+
+## Install
+
+```
+$ npm install ansi-styles
+```
+
+## Usage
+
+```js
+const style = require('ansi-styles');
+
+console.log(`${style.green.open}Hello world!${style.green.close}`);
+
+
+// Color conversion between 16/256/truecolor
+// NOTE: If conversion goes to 16 colors or 256 colors, the original color
+// may be degraded to fit that color palette. This means terminals
+// that do not support 16 million colors will best-match the
+// original color.
+console.log(style.bgColor.ansi.hsl(120, 80, 72) + 'Hello world!' + style.bgColor.close);
+console.log(style.color.ansi256.rgb(199, 20, 250) + 'Hello world!' + style.color.close);
+console.log(style.color.ansi16m.hex('#abcdef') + 'Hello world!' + style.color.close);
+```
+
+## API
+
+Each style has an `open` and `close` property.
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(Not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(Not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Advanced usage
+
+By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
+
+- `style.modifier`
+- `style.color`
+- `style.bgColor`
+
+###### Example
+
+```js
+console.log(style.color.green.open);
+```
+
+Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
+
+###### Example
+
+```js
+console.log(style.codes.get(36));
+//=> 39
+```
+
+## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728)
+
+`ansi-styles` uses the [`color-convert`](https://github.com/Qix-/color-convert) package to allow for converting between various colors and ANSI escapes, with support for 256 and 16 million colors.
+
+The following color spaces from `color-convert` are supported:
+
+- `rgb`
+- `hex`
+- `keyword`
+- `hsl`
+- `hsv`
+- `hwb`
+- `ansi`
+- `ansi256`
+
+To use these, call the associated conversion function with the intended output, for example:
+
+```js
+style.color.ansi.rgb(100, 200, 15); // RGB to 16 color ansi foreground code
+style.bgColor.ansi.rgb(100, 200, 15); // RGB to 16 color ansi background code
+
+style.color.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+style.bgColor.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+
+style.color.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color foreground code
+style.bgColor.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color background code
+```
+
+## Related
+
+- [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+## For enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of `ansi-styles` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-ansi-styles?utm_source=npm-ansi-styles&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/emoji-regex/LICENSE-MIT.txt b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/emoji-regex/LICENSE-MIT.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a41e0a7ef970ecdd83d82cd99bda97b22077bc62
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/emoji-regex/LICENSE-MIT.txt
@@ -0,0 +1,20 @@
+Copyright Mathias Bynens
+
+ Get professional support for this package with a Tidelift subscription
+
+
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/index.d.ts b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..907fccc29269ebcd49141fa8a4513be3b6a8d270
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/index.d.ts
@@ -0,0 +1,17 @@
+/**
+Strip [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code) from a string.
+
+@example
+```
+import stripAnsi = require('strip-ansi');
+
+stripAnsi('\u001B[4mUnicorn\u001B[0m');
+//=> 'Unicorn'
+
+stripAnsi('\u001B]8;;https://github.com\u0007Click\u001B]8;;\u0007');
+//=> 'Click'
+```
+*/
+declare function stripAnsi(string: string): string;
+
+export = stripAnsi;
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/index.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a593dfcd1fd5c9e627d9ff2ed85a88df9a41a99
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/index.js
@@ -0,0 +1,4 @@
+'use strict';
+const ansiRegex = require('ansi-regex');
+
+module.exports = string => typeof string === 'string' ? string.replace(ansiRegex(), '') : string;
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/license b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/license
new file mode 100644
index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/node_modules/wrap-ansi-cjs/node_modules/strip-ansi/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus + + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
+
+ Get professional support for this package with a Tidelift subscription
+
+
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/LICENSE b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..d645695673349e3947e8e5ae42332d0ac3164cd7
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/README.md b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1463c9f6289d6aec71987d5299b8806af4821fb4
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/README.md
@@ -0,0 +1,218 @@
+# @ampproject/remapping
+
+> Remap sequential sourcemaps through transformations to point at the original source code
+
+Remapping allows you to take the sourcemaps generated through transforming your code and "remap"
+them to the original source locations. Think "my minified code, transformed with babel and bundled
+with webpack", all pointing to the correct location in your original source code.
+
+With remapping, none of your source code transformations need to be aware of the input's sourcemap,
+they only need to generate an output sourcemap. This greatly simplifies building custom
+transformations (think a find-and-replace).
+
+## Installation
+
+```sh
+npm install @ampproject/remapping
+```
+
+## Usage
+
+```typescript
+function remapping(
+ map: SourceMap | SourceMap[],
+ loader: (file: string, ctx: LoaderContext) => (SourceMap | null | undefined),
+ options?: { excludeContent: boolean, decodedMappings: boolean }
+): SourceMap;
+
+// LoaderContext gives the loader the importing sourcemap, tree depth, the ability to override the
+// "source" location (where child sources are resolved relative to, or the location of original
+// source), and the ability to override the "content" of an original source for inclusion in the
+// output sourcemap.
+type LoaderContext = {
+ readonly importer: string;
+ readonly depth: number;
+ source: string;
+ content: string | null | undefined;
+}
+```
+
+`remapping` takes the final output sourcemap, and a `loader` function. For every source file pointer
+in the sourcemap, the `loader` will be called with the resolved path. If the path itself represents
+a transformed file (it has a sourcmap associated with it), then the `loader` should return that
+sourcemap. If not, the path will be treated as an original, untransformed source code.
+
+```js
+// Babel transformed "helloworld.js" into "transformed.js"
+const transformedMap = JSON.stringify({
+ file: 'transformed.js',
+ // 1st column of 2nd line of output file translates into the 1st source
+ // file, line 3, column 2
+ mappings: ';CAEE',
+ sources: ['helloworld.js'],
+ version: 3,
+});
+
+// Uglify minified "transformed.js" into "transformed.min.js"
+const minifiedTransformedMap = JSON.stringify({
+ file: 'transformed.min.js',
+ // 0th column of 1st line of output file translates into the 1st source
+ // file, line 2, column 1.
+ mappings: 'AACC',
+ names: [],
+ sources: ['transformed.js'],
+ version: 3,
+});
+
+const remapped = remapping(
+ minifiedTransformedMap,
+ (file, ctx) => {
+
+ // The "transformed.js" file is an transformed file.
+ if (file === 'transformed.js') {
+ // The root importer is empty.
+ console.assert(ctx.importer === '');
+ // The depth in the sourcemap tree we're currently loading.
+ // The root `minifiedTransformedMap` is depth 0, and its source children are depth 1, etc.
+ console.assert(ctx.depth === 1);
+
+ return transformedMap;
+ }
+
+ // Loader will be called to load transformedMap's source file pointers as well.
+ console.assert(file === 'helloworld.js');
+ // `transformed.js`'s sourcemap points into `helloworld.js`.
+ console.assert(ctx.importer === 'transformed.js');
+ // This is a source child of `transformed`, which is a source child of `minifiedTransformedMap`.
+ console.assert(ctx.depth === 2);
+ return null;
+ }
+);
+
+console.log(remapped);
+// {
+// file: 'transpiled.min.js',
+// mappings: 'AAEE',
+// sources: ['helloworld.js'],
+// version: 3,
+// };
+```
+
+In this example, `loader` will be called twice:
+
+1. `"transformed.js"`, the first source file pointer in the `minifiedTransformedMap`. We return the
+ associated sourcemap for it (its a transformed file, after all) so that sourcemap locations can
+ be traced through it into the source files it represents.
+2. `"helloworld.js"`, our original, unmodified source code. This file does not have a sourcemap, so
+ we return `null`.
+
+The `remapped` sourcemap now points from `transformed.min.js` into locations in `helloworld.js`. If
+you were to read the `mappings`, it says "0th column of the first line output line points to the 1st
+column of the 2nd line of the file `helloworld.js`".
+
+### Multiple transformations of a file
+
+As a convenience, if you have multiple single-source transformations of a file, you may pass an
+array of sourcemap files in the order of most-recent transformation sourcemap first. Note that this
+changes the `importer` and `depth` of each call to our loader. So our above example could have been
+written as:
+
+```js
+const remapped = remapping(
+ [minifiedTransformedMap, transformedMap],
+ () => null
+);
+
+console.log(remapped);
+// {
+// file: 'transpiled.min.js',
+// mappings: 'AAEE',
+// sources: ['helloworld.js'],
+// version: 3,
+// };
+```
+
+### Advanced control of the loading graph
+
+#### `source`
+
+The `source` property can overridden to any value to change the location of the current load. Eg,
+for an original source file, it allows us to change the location to the original source regardless
+of what the sourcemap source entry says. And for transformed files, it allows us to change the
+relative resolving location for child sources of the loaded sourcemap.
+
+```js
+const remapped = remapping(
+ minifiedTransformedMap,
+ (file, ctx) => {
+
+ if (file === 'transformed.js') {
+ // We pretend the transformed.js file actually exists in the 'src/' directory. When the nested
+ // source files are loaded, they will now be relative to `src/`.
+ ctx.source = 'src/transformed.js';
+ return transformedMap;
+ }
+
+ console.assert(file === 'src/helloworld.js');
+ // We could futher change the source of this original file, eg, to be inside a nested directory
+ // itself. This will be reflected in the remapped sourcemap.
+ ctx.source = 'src/nested/transformed.js';
+ return null;
+ }
+);
+
+console.log(remapped);
+// {
+// …,
+// sources: ['src/nested/helloworld.js'],
+// };
+```
+
+
+#### `content`
+
+The `content` property can be overridden when we encounter an original source file. Eg, this allows
+you to manually provide the source content of the original file regardless of whether the
+`sourcesContent` field is present in the parent sourcemap. It can also be set to `null` to remove
+the source content.
+
+```js
+const remapped = remapping(
+ minifiedTransformedMap,
+ (file, ctx) => {
+
+ if (file === 'transformed.js') {
+ // transformedMap does not include a `sourcesContent` field, so usually the remapped sourcemap
+ // would not include any `sourcesContent` values.
+ return transformedMap;
+ }
+
+ console.assert(file === 'helloworld.js');
+ // We can read the file to provide the source content.
+ ctx.content = fs.readFileSync(file, 'utf8');
+ return null;
+ }
+);
+
+console.log(remapped);
+// {
+// …,
+// sourcesContent: [
+// 'console.log("Hello world!")',
+// ],
+// };
+```
+
+### Options
+
+#### excludeContent
+
+By default, `excludeContent` is `false`. Passing `{ excludeContent: true }` will exclude the
+`sourcesContent` field from the returned sourcemap. This is mainly useful when you want to reduce
+the size out the sourcemap.
+
+#### decodedMappings
+
+By default, `decodedMappings` is `false`. Passing `{ decodedMappings: true }` will leave the
+`mappings` field in a [decoded state](https://github.com/rich-harris/sourcemap-codec) instead of
+encoding into a VLQ string.
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/dist/remapping.mjs b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/dist/remapping.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..f3875999c027f75f69e1b22f7d8fedb1eceef63e
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/dist/remapping.mjs
@@ -0,0 +1,197 @@
+import { decodedMappings, traceSegment, TraceMap } from '@jridgewell/trace-mapping';
+import { GenMapping, maybeAddSegment, setSourceContent, setIgnore, toDecodedMap, toEncodedMap } from '@jridgewell/gen-mapping';
+
+const SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);
+const EMPTY_SOURCES = [];
+function SegmentObject(source, line, column, name, content, ignore) {
+ return { source, line, column, name, content, ignore };
+}
+function Source(map, sources, source, content, ignore) {
+ return {
+ map,
+ sources,
+ source,
+ content,
+ ignore,
+ };
+}
+/**
+ * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes
+ * (which may themselves be SourceMapTrees).
+ */
+function MapSource(map, sources) {
+ return Source(map, sources, '', null, false);
+}
+/**
+ * A "leaf" node in the sourcemap tree, representing an original, unmodified source file. Recursive
+ * segment tracing ends at the `OriginalSource`.
+ */
+function OriginalSource(source, content, ignore) {
+ return Source(null, EMPTY_SOURCES, source, content, ignore);
+}
+/**
+ * traceMappings is only called on the root level SourceMapTree, and begins the process of
+ * resolving each mapping in terms of the original source files.
+ */
+function traceMappings(tree) {
+ // TODO: Eventually support sourceRoot, which has to be removed because the sources are already
+ // fully resolved. We'll need to make sources relative to the sourceRoot before adding them.
+ const gen = new GenMapping({ file: tree.map.file });
+ const { sources: rootSources, map } = tree;
+ const rootNames = map.names;
+ const rootMappings = decodedMappings(map);
+ for (let i = 0; i < rootMappings.length; i++) {
+ const segments = rootMappings[i];
+ for (let j = 0; j < segments.length; j++) {
+ const segment = segments[j];
+ const genCol = segment[0];
+ let traced = SOURCELESS_MAPPING;
+ // 1-length segments only move the current generated column, there's no source information
+ // to gather from it.
+ if (segment.length !== 1) {
+ const source = rootSources[segment[1]];
+ traced = originalPositionFor(source, segment[2], segment[3], segment.length === 5 ? rootNames[segment[4]] : '');
+ // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a
+ // respective segment into an original source.
+ if (traced == null)
+ continue;
+ }
+ const { column, line, name, content, source, ignore } = traced;
+ maybeAddSegment(gen, i, genCol, source, line, column, name);
+ if (source && content != null)
+ setSourceContent(gen, source, content);
+ if (ignore)
+ setIgnore(gen, source, true);
+ }
+ }
+ return gen;
+}
+/**
+ * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own
+ * child SourceMapTrees, until we find the original source map.
+ */
+function originalPositionFor(source, line, column, name) {
+ if (!source.map) {
+ return SegmentObject(source.source, line, column, name, source.content, source.ignore);
+ }
+ const segment = traceSegment(source.map, line, column);
+ // If we couldn't find a segment, then this doesn't exist in the sourcemap.
+ if (segment == null)
+ return null;
+ // 1-length segments only move the current generated column, there's no source information
+ // to gather from it.
+ if (segment.length === 1)
+ return SOURCELESS_MAPPING;
+ return originalPositionFor(source.sources[segment[1]], segment[2], segment[3], segment.length === 5 ? source.map.names[segment[4]] : name);
+}
+
+function asArray(value) {
+ if (Array.isArray(value))
+ return value;
+ return [value];
+}
+/**
+ * Recursively builds a tree structure out of sourcemap files, with each node
+ * being either an `OriginalSource` "leaf" or a `SourceMapTree` composed of
+ * `OriginalSource`s and `SourceMapTree`s.
+ *
+ * Every sourcemap is composed of a collection of source files and mappings
+ * into locations of those source files. When we generate a `SourceMapTree` for
+ * the sourcemap, we attempt to load each source file's own sourcemap. If it
+ * does not have an associated sourcemap, it is considered an original,
+ * unmodified source file.
+ */
+function buildSourceMapTree(input, loader) {
+ const maps = asArray(input).map((m) => new TraceMap(m, ''));
+ const map = maps.pop();
+ for (let i = 0; i < maps.length; i++) {
+ if (maps[i].sources.length > 1) {
+ throw new Error(`Transformation map ${i} must have exactly one source file.\n` +
+ 'Did you specify these with the most recent transformation maps first?');
+ }
+ }
+ let tree = build(map, loader, '', 0);
+ for (let i = maps.length - 1; i >= 0; i--) {
+ tree = MapSource(maps[i], [tree]);
+ }
+ return tree;
+}
+function build(map, loader, importer, importerDepth) {
+ const { resolvedSources, sourcesContent, ignoreList } = map;
+ const depth = importerDepth + 1;
+ const children = resolvedSources.map((sourceFile, i) => {
+ // The loading context gives the loader more information about why this file is being loaded
+ // (eg, from which importer). It also allows the loader to override the location of the loaded
+ // sourcemap/original source, or to override the content in the sourcesContent field if it's
+ // an unmodified source file.
+ const ctx = {
+ importer,
+ depth,
+ source: sourceFile || '',
+ content: undefined,
+ ignore: undefined,
+ };
+ // Use the provided loader callback to retrieve the file's sourcemap.
+ // TODO: We should eventually support async loading of sourcemap files.
+ const sourceMap = loader(ctx.source, ctx);
+ const { source, content, ignore } = ctx;
+ // If there is a sourcemap, then we need to recurse into it to load its source files.
+ if (sourceMap)
+ return build(new TraceMap(sourceMap, source), loader, source, depth);
+ // Else, it's an unmodified source file.
+ // The contents of this unmodified source file can be overridden via the loader context,
+ // allowing it to be explicitly null or a string. If it remains undefined, we fall back to
+ // the importing sourcemap's `sourcesContent` field.
+ const sourceContent = content !== undefined ? content : sourcesContent ? sourcesContent[i] : null;
+ const ignored = ignore !== undefined ? ignore : ignoreList ? ignoreList.includes(i) : false;
+ return OriginalSource(source, sourceContent, ignored);
+ });
+ return MapSource(map, children);
+}
+
+/**
+ * A SourceMap v3 compatible sourcemap, which only includes fields that were
+ * provided to it.
+ */
+class SourceMap {
+ constructor(map, options) {
+ const out = options.decodedMappings ? toDecodedMap(map) : toEncodedMap(map);
+ this.version = out.version; // SourceMap spec says this should be first.
+ this.file = out.file;
+ this.mappings = out.mappings;
+ this.names = out.names;
+ this.ignoreList = out.ignoreList;
+ this.sourceRoot = out.sourceRoot;
+ this.sources = out.sources;
+ if (!options.excludeContent) {
+ this.sourcesContent = out.sourcesContent;
+ }
+ }
+ toString() {
+ return JSON.stringify(this);
+ }
+}
+
+/**
+ * Traces through all the mappings in the root sourcemap, through the sources
+ * (and their sourcemaps), all the way back to the original source location.
+ *
+ * `loader` will be called every time we encounter a source file. If it returns
+ * a sourcemap, we will recurse into that sourcemap to continue the trace. If
+ * it returns a falsey value, that source file is treated as an original,
+ * unmodified source file.
+ *
+ * Pass `excludeContent` to exclude any self-containing source file content
+ * from the output sourcemap.
+ *
+ * Pass `decodedMappings` to receive a SourceMap with decoded (instead of
+ * VLQ encoded) mappings.
+ */
+function remapping(input, loader, options) {
+ const opts = typeof options === 'object' ? options : { excludeContent: !!options, decodedMappings: false };
+ const tree = buildSourceMapTree(input, loader);
+ return new SourceMap(traceMappings(tree), opts);
+}
+
+export { remapping as default };
+//# sourceMappingURL=remapping.mjs.map
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/dist/remapping.mjs.map b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/dist/remapping.mjs.map
new file mode 100644
index 0000000000000000000000000000000000000000..0eb007bfdf5fd31d2d2292e7e24fbd7e859a06d8
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/@ampproject/remapping/dist/remapping.mjs.map
@@ -0,0 +1 @@
+{"version":3,"file":"remapping.mjs","sources":["../src/source-map-tree.ts","../src/build-source-map-tree.ts","../src/source-map.ts","../src/remapping.ts"],"sourcesContent":["import { GenMapping, maybeAddSegment, setIgnore, setSourceContent } from '@jridgewell/gen-mapping';\nimport { traceSegment, decodedMappings } from '@jridgewell/trace-mapping';\n\nimport type { TraceMap } from '@jridgewell/trace-mapping';\n\nexport type SourceMapSegmentObject = {\n column: number;\n line: number;\n name: string;\n source: string;\n content: string | null;\n ignore: boolean;\n};\n\nexport type OriginalSource = {\n map: null;\n sources: Sources[];\n source: string;\n content: string | null;\n ignore: boolean;\n};\n\nexport type MapSource = {\n map: TraceMap;\n sources: Sources[];\n source: string;\n content: null;\n ignore: false;\n};\n\nexport type Sources = OriginalSource | MapSource;\n\nconst SOURCELESS_MAPPING = /* #__PURE__ */ SegmentObject('', -1, -1, '', null, false);\nconst EMPTY_SOURCES: Sources[] = [];\n\nfunction SegmentObject(\n source: string,\n line: number,\n column: number,\n name: string,\n content: string | null,\n ignore: boolean\n): SourceMapSegmentObject {\n return { source, line, column, name, content, ignore };\n}\n\nfunction Source(\n map: TraceMap,\n sources: Sources[],\n source: '',\n content: null,\n ignore: false\n): MapSource;\nfunction Source(\n map: null,\n sources: Sources[],\n source: string,\n content: string | null,\n ignore: boolean\n): OriginalSource;\nfunction Source(\n map: TraceMap | null,\n sources: Sources[],\n source: string | '',\n content: string | null,\n ignore: boolean\n): Sources {\n return {\n map,\n sources,\n source,\n content,\n ignore,\n } as any;\n}\n\n/**\n * MapSource represents a single sourcemap, with the ability to trace mappings into its child nodes\n * (which may themselves be SourceMapTrees).\n */\nexport function MapSource(map: TraceMap, sources: Sources[]): MapSource {\n return Source(map, sources, '', null, false);\n}\n\n/**\n * A \"leaf\" node in the sourcemap tree, representing an original, unmodified source file. Recursive\n * segment tracing ends at the `OriginalSource`.\n */\nexport function OriginalSource(\n source: string,\n content: string | null,\n ignore: boolean\n): OriginalSource {\n return Source(null, EMPTY_SOURCES, source, content, ignore);\n}\n\n/**\n * traceMappings is only called on the root level SourceMapTree, and begins the process of\n * resolving each mapping in terms of the original source files.\n */\nexport function traceMappings(tree: MapSource): GenMapping {\n // TODO: Eventually support sourceRoot, which has to be removed because the sources are already\n // fully resolved. We'll need to make sources relative to the sourceRoot before adding them.\n const gen = new GenMapping({ file: tree.map.file });\n const { sources: rootSources, map } = tree;\n const rootNames = map.names;\n const rootMappings = decodedMappings(map);\n\n for (let i = 0; i < rootMappings.length; i++) {\n const segments = rootMappings[i];\n\n for (let j = 0; j < segments.length; j++) {\n const segment = segments[j];\n const genCol = segment[0];\n let traced: SourceMapSegmentObject | null = SOURCELESS_MAPPING;\n\n // 1-length segments only move the current generated column, there's no source information\n // to gather from it.\n if (segment.length !== 1) {\n const source = rootSources[segment[1]];\n traced = originalPositionFor(\n source,\n segment[2],\n segment[3],\n segment.length === 5 ? rootNames[segment[4]] : ''\n );\n\n // If the trace is invalid, then the trace ran into a sourcemap that doesn't contain a\n // respective segment into an original source.\n if (traced == null) continue;\n }\n\n const { column, line, name, content, source, ignore } = traced;\n\n maybeAddSegment(gen, i, genCol, source, line, column, name);\n if (source && content != null) setSourceContent(gen, source, content);\n if (ignore) setIgnore(gen, source, true);\n }\n }\n\n return gen;\n}\n\n/**\n * originalPositionFor is only called on children SourceMapTrees. It recurses down into its own\n * child SourceMapTrees, until we find the original source map.\n */\nexport function originalPositionFor(\n source: Sources,\n line: number,\n column: number,\n name: string\n): SourceMapSegmentObject | null {\n if (!source.map) {\n return SegmentObject(source.source, line, column, name, source.content, source.ignore);\n }\n\n const segment = traceSegment(source.map, line, column);\n\n // If we couldn't find a segment, then this doesn't exist in the sourcemap.\n if (segment == null) return null;\n // 1-length segments only move the current generated column, there's no source information\n // to gather from it.\n if (segment.length === 1) return SOURCELESS_MAPPING;\n\n return originalPositionFor(\n source.sources[segment[1]],\n segment[2],\n segment[3],\n segment.length === 5 ? source.map.names[segment[4]] : name\n );\n}\n","import { TraceMap } from '@jridgewell/trace-mapping';\n\nimport { OriginalSource, MapSource } from './source-map-tree';\n\nimport type { Sources, MapSource as MapSourceType } from './source-map-tree';\nimport type { SourceMapInput, SourceMapLoader, LoaderContext } from './types';\n\nfunction asArray+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
{/* foo */}
+```
+
+Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy)
+
+When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.
+
+Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant)
+
+Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray)
+
+### :house: Internal
+
+User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder)
+
+Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo)
+
+Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine)
+
+Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder)
+
+Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine)
+
+Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU)
+
+Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot])
+
+chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot])
+
+chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot])
+
+## 6.14.1 (2016-11-17)
+
+### :bug: Bug Fix
+
+Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder)
+
+```js
+{
+ "plugins": ["*"]
+}
+```
+
+Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.
+
+## 6.14.0 (2016-11-16)
+
+### :eyeglasses: Spec Compliance
+
+Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
+
+[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words)
+
+Babylon will throw for more reserved words such as `enum` or `await` (in strict mode).
+
+```
+class enum {} // throws
+class await {} // throws in strict mode (module)
+```
+
+Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi)
+
+So where you used to have to write
+
+```js
+type A = (x: string, y: boolean) => number;
+type B = (z: string) => number;
+type C = { [key: string]: number };
+```
+
+you can now write (with flow 0.34.0)
+
+```js
+type A = (string, boolean) => number;
+type B = string => number;
+type C = { [string]: number };
+```
+
+Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner)
+
+Supports these form now of specifying array types:
+
+```js
+var a: number[][][][];
+var b: string[][];
+```
+
+### :bug: Bug Fix
+
+Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223)) (Daniel Tschinder)
+
+```
+declare module "foo" { declare module.exports: number }
+declare module "foo" { declare module.exports: number; } // also allowed now
+```
+
+### :house: Internal
+
+ * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman)
+ * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger)
+ * Add node 7 (Daniel Tschinder)
+ * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper)
+
+## v6.13.1 (2016-10-26)
+
+### :nail_care: Polish
+
+- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML))
+
+```js
+const babylon = require('babylon');
+const ast = babylon.parse('var foo = "lol";');
+```
+
+With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.
+
+**Without bundling**
+
+
+**With bundling**
+
+
+- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu)
+- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu)
+
+## v6.13.0 (2016-10-21)
+
+### :eyeglasses: Spec Compliance
+
+Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
+
+> See https://flowtype.org/docs/variance.html for more information
+
+```js
+type T = { +p: T };
+interface T { -p: T };
+declare class T { +[k:K]: V };
+class T { -[k:K]: V };
+class C2 { +p: T = e };
+```
+
+Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman)
+
+```js
+({ __proto__: 1, __proto__: 2 }) // Throws an error now
+```
+
+### :bug: Bug Fix
+
+Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman)
+
+```js
+declare class A {
+ static: T;
+}
+```
+
+Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine)
+
+```js
+var foo = { async, bar };
+```
+
+### :nail_care: Polish
+
+Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder)
+
+> This improves the performance slightly (because of hidden classes)
+
+### :house: Internal
+
+Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman)
+
+Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman)
+
+Readd missin .eslinignore for IDEs (Daniel Tschinder)
+
+Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman)
+
+Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman)
+
+Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman)
+
+## v6.12.0 (2016-10-14)
+
+### :eyeglasses: Spec Compliance
+
+Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
+
+#### Dynamic Import
+
+- Proposal Repo: https://github.com/domenic/proposal-dynamic-import
+- Championed by [@domenic](https://github.com/domenic)
+- stage-2
+- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import)
+
+> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript
+
+```js
+import(`./section-modules/${link.dataset.entryModule}.js`)
+.then(module => {
+ module.loadPageInto(main);
+})
+```
+
+Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman)
+
+#### EmptyTypeAnnotation
+
+Just wasn't covered before.
+
+```js
+type T = empty;
+```
+
+### :bug: Bug Fix
+
+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
+
+```js
+// was failing due to sparse array
+export const { foo: [ ,, qux7 ] } = bar;
+```
+
+Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper)
+
+```js
+declare class X {
+ foobar
+ {...todos.map(todo => )}
+
+```
+
+- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez
+
+```js
+declare module "foo" {
+ declare module.exports: {}
+}
+```
+
+### New Features
+
+- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain
+- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens
+
+### Bug Fixes
+
+- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez
+- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez
+- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi
+- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez
+- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi
+- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez
+- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez
+
+### Internal
+
+- Add codecoverage to tests @danez
+- Fix tests to not save expected output if we expect the test to fail @danez
+- Make a shallow clone of babel for testing @danez
+- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot
+- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot
+- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot
+- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot
+
+## 6.8.4 (2016-07-06)
+
+### Bug Fixes
+
+- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez
+
+## 6.8.3 (2016-07-02)
+
+### Bug Fixes
+
+- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez
+
+## 6.8.2 (2016-06-24)
+
+### Bug Fixes
+
+- Fix parse error with yielding jsx elements in generators `function* it() { yield ; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal
+- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez
+- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez
+- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez
+- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez
+- Support negative numeric type literals @kittens
+- Remove line terminator restriction after await keyword @kittens
+- Remove grouped type arrow restriction as it seems flow no longer has it @kittens
+- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin
+- Fix parse error with arrow functions that have flow type parameter declarations `
+
+# Ajv: Another JSON Schema Validator
+
+The fastest JSON Schema validator for Node.js and browser. Supports draft-04/06/07.
+
+[](https://travis-ci.org/ajv-validator/ajv)
+[](https://www.npmjs.com/package/ajv)
+[](https://www.npmjs.com/package/ajv/v/7.0.0-beta.0)
+[](https://www.npmjs.com/package/ajv)
+[](https://coveralls.io/github/ajv-validator/ajv?branch=master)
+[](https://gitter.im/ajv-validator/ajv)
+[](https://github.com/sponsors/epoberezkin)
+
+
+## Ajv v7 beta is released
+
+[Ajv version 7.0.0-beta.0](https://github.com/ajv-validator/ajv/tree/v7-beta) is released with these changes:
+
+- to reduce the mistakes in JSON schemas and unexpected validation results, [strict mode](./docs/strict-mode.md) is added - it prohibits ignored or ambiguous JSON Schema elements.
+- to make code injection from untrusted schemas impossible, [code generation](./docs/codegen.md) is fully re-written to be safe.
+- to simplify Ajv extensions, the new keyword API that is used by pre-defined keywords is available to user-defined keywords - it is much easier to define any keywords now, especially with subschemas.
+- schemas are compiled to ES6 code (ES5 code generation is supported with an option).
+- to improve reliability and maintainability the code is migrated to TypeScript.
+
+**Please note**:
+
+- the support for JSON-Schema draft-04 is removed - if you have schemas using "id" attributes you have to replace them with "\$id" (or continue using version 6 that will be supported until 02/28/2021).
+- all formats are separated to ajv-formats package - they have to be explicitely added if you use them.
+
+See [release notes](https://github.com/ajv-validator/ajv/releases/tag/v7.0.0-beta.0) for the details.
+
+To install the new version:
+
+```bash
+npm install ajv@beta
+```
+
+See [Getting started with v7](https://github.com/ajv-validator/ajv/tree/v7-beta#usage) for code example.
+
+
+## Mozilla MOSS grant and OpenJS Foundation
+
+[
](https://www.mozilla.org/en-US/moss/) [
](https://openjsf.org/blog/2020/08/14/ajv-joins-openjs-foundation-as-an-incubation-project/)
+
+Ajv has been awarded a grant from Mozilla’s [Open Source Support (MOSS) program](https://www.mozilla.org/en-US/moss/) in the “Foundational Technology” track! It will sponsor the development of Ajv support of [JSON Schema version 2019-09](https://tools.ietf.org/html/draft-handrews-json-schema-02) and of [JSON Type Definition](https://tools.ietf.org/html/draft-ucarion-json-type-definition-04).
+
+Ajv also joined [OpenJS Foundation](https://openjsf.org/) – having this support will help ensure the longevity and stability of Ajv for all its users.
+
+This [blog post](https://www.poberezkin.com/posts/2020-08-14-ajv-json-validator-mozilla-open-source-grant-openjs-foundation.html) has more details.
+
+I am looking for the long term maintainers of Ajv – working with [ReadySet](https://www.thereadyset.co/), also sponsored by Mozilla, to establish clear guidelines for the role of a "maintainer" and the contribution standards, and to encourage a wider, more inclusive, contribution from the community.
+
+
+## Please [sponsor Ajv development](https://github.com/sponsors/epoberezkin)
+
+Since I asked to support Ajv development 40 people and 6 organizations contributed via GitHub and OpenCollective - this support helped receiving the MOSS grant!
+
+Your continuing support is very important - the funds will be used to develop and maintain Ajv once the next major version is released.
+
+Please sponsor Ajv via:
+- [GitHub sponsors page](https://github.com/sponsors/epoberezkin) (GitHub will match it)
+- [Ajv Open Collective️](https://opencollective.com/ajv)
+
+Thank you.
+
+
+#### Open Collective sponsors
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Using version 6
+
+[JSON Schema draft-07](http://json-schema.org/latest/json-schema-validation.html) is published.
+
+[Ajv version 6.0.0](https://github.com/ajv-validator/ajv/releases/tag/v6.0.0) that supports draft-07 is released. It may require either migrating your schemas or updating your code (to continue using draft-04 and v5 schemas, draft-06 schemas will be supported without changes).
+
+__Please note__: To use Ajv with draft-06 schemas you need to explicitly add the meta-schema to the validator instance:
+
+```javascript
+ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-06.json'));
+```
+
+To use Ajv with draft-04 schemas in addition to explicitly adding meta-schema you also need to use option schemaId:
+
+```javascript
+var ajv = new Ajv({schemaId: 'id'});
+// If you want to use both draft-04 and draft-06/07 schemas:
+// var ajv = new Ajv({schemaId: 'auto'});
+ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json'));
+```
+
+
+## Contents
+
+- [Performance](#performance)
+- [Features](#features)
+- [Getting started](#getting-started)
+- [Frequently Asked Questions](https://github.com/ajv-validator/ajv/blob/master/FAQ.md)
+- [Using in browser](#using-in-browser)
+ - [Ajv and Content Security Policies (CSP)](#ajv-and-content-security-policies-csp)
+- [Command line interface](#command-line-interface)
+- Validation
+ - [Keywords](#validation-keywords)
+ - [Annotation keywords](#annotation-keywords)
+ - [Formats](#formats)
+ - [Combining schemas with $ref](#ref)
+ - [$data reference](#data-reference)
+ - NEW: [$merge and $patch keywords](#merge-and-patch-keywords)
+ - [Defining custom keywords](#defining-custom-keywords)
+ - [Asynchronous schema compilation](#asynchronous-schema-compilation)
+ - [Asynchronous validation](#asynchronous-validation)
+- [Security considerations](#security-considerations)
+ - [Security contact](#security-contact)
+ - [Untrusted schemas](#untrusted-schemas)
+ - [Circular references in objects](#circular-references-in-javascript-objects)
+ - [Trusted schemas](#security-risks-of-trusted-schemas)
+ - [ReDoS attack](#redos-attack)
+- Modifying data during validation
+ - [Filtering data](#filtering-data)
+ - [Assigning defaults](#assigning-defaults)
+ - [Coercing data types](#coercing-data-types)
+- API
+ - [Methods](#api)
+ - [Options](#options)
+ - [Validation errors](#validation-errors)
+- [Plugins](#plugins)
+- [Related packages](#related-packages)
+- [Some packages using Ajv](#some-packages-using-ajv)
+- [Tests, Contributing, Changes history](#tests)
+- [Support, Code of conduct, License](#open-source-software-support)
+
+
+## Performance
+
+Ajv generates code using [doT templates](https://github.com/olado/doT) to turn JSON Schemas into super-fast validation functions that are efficient for v8 optimization.
+
+Currently Ajv is the fastest and the most standard compliant validator according to these benchmarks:
+
+- [json-schema-benchmark](https://github.com/ebdrup/json-schema-benchmark) - 50% faster than the second place
+- [jsck benchmark](https://github.com/pandastrike/jsck#benchmarks) - 20-190% faster
+- [z-schema benchmark](https://rawgit.com/zaggino/z-schema/master/benchmark/results.html)
+- [themis benchmark](https://cdn.rawgit.com/playlyfe/themis/master/benchmark/results.html)
+
+
+Performance of different validators by [json-schema-benchmark](https://github.com/ebdrup/json-schema-benchmark):
+
+[](https://github.com/ebdrup/json-schema-benchmark/blob/master/README.md#performance)
+
+
+## Features
+
+- Ajv implements full JSON Schema [draft-06/07](http://json-schema.org/) and draft-04 standards:
+ - all validation keywords (see [JSON Schema validation keywords](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md))
+ - full support of remote refs (remote schemas have to be added with `addSchema` or compiled to be available)
+ - support of circular references between schemas
+ - correct string lengths for strings with unicode pairs (can be turned off)
+ - [formats](#formats) defined by JSON Schema draft-07 standard and custom formats (can be turned off)
+ - [validates schemas against meta-schema](#api-validateschema)
+- supports [browsers](#using-in-browser) and Node.js 0.10-14.x
+- [asynchronous loading](#asynchronous-schema-compilation) of referenced schemas during compilation
+- "All errors" validation mode with [option allErrors](#options)
+- [error messages with parameters](#validation-errors) describing error reasons to allow creating custom error messages
+- i18n error messages support with [ajv-i18n](https://github.com/ajv-validator/ajv-i18n) package
+- [filtering data](#filtering-data) from additional properties
+- [assigning defaults](#assigning-defaults) to missing properties and items
+- [coercing data](#coercing-data-types) to the types specified in `type` keywords
+- [custom keywords](#defining-custom-keywords)
+- draft-06/07 keywords `const`, `contains`, `propertyNames` and `if/then/else`
+- draft-06 boolean schemas (`true`/`false` as a schema to always pass/fail).
+- keywords `switch`, `patternRequired`, `formatMaximum` / `formatMinimum` and `formatExclusiveMaximum` / `formatExclusiveMinimum` from [JSON Schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) with [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package
+- [$data reference](#data-reference) to use values from the validated data as values for the schema keywords
+- [asynchronous validation](#asynchronous-validation) of custom formats and keywords
+
+
+## Install
+
+```
+npm install ajv
+```
+
+
+## Getting started
+
+Try it in the Node.js REPL: https://tonicdev.com/npm/ajv
+
+
+The fastest validation call:
+
+```javascript
+// Node.js require:
+var Ajv = require('ajv');
+// or ESM/TypeScript import
+import Ajv from 'ajv';
+
+var ajv = new Ajv(); // options can be passed, e.g. {allErrors: true}
+var validate = ajv.compile(schema);
+var valid = validate(data);
+if (!valid) console.log(validate.errors);
+```
+
+or with less code
+
+```javascript
+// ...
+var valid = ajv.validate(schema, data);
+if (!valid) console.log(ajv.errors);
+// ...
+```
+
+or
+
+```javascript
+// ...
+var valid = ajv.addSchema(schema, 'mySchema')
+ .validate('mySchema', data);
+if (!valid) console.log(ajv.errorsText());
+// ...
+```
+
+See [API](#api) and [Options](#options) for more details.
+
+Ajv compiles schemas to functions and caches them in all cases (using schema serialized with [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) or a custom function as a key), so that the next time the same schema is used (not necessarily the same object instance) it won't be compiled again.
+
+The best performance is achieved when using compiled functions returned by `compile` or `getSchema` methods (there is no additional function call).
+
+__Please note__: every time a validation function or `ajv.validate` are called `errors` property is overwritten. You need to copy `errors` array reference to another variable if you want to use it later (e.g., in the callback). See [Validation errors](#validation-errors)
+
+__Note for TypeScript users__: `ajv` provides its own TypeScript declarations
+out of the box, so you don't need to install the deprecated `@types/ajv`
+module.
+
+
+## Using in browser
+
+You can require Ajv directly from the code you browserify - in this case Ajv will be a part of your bundle.
+
+If you need to use Ajv in several bundles you can create a separate UMD bundle using `npm run bundle` script (thanks to [siddo420](https://github.com/siddo420)).
+
+Then you need to load Ajv in the browser:
+```html
+
+```
+
+This bundle can be used with different module systems; it creates global `Ajv` if no module system is found.
+
+The browser bundle is available on [cdnjs](https://cdnjs.com/libraries/ajv).
+
+Ajv is tested with these browsers:
+
+[](https://saucelabs.com/u/epoberezkin)
+
+__Please note__: some frameworks, e.g. Dojo, may redefine global require in such way that is not compatible with CommonJS module format. In such case Ajv bundle has to be loaded before the framework and then you can use global Ajv (see issue [#234](https://github.com/ajv-validator/ajv/issues/234)).
+
+
+### Ajv and Content Security Policies (CSP)
+
+If you're using Ajv to compile a schema (the typical use) in a browser document that is loaded with a Content Security Policy (CSP), that policy will require a `script-src` directive that includes the value `'unsafe-eval'`.
+:warning: NOTE, however, that `unsafe-eval` is NOT recommended in a secure CSP[[1]](https://developer.chrome.com/extensions/contentSecurityPolicy#relaxing-eval), as it has the potential to open the document to cross-site scripting (XSS) attacks.
+
+In order to make use of Ajv without easing your CSP, you can [pre-compile a schema using the CLI](https://github.com/ajv-validator/ajv-cli#compile-schemas). This will transpile the schema JSON into a JavaScript file that exports a `validate` function that works simlarly to a schema compiled at runtime.
+
+Note that pre-compilation of schemas is performed using [ajv-pack](https://github.com/ajv-validator/ajv-pack) and there are [some limitations to the schema features it can compile](https://github.com/ajv-validator/ajv-pack#limitations). A successfully pre-compiled schema is equivalent to the same schema compiled at runtime.
+
+
+## Command line interface
+
+CLI is available as a separate npm package [ajv-cli](https://github.com/ajv-validator/ajv-cli). It supports:
+
+- compiling JSON Schemas to test their validity
+- BETA: generating standalone module exporting a validation function to be used without Ajv (using [ajv-pack](https://github.com/ajv-validator/ajv-pack))
+- migrate schemas to draft-07 (using [json-schema-migrate](https://github.com/epoberezkin/json-schema-migrate))
+- validating data file(s) against JSON Schema
+- testing expected validity of data against JSON Schema
+- referenced schemas
+- custom meta-schemas
+- files in JSON, JSON5, YAML, and JavaScript format
+- all Ajv options
+- reporting changes in data after validation in [JSON-patch](https://tools.ietf.org/html/rfc6902) format
+
+
+## Validation keywords
+
+Ajv supports all validation keywords from draft-07 of JSON Schema standard:
+
+- [type](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#type)
+- [for numbers](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-numbers) - maximum, minimum, exclusiveMaximum, exclusiveMinimum, multipleOf
+- [for strings](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-strings) - maxLength, minLength, pattern, format
+- [for arrays](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-arrays) - maxItems, minItems, uniqueItems, items, additionalItems, [contains](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#contains)
+- [for objects](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-objects) - maxProperties, minProperties, required, properties, patternProperties, additionalProperties, dependencies, [propertyNames](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#propertynames)
+- [for all types](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#keywords-for-all-types) - enum, [const](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#const)
+- [compound keywords](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#compound-keywords) - not, oneOf, anyOf, allOf, [if/then/else](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#ifthenelse)
+
+With [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package Ajv also supports validation keywords from [JSON Schema extension proposals](https://github.com/json-schema/json-schema/wiki/v5-Proposals) for JSON Schema standard:
+
+- [patternRequired](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#patternrequired-proposed) - like `required` but with patterns that some property should match.
+- [formatMaximum, formatMinimum, formatExclusiveMaximum, formatExclusiveMinimum](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md#formatmaximum--formatminimum-and-exclusiveformatmaximum--exclusiveformatminimum-proposed) - setting limits for date, time, etc.
+
+See [JSON Schema validation keywords](https://github.com/ajv-validator/ajv/blob/master/KEYWORDS.md) for more details.
+
+
+## Annotation keywords
+
+JSON Schema specification defines several annotation keywords that describe schema itself but do not perform any validation.
+
+- `title` and `description`: information about the data represented by that schema
+- `$comment` (NEW in draft-07): information for developers. With option `$comment` Ajv logs or passes the comment string to the user-supplied function. See [Options](#options).
+- `default`: a default value of the data instance, see [Assigning defaults](#assigning-defaults).
+- `examples` (NEW in draft-06): an array of data instances. Ajv does not check the validity of these instances against the schema.
+- `readOnly` and `writeOnly` (NEW in draft-07): marks data-instance as read-only or write-only in relation to the source of the data (database, api, etc.).
+- `contentEncoding`: [RFC 2045](https://tools.ietf.org/html/rfc2045#section-6.1 ), e.g., "base64".
+- `contentMediaType`: [RFC 2046](https://tools.ietf.org/html/rfc2046), e.g., "image/png".
+
+__Please note__: Ajv does not implement validation of the keywords `examples`, `contentEncoding` and `contentMediaType` but it reserves them. If you want to create a plugin that implements some of them, it should remove these keywords from the instance.
+
+
+## Formats
+
+Ajv implements formats defined by JSON Schema specification and several other formats. It is recommended NOT to use "format" keyword implementations with untrusted data, as they use potentially unsafe regular expressions - see [ReDoS attack](#redos-attack).
+
+__Please note__: if you need to use "format" keyword to validate untrusted data, you MUST assess their suitability and safety for your validation scenarios.
+
+The following formats are implemented for string validation with "format" keyword:
+
+- _date_: full-date according to [RFC3339](http://tools.ietf.org/html/rfc3339#section-5.6).
+- _time_: time with optional time-zone.
+- _date-time_: date-time from the same source (time-zone is mandatory). `date`, `time` and `date-time` validate ranges in `full` mode and only regexp in `fast` mode (see [options](#options)).
+- _uri_: full URI.
+- _uri-reference_: URI reference, including full and relative URIs.
+- _uri-template_: URI template according to [RFC6570](https://tools.ietf.org/html/rfc6570)
+- _url_ (deprecated): [URL record](https://url.spec.whatwg.org/#concept-url).
+- _email_: email address.
+- _hostname_: host name according to [RFC1034](http://tools.ietf.org/html/rfc1034#section-3.5).
+- _ipv4_: IP address v4.
+- _ipv6_: IP address v6.
+- _regex_: tests whether a string is a valid regular expression by passing it to RegExp constructor.
+- _uuid_: Universally Unique IDentifier according to [RFC4122](http://tools.ietf.org/html/rfc4122).
+- _json-pointer_: JSON-pointer according to [RFC6901](https://tools.ietf.org/html/rfc6901).
+- _relative-json-pointer_: relative JSON-pointer according to [this draft](http://tools.ietf.org/html/draft-luff-relative-json-pointer-00).
+
+__Please note__: JSON Schema draft-07 also defines formats `iri`, `iri-reference`, `idn-hostname` and `idn-email` for URLs, hostnames and emails with international characters. Ajv does not implement these formats. If you create Ajv plugin that implements them please make a PR to mention this plugin here.
+
+There are two modes of format validation: `fast` and `full`. This mode affects formats `date`, `time`, `date-time`, `uri`, `uri-reference`, and `email`. See [Options](#options) for details.
+
+You can add additional formats and replace any of the formats above using [addFormat](#api-addformat) method.
+
+The option `unknownFormats` allows changing the default behaviour when an unknown format is encountered. In this case Ajv can either fail schema compilation (default) or ignore it (default in versions before 5.0.0). You also can allow specific format(s) that will be ignored. See [Options](#options) for details.
+
+You can find regular expressions used for format validation and the sources that were used in [formats.js](https://github.com/ajv-validator/ajv/blob/master/lib/compile/formats.js).
+
+
+## Combining schemas with $ref
+
+You can structure your validation logic across multiple schema files and have schemas reference each other using `$ref` keyword.
+
+Example:
+
+```javascript
+var schema = {
+ "$id": "http://example.com/schemas/schema.json",
+ "type": "object",
+ "properties": {
+ "foo": { "$ref": "defs.json#/definitions/int" },
+ "bar": { "$ref": "defs.json#/definitions/str" }
+ }
+};
+
+var defsSchema = {
+ "$id": "http://example.com/schemas/defs.json",
+ "definitions": {
+ "int": { "type": "integer" },
+ "str": { "type": "string" }
+ }
+};
+```
+
+Now to compile your schema you can either pass all schemas to Ajv instance:
+
+```javascript
+var ajv = new Ajv({schemas: [schema, defsSchema]});
+var validate = ajv.getSchema('http://example.com/schemas/schema.json');
+```
+
+or use `addSchema` method:
+
+```javascript
+var ajv = new Ajv;
+var validate = ajv.addSchema(defsSchema)
+ .compile(schema);
+```
+
+See [Options](#options) and [addSchema](#api) method.
+
+__Please note__:
+- `$ref` is resolved as the uri-reference using schema $id as the base URI (see the example).
+- References can be recursive (and mutually recursive) to implement the schemas for different data structures (such as linked lists, trees, graphs, etc.).
+- You don't have to host your schema files at the URIs that you use as schema $id. These URIs are only used to identify the schemas, and according to JSON Schema specification validators should not expect to be able to download the schemas from these URIs.
+- The actual location of the schema file in the file system is not used.
+- You can pass the identifier of the schema as the second parameter of `addSchema` method or as a property name in `schemas` option. This identifier can be used instead of (or in addition to) schema $id.
+- You cannot have the same $id (or the schema identifier) used for more than one schema - the exception will be thrown.
+- You can implement dynamic resolution of the referenced schemas using `compileAsync` method. In this way you can store schemas in any system (files, web, database, etc.) and reference them without explicitly adding to Ajv instance. See [Asynchronous schema compilation](#asynchronous-schema-compilation).
+
+
+## $data reference
+
+With `$data` option you can use values from the validated data as the values for the schema keywords. See [proposal](https://github.com/json-schema-org/json-schema-spec/issues/51) for more information about how it works.
+
+`$data` reference is supported in the keywords: const, enum, format, maximum/minimum, exclusiveMaximum / exclusiveMinimum, maxLength / minLength, maxItems / minItems, maxProperties / minProperties, formatMaximum / formatMinimum, formatExclusiveMaximum / formatExclusiveMinimum, multipleOf, pattern, required, uniqueItems.
+
+The value of "$data" should be a [JSON-pointer](https://tools.ietf.org/html/rfc6901) to the data (the root is always the top level data object, even if the $data reference is inside a referenced subschema) or a [relative JSON-pointer](http://tools.ietf.org/html/draft-luff-relative-json-pointer-00) (it is relative to the current point in data; if the $data reference is inside a referenced subschema it cannot point to the data outside of the root level for this subschema).
+
+Examples.
+
+This schema requires that the value in property `smaller` is less or equal than the value in the property larger:
+
+```javascript
+var ajv = new Ajv({$data: true});
+
+var schema = {
+ "properties": {
+ "smaller": {
+ "type": "number",
+ "maximum": { "$data": "1/larger" }
+ },
+ "larger": { "type": "number" }
+ }
+};
+
+var validData = {
+ smaller: 5,
+ larger: 7
+};
+
+ajv.validate(schema, validData); // true
+```
+
+This schema requires that the properties have the same format as their field names:
+
+```javascript
+var schema = {
+ "additionalProperties": {
+ "type": "string",
+ "format": { "$data": "0#" }
+ }
+};
+
+var validData = {
+ 'date-time': '1963-06-19T08:30:06.283185Z',
+ email: 'joe.bloggs@example.com'
+}
+```
+
+`$data` reference is resolved safely - it won't throw even if some property is undefined. If `$data` resolves to `undefined` the validation succeeds (with the exclusion of `const` keyword). If `$data` resolves to incorrect type (e.g. not "number" for maximum keyword) the validation fails.
+
+
+## $merge and $patch keywords
+
+With the package [ajv-merge-patch](https://github.com/ajv-validator/ajv-merge-patch) you can use the keywords `$merge` and `$patch` that allow extending JSON Schemas with patches using formats [JSON Merge Patch (RFC 7396)](https://tools.ietf.org/html/rfc7396) and [JSON Patch (RFC 6902)](https://tools.ietf.org/html/rfc6902).
+
+To add keywords `$merge` and `$patch` to Ajv instance use this code:
+
+```javascript
+require('ajv-merge-patch')(ajv);
+```
+
+Examples.
+
+Using `$merge`:
+
+```json
+{
+ "$merge": {
+ "source": {
+ "type": "object",
+ "properties": { "p": { "type": "string" } },
+ "additionalProperties": false
+ },
+ "with": {
+ "properties": { "q": { "type": "number" } }
+ }
+ }
+}
+```
+
+Using `$patch`:
+
+```json
+{
+ "$patch": {
+ "source": {
+ "type": "object",
+ "properties": { "p": { "type": "string" } },
+ "additionalProperties": false
+ },
+ "with": [
+ { "op": "add", "path": "/properties/q", "value": { "type": "number" } }
+ ]
+ }
+}
+```
+
+The schemas above are equivalent to this schema:
+
+```json
+{
+ "type": "object",
+ "properties": {
+ "p": { "type": "string" },
+ "q": { "type": "number" }
+ },
+ "additionalProperties": false
+}
+```
+
+The properties `source` and `with` in the keywords `$merge` and `$patch` can use absolute or relative `$ref` to point to other schemas previously added to the Ajv instance or to the fragments of the current schema.
+
+See the package [ajv-merge-patch](https://github.com/ajv-validator/ajv-merge-patch) for more information.
+
+
+## Defining custom keywords
+
+The advantages of using custom keywords are:
+
+- allow creating validation scenarios that cannot be expressed using JSON Schema
+- simplify your schemas
+- help bringing a bigger part of the validation logic to your schemas
+- make your schemas more expressive, less verbose and closer to your application domain
+- implement custom data processors that modify your data (`modifying` option MUST be used in keyword definition) and/or create side effects while the data is being validated
+
+If a keyword is used only for side-effects and its validation result is pre-defined, use option `valid: true/false` in keyword definition to simplify both generated code (no error handling in case of `valid: true`) and your keyword functions (no need to return any validation result).
+
+The concerns you have to be aware of when extending JSON Schema standard with custom keywords are the portability and understanding of your schemas. You will have to support these custom keywords on other platforms and to properly document these keywords so that everybody can understand them in your schemas.
+
+You can define custom keywords with [addKeyword](#api-addkeyword) method. Keywords are defined on the `ajv` instance level - new instances will not have previously defined keywords.
+
+Ajv allows defining keywords with:
+- validation function
+- compilation function
+- macro function
+- inline compilation function that should return code (as string) that will be inlined in the currently compiled schema.
+
+Example. `range` and `exclusiveRange` keywords using compiled schema:
+
+```javascript
+ajv.addKeyword('range', {
+ type: 'number',
+ compile: function (sch, parentSchema) {
+ var min = sch[0];
+ var max = sch[1];
+
+ return parentSchema.exclusiveRange === true
+ ? function (data) { return data > min && data < max; }
+ : function (data) { return data >= min && data <= max; }
+ }
+});
+
+var schema = { "range": [2, 4], "exclusiveRange": true };
+var validate = ajv.compile(schema);
+console.log(validate(2.01)); // true
+console.log(validate(3.99)); // true
+console.log(validate(2)); // false
+console.log(validate(4)); // false
+```
+
+Several custom keywords (typeof, instanceof, range and propertyNames) are defined in [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package - they can be used for your schemas and as a starting point for your own custom keywords.
+
+See [Defining custom keywords](https://github.com/ajv-validator/ajv/blob/master/CUSTOM.md) for more details.
+
+
+## Asynchronous schema compilation
+
+During asynchronous compilation remote references are loaded using supplied function. See `compileAsync` [method](#api-compileAsync) and `loadSchema` [option](#options).
+
+Example:
+
+```javascript
+var ajv = new Ajv({ loadSchema: loadSchema });
+
+ajv.compileAsync(schema).then(function (validate) {
+ var valid = validate(data);
+ // ...
+});
+
+function loadSchema(uri) {
+ return request.json(uri).then(function (res) {
+ if (res.statusCode >= 400)
+ throw new Error('Loading error: ' + res.statusCode);
+ return res.body;
+ });
+}
+```
+
+__Please note__: [Option](#options) `missingRefs` should NOT be set to `"ignore"` or `"fail"` for asynchronous compilation to work.
+
+
+## Asynchronous validation
+
+Example in Node.js REPL: https://tonicdev.com/esp/ajv-asynchronous-validation
+
+You can define custom formats and keywords that perform validation asynchronously by accessing database or some other service. You should add `async: true` in the keyword or format definition (see [addFormat](#api-addformat), [addKeyword](#api-addkeyword) and [Defining custom keywords](#defining-custom-keywords)).
+
+If your schema uses asynchronous formats/keywords or refers to some schema that contains them it should have `"$async": true` keyword so that Ajv can compile it correctly. If asynchronous format/keyword or reference to asynchronous schema is used in the schema without `$async` keyword Ajv will throw an exception during schema compilation.
+
+__Please note__: all asynchronous subschemas that are referenced from the current or other schemas should have `"$async": true` keyword as well, otherwise the schema compilation will fail.
+
+Validation function for an asynchronous custom format/keyword should return a promise that resolves with `true` or `false` (or rejects with `new Ajv.ValidationError(errors)` if you want to return custom errors from the keyword function).
+
+Ajv compiles asynchronous schemas to [es7 async functions](http://tc39.github.io/ecmascript-asyncawait/) that can optionally be transpiled with [nodent](https://github.com/MatAtBread/nodent). Async functions are supported in Node.js 7+ and all modern browsers. You can also supply any other transpiler as a function via `processCode` option. See [Options](#options).
+
+The compiled validation function has `$async: true` property (if the schema is asynchronous), so you can differentiate these functions if you are using both synchronous and asynchronous schemas.
+
+Validation result will be a promise that resolves with validated data or rejects with an exception `Ajv.ValidationError` that contains the array of validation errors in `errors` property.
+
+
+Example:
+
+```javascript
+var ajv = new Ajv;
+// require('ajv-async')(ajv);
+
+ajv.addKeyword('idExists', {
+ async: true,
+ type: 'number',
+ validate: checkIdExists
+});
+
+
+function checkIdExists(schema, data) {
+ return knex(schema.table)
+ .select('id')
+ .where('id', data)
+ .then(function (rows) {
+ return !!rows.length; // true if record is found
+ });
+}
+
+var schema = {
+ "$async": true,
+ "properties": {
+ "userId": {
+ "type": "integer",
+ "idExists": { "table": "users" }
+ },
+ "postId": {
+ "type": "integer",
+ "idExists": { "table": "posts" }
+ }
+ }
+};
+
+var validate = ajv.compile(schema);
+
+validate({ userId: 1, postId: 19 })
+.then(function (data) {
+ console.log('Data is valid', data); // { userId: 1, postId: 19 }
+})
+.catch(function (err) {
+ if (!(err instanceof Ajv.ValidationError)) throw err;
+ // data is invalid
+ console.log('Validation errors:', err.errors);
+});
+```
+
+### Using transpilers with asynchronous validation functions.
+
+[ajv-async](https://github.com/ajv-validator/ajv-async) uses [nodent](https://github.com/MatAtBread/nodent) to transpile async functions. To use another transpiler you should separately install it (or load its bundle in the browser).
+
+
+#### Using nodent
+
+```javascript
+var ajv = new Ajv;
+require('ajv-async')(ajv);
+// in the browser if you want to load ajv-async bundle separately you can:
+// window.ajvAsync(ajv);
+var validate = ajv.compile(schema); // transpiled es7 async function
+validate(data).then(successFunc).catch(errorFunc);
+```
+
+
+#### Using other transpilers
+
+```javascript
+var ajv = new Ajv({ processCode: transpileFunc });
+var validate = ajv.compile(schema); // transpiled es7 async function
+validate(data).then(successFunc).catch(errorFunc);
+```
+
+See [Options](#options).
+
+
+## Security considerations
+
+JSON Schema, if properly used, can replace data sanitisation. It doesn't replace other API security considerations. It also introduces additional security aspects to consider.
+
+
+##### Security contact
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerabilities via GitHub issues.
+
+
+##### Untrusted schemas
+
+Ajv treats JSON schemas as trusted as your application code. This security model is based on the most common use case, when the schemas are static and bundled together with the application.
+
+If your schemas are received from untrusted sources (or generated from untrusted data) there are several scenarios you need to prevent:
+- compiling schemas can cause stack overflow (if they are too deep)
+- compiling schemas can be slow (e.g. [#557](https://github.com/ajv-validator/ajv/issues/557))
+- validating certain data can be slow
+
+It is difficult to predict all the scenarios, but at the very least it may help to limit the size of untrusted schemas (e.g. limit JSON string length) and also the maximum schema object depth (that can be high for relatively small JSON strings). You also may want to mitigate slow regular expressions in `pattern` and `patternProperties` keywords.
+
+Regardless the measures you take, using untrusted schemas increases security risks.
+
+
+##### Circular references in JavaScript objects
+
+Ajv does not support schemas and validated data that have circular references in objects. See [issue #802](https://github.com/ajv-validator/ajv/issues/802).
+
+An attempt to compile such schemas or validate such data would cause stack overflow (or will not complete in case of asynchronous validation). Depending on the parser you use, untrusted data can lead to circular references.
+
+
+##### Security risks of trusted schemas
+
+Some keywords in JSON Schemas can lead to very slow validation for certain data. These keywords include (but may be not limited to):
+
+- `pattern` and `format` for large strings - in some cases using `maxLength` can help mitigate it, but certain regular expressions can lead to exponential validation time even with relatively short strings (see [ReDoS attack](#redos-attack)).
+- `patternProperties` for large property names - use `propertyNames` to mitigate, but some regular expressions can have exponential evaluation time as well.
+- `uniqueItems` for large non-scalar arrays - use `maxItems` to mitigate
+
+__Please note__: The suggestions above to prevent slow validation would only work if you do NOT use `allErrors: true` in production code (using it would continue validation after validation errors).
+
+You can validate your JSON schemas against [this meta-schema](https://github.com/ajv-validator/ajv/blob/master/lib/refs/json-schema-secure.json) to check that these recommendations are followed:
+
+```javascript
+const isSchemaSecure = ajv.compile(require('ajv/lib/refs/json-schema-secure.json'));
+
+const schema1 = {format: 'email'};
+isSchemaSecure(schema1); // false
+
+const schema2 = {format: 'email', maxLength: MAX_LENGTH};
+isSchemaSecure(schema2); // true
+```
+
+__Please note__: following all these recommendation is not a guarantee that validation of untrusted data is safe - it can still lead to some undesirable results.
+
+
+##### Content Security Policies (CSP)
+See [Ajv and Content Security Policies (CSP)](#ajv-and-content-security-policies-csp)
+
+
+## ReDoS attack
+
+Certain regular expressions can lead to the exponential evaluation time even with relatively short strings.
+
+Please assess the regular expressions you use in the schemas on their vulnerability to this attack - see [safe-regex](https://github.com/substack/safe-regex), for example.
+
+__Please note__: some formats that Ajv implements use [regular expressions](https://github.com/ajv-validator/ajv/blob/master/lib/compile/formats.js) that can be vulnerable to ReDoS attack, so if you use Ajv to validate data from untrusted sources __it is strongly recommended__ to consider the following:
+
+- making assessment of "format" implementations in Ajv.
+- using `format: 'fast'` option that simplifies some of the regular expressions (although it does not guarantee that they are safe).
+- replacing format implementations provided by Ajv with your own implementations of "format" keyword that either uses different regular expressions or another approach to format validation. Please see [addFormat](#api-addformat) method.
+- disabling format validation by ignoring "format" keyword with option `format: false`
+
+Whatever mitigation you choose, please assume all formats provided by Ajv as potentially unsafe and make your own assessment of their suitability for your validation scenarios.
+
+
+## Filtering data
+
+With [option `removeAdditional`](#options) (added by [andyscott](https://github.com/andyscott)) you can filter data during the validation.
+
+This option modifies original data.
+
+Example:
+
+```javascript
+var ajv = new Ajv({ removeAdditional: true });
+var schema = {
+ "additionalProperties": false,
+ "properties": {
+ "foo": { "type": "number" },
+ "bar": {
+ "additionalProperties": { "type": "number" },
+ "properties": {
+ "baz": { "type": "string" }
+ }
+ }
+ }
+}
+
+var data = {
+ "foo": 0,
+ "additional1": 1, // will be removed; `additionalProperties` == false
+ "bar": {
+ "baz": "abc",
+ "additional2": 2 // will NOT be removed; `additionalProperties` != false
+ },
+}
+
+var validate = ajv.compile(schema);
+
+console.log(validate(data)); // true
+console.log(data); // { "foo": 0, "bar": { "baz": "abc", "additional2": 2 }
+```
+
+If `removeAdditional` option in the example above were `"all"` then both `additional1` and `additional2` properties would have been removed.
+
+If the option were `"failing"` then property `additional1` would have been removed regardless of its value and property `additional2` would have been removed only if its value were failing the schema in the inner `additionalProperties` (so in the example above it would have stayed because it passes the schema, but any non-number would have been removed).
+
+__Please note__: If you use `removeAdditional` option with `additionalProperties` keyword inside `anyOf`/`oneOf` keywords your validation can fail with this schema, for example:
+
+```json
+{
+ "type": "object",
+ "oneOf": [
+ {
+ "properties": {
+ "foo": { "type": "string" }
+ },
+ "required": [ "foo" ],
+ "additionalProperties": false
+ },
+ {
+ "properties": {
+ "bar": { "type": "integer" }
+ },
+ "required": [ "bar" ],
+ "additionalProperties": false
+ }
+ ]
+}
+```
+
+The intention of the schema above is to allow objects with either the string property "foo" or the integer property "bar", but not with both and not with any other properties.
+
+With the option `removeAdditional: true` the validation will pass for the object `{ "foo": "abc"}` but will fail for the object `{"bar": 1}`. It happens because while the first subschema in `oneOf` is validated, the property `bar` is removed because it is an additional property according to the standard (because it is not included in `properties` keyword in the same schema).
+
+While this behaviour is unexpected (issues [#129](https://github.com/ajv-validator/ajv/issues/129), [#134](https://github.com/ajv-validator/ajv/issues/134)), it is correct. To have the expected behaviour (both objects are allowed and additional properties are removed) the schema has to be refactored in this way:
+
+```json
+{
+ "type": "object",
+ "properties": {
+ "foo": { "type": "string" },
+ "bar": { "type": "integer" }
+ },
+ "additionalProperties": false,
+ "oneOf": [
+ { "required": [ "foo" ] },
+ { "required": [ "bar" ] }
+ ]
+}
+```
+
+The schema above is also more efficient - it will compile into a faster function.
+
+
+## Assigning defaults
+
+With [option `useDefaults`](#options) Ajv will assign values from `default` keyword in the schemas of `properties` and `items` (when it is the array of schemas) to the missing properties and items.
+
+With the option value `"empty"` properties and items equal to `null` or `""` (empty string) will be considered missing and assigned defaults.
+
+This option modifies original data.
+
+__Please note__: the default value is inserted in the generated validation code as a literal, so the value inserted in the data will be the deep clone of the default in the schema.
+
+
+Example 1 (`default` in `properties`):
+
+```javascript
+var ajv = new Ajv({ useDefaults: true });
+var schema = {
+ "type": "object",
+ "properties": {
+ "foo": { "type": "number" },
+ "bar": { "type": "string", "default": "baz" }
+ },
+ "required": [ "foo", "bar" ]
+};
+
+var data = { "foo": 1 };
+
+var validate = ajv.compile(schema);
+
+console.log(validate(data)); // true
+console.log(data); // { "foo": 1, "bar": "baz" }
+```
+
+Example 2 (`default` in `items`):
+
+```javascript
+var schema = {
+ "type": "array",
+ "items": [
+ { "type": "number" },
+ { "type": "string", "default": "foo" }
+ ]
+}
+
+var data = [ 1 ];
+
+var validate = ajv.compile(schema);
+
+console.log(validate(data)); // true
+console.log(data); // [ 1, "foo" ]
+```
+
+`default` keywords in other cases are ignored:
+
+- not in `properties` or `items` subschemas
+- in schemas inside `anyOf`, `oneOf` and `not` (see [#42](https://github.com/ajv-validator/ajv/issues/42))
+- in `if` subschema of `switch` keyword
+- in schemas generated by custom macro keywords
+
+The [`strictDefaults` option](#options) customizes Ajv's behavior for the defaults that Ajv ignores (`true` raises an error, and `"log"` outputs a warning).
+
+
+## Coercing data types
+
+When you are validating user inputs all your data properties are usually strings. The option `coerceTypes` allows you to have your data types coerced to the types specified in your schema `type` keywords, both to pass the validation and to use the correctly typed data afterwards.
+
+This option modifies original data.
+
+__Please note__: if you pass a scalar value to the validating function its type will be coerced and it will pass the validation, but the value of the variable you pass won't be updated because scalars are passed by value.
+
+
+Example 1:
+
+```javascript
+var ajv = new Ajv({ coerceTypes: true });
+var schema = {
+ "type": "object",
+ "properties": {
+ "foo": { "type": "number" },
+ "bar": { "type": "boolean" }
+ },
+ "required": [ "foo", "bar" ]
+};
+
+var data = { "foo": "1", "bar": "false" };
+
+var validate = ajv.compile(schema);
+
+console.log(validate(data)); // true
+console.log(data); // { "foo": 1, "bar": false }
+```
+
+Example 2 (array coercions):
+
+```javascript
+var ajv = new Ajv({ coerceTypes: 'array' });
+var schema = {
+ "properties": {
+ "foo": { "type": "array", "items": { "type": "number" } },
+ "bar": { "type": "boolean" }
+ }
+};
+
+var data = { "foo": "1", "bar": ["false"] };
+
+var validate = ajv.compile(schema);
+
+console.log(validate(data)); // true
+console.log(data); // { "foo": [1], "bar": false }
+```
+
+The coercion rules, as you can see from the example, are different from JavaScript both to validate user input as expected and to have the coercion reversible (to correctly validate cases where different types are defined in subschemas of "anyOf" and other compound keywords).
+
+See [Coercion rules](https://github.com/ajv-validator/ajv/blob/master/COERCION.md) for details.
+
+
+## API
+
+##### new Ajv(Object options) -> Object
+
+Create Ajv instance.
+
+
+##### .compile(Object schema) -> Function<Object data>
+
+Generate validating function and cache the compiled schema for future use.
+
+Validating function returns a boolean value. This function has properties `errors` and `schema`. Errors encountered during the last validation are assigned to `errors` property (it is assigned `null` if there was no errors). `schema` property contains the reference to the original schema.
+
+The schema passed to this method will be validated against meta-schema unless `validateSchema` option is false. If schema is invalid, an error will be thrown. See [options](#options).
+
+
+##### .compileAsync(Object schema [, Boolean meta] [, Function callback]) -> Promise
+
+Asynchronous version of `compile` method that loads missing remote schemas using asynchronous function in `options.loadSchema`. This function returns a Promise that resolves to a validation function. An optional callback passed to `compileAsync` will be called with 2 parameters: error (or null) and validating function. The returned promise will reject (and the callback will be called with an error) when:
+
+- missing schema can't be loaded (`loadSchema` returns a Promise that rejects).
+- a schema containing a missing reference is loaded, but the reference cannot be resolved.
+- schema (or some loaded/referenced schema) is invalid.
+
+The function compiles schema and loads the first missing schema (or meta-schema) until all missing schemas are loaded.
+
+You can asynchronously compile meta-schema by passing `true` as the second parameter.
+
+See example in [Asynchronous compilation](#asynchronous-schema-compilation).
+
+
+##### .validate(Object schema|String key|String ref, data) -> Boolean
+
+Validate data using passed schema (it will be compiled and cached).
+
+Instead of the schema you can use the key that was previously passed to `addSchema`, the schema id if it was present in the schema or any previously resolved reference.
+
+Validation errors will be available in the `errors` property of Ajv instance (`null` if there were no errors).
+
+__Please note__: every time this method is called the errors are overwritten so you need to copy them to another variable if you want to use them later.
+
+If the schema is asynchronous (has `$async` keyword on the top level) this method returns a Promise. See [Asynchronous validation](#asynchronous-validation).
+
+
+##### .addSchema(Array<Object>|Object schema [, String key]) -> Ajv
+
+Add schema(s) to validator instance. This method does not compile schemas (but it still validates them). Because of that dependencies can be added in any order and circular dependencies are supported. It also prevents unnecessary compilation of schemas that are containers for other schemas but not used as a whole.
+
+Array of schemas can be passed (schemas should have ids), the second parameter will be ignored.
+
+Key can be passed that can be used to reference the schema and will be used as the schema id if there is no id inside the schema. If the key is not passed, the schema id will be used as the key.
+
+
+Once the schema is added, it (and all the references inside it) can be referenced in other schemas and used to validate data.
+
+Although `addSchema` does not compile schemas, explicit compilation is not required - the schema will be compiled when it is used first time.
+
+By default the schema is validated against meta-schema before it is added, and if the schema does not pass validation the exception is thrown. This behaviour is controlled by `validateSchema` option.
+
+__Please note__: Ajv uses the [method chaining syntax](https://en.wikipedia.org/wiki/Method_chaining) for all methods with the prefix `add*` and `remove*`.
+This allows you to do nice things like the following.
+
+```javascript
+var validate = new Ajv().addSchema(schema).addFormat(name, regex).getSchema(uri);
+```
+
+##### .addMetaSchema(Array<Object>|Object schema [, String key]) -> Ajv
+
+Adds meta schema(s) that can be used to validate other schemas. That function should be used instead of `addSchema` because there may be instance options that would compile a meta schema incorrectly (at the moment it is `removeAdditional` option).
+
+There is no need to explicitly add draft-07 meta schema (http://json-schema.org/draft-07/schema) - it is added by default, unless option `meta` is set to `false`. You only need to use it if you have a changed meta-schema that you want to use to validate your schemas. See `validateSchema`.
+
+
+##### .validateSchema(Object schema) -> Boolean
+
+Validates schema. This method should be used to validate schemas rather than `validate` due to the inconsistency of `uri` format in JSON Schema standard.
+
+By default this method is called automatically when the schema is added, so you rarely need to use it directly.
+
+If schema doesn't have `$schema` property, it is validated against draft 6 meta-schema (option `meta` should not be false).
+
+If schema has `$schema` property, then the schema with this id (that should be previously added) is used to validate passed schema.
+
+Errors will be available at `ajv.errors`.
+
+
+##### .getSchema(String key) -> Function<Object data>
+
+Retrieve compiled schema previously added with `addSchema` by the key passed to `addSchema` or by its full reference (id). The returned validating function has `schema` property with the reference to the original schema.
+
+
+##### .removeSchema([Object schema|String key|String ref|RegExp pattern]) -> Ajv
+
+Remove added/cached schema. Even if schema is referenced by other schemas it can be safely removed as dependent schemas have local references.
+
+Schema can be removed using:
+- key passed to `addSchema`
+- it's full reference (id)
+- RegExp that should match schema id or key (meta-schemas won't be removed)
+- actual schema object that will be stable-stringified to remove schema from cache
+
+If no parameter is passed all schemas but meta-schemas will be removed and the cache will be cleared.
+
+
+##### .addFormat(String name, String|RegExp|Function|Object format) -> Ajv
+
+Add custom format to validate strings or numbers. It can also be used to replace pre-defined formats for Ajv instance.
+
+Strings are converted to RegExp.
+
+Function should return validation result as `true` or `false`.
+
+If object is passed it should have properties `validate`, `compare` and `async`:
+
+- _validate_: a string, RegExp or a function as described above.
+- _compare_: an optional comparison function that accepts two strings and compares them according to the format meaning. This function is used with keywords `formatMaximum`/`formatMinimum` (defined in [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) package). It should return `1` if the first value is bigger than the second value, `-1` if it is smaller and `0` if it is equal.
+- _async_: an optional `true` value if `validate` is an asynchronous function; in this case it should return a promise that resolves with a value `true` or `false`.
+- _type_: an optional type of data that the format applies to. It can be `"string"` (default) or `"number"` (see https://github.com/ajv-validator/ajv/issues/291#issuecomment-259923858). If the type of data is different, the validation will pass.
+
+Custom formats can be also added via `formats` option.
+
+
+##### .addKeyword(String keyword, Object definition) -> Ajv
+
+Add custom validation keyword to Ajv instance.
+
+Keyword should be different from all standard JSON Schema keywords and different from previously defined keywords. There is no way to redefine keywords or to remove keyword definition from the instance.
+
+Keyword must start with a letter, `_` or `$`, and may continue with letters, numbers, `_`, `$`, or `-`.
+It is recommended to use an application-specific prefix for keywords to avoid current and future name collisions.
+
+Example Keywords:
+- `"xyz-example"`: valid, and uses prefix for the xyz project to avoid name collisions.
+- `"example"`: valid, but not recommended as it could collide with future versions of JSON Schema etc.
+- `"3-example"`: invalid as numbers are not allowed to be the first character in a keyword
+
+Keyword definition is an object with the following properties:
+
+- _type_: optional string or array of strings with data type(s) that the keyword applies to. If not present, the keyword will apply to all types.
+- _validate_: validating function
+- _compile_: compiling function
+- _macro_: macro function
+- _inline_: compiling function that returns code (as string)
+- _schema_: an optional `false` value used with "validate" keyword to not pass schema
+- _metaSchema_: an optional meta-schema for keyword schema
+- _dependencies_: an optional list of properties that must be present in the parent schema - it will be checked during schema compilation
+- _modifying_: `true` MUST be passed if keyword modifies data
+- _statements_: `true` can be passed in case inline keyword generates statements (as opposed to expression)
+- _valid_: pass `true`/`false` to pre-define validation result, the result returned from validation function will be ignored. This option cannot be used with macro keywords.
+- _$data_: an optional `true` value to support [$data reference](#data-reference) as the value of custom keyword. The reference will be resolved at validation time. If the keyword has meta-schema it would be extended to allow $data and it will be used to validate the resolved value. Supporting $data reference requires that keyword has validating function (as the only option or in addition to compile, macro or inline function).
+- _async_: an optional `true` value if the validation function is asynchronous (whether it is compiled or passed in _validate_ property); in this case it should return a promise that resolves with a value `true` or `false`. This option is ignored in case of "macro" and "inline" keywords.
+- _errors_: an optional boolean or string `"full"` indicating whether keyword returns errors. If this property is not set Ajv will determine if the errors were set in case of failed validation.
+
+_compile_, _macro_ and _inline_ are mutually exclusive, only one should be used at a time. _validate_ can be used separately or in addition to them to support $data reference.
+
+__Please note__: If the keyword is validating data type that is different from the type(s) in its definition, the validation function will not be called (and expanded macro will not be used), so there is no need to check for data type inside validation function or inside schema returned by macro function (unless you want to enforce a specific type and for some reason do not want to use a separate `type` keyword for that). In the same way as standard keywords work, if the keyword does not apply to the data type being validated, the validation of this keyword will succeed.
+
+See [Defining custom keywords](#defining-custom-keywords) for more details.
+
+
+##### .getKeyword(String keyword) -> Object|Boolean
+
+Returns custom keyword definition, `true` for pre-defined keywords and `false` if the keyword is unknown.
+
+
+##### .removeKeyword(String keyword) -> Ajv
+
+Removes custom or pre-defined keyword so you can redefine them.
+
+While this method can be used to extend pre-defined keywords, it can also be used to completely change their meaning - it may lead to unexpected results.
+
+__Please note__: schemas compiled before the keyword is removed will continue to work without changes. To recompile schemas use `removeSchema` method and compile them again.
+
+
+##### .errorsText([Array<Object> errors [, Object options]]) -> String
+
+Returns the text with all errors in a String.
+
+Options can have properties `separator` (string used to separate errors, ", " by default) and `dataVar` (the variable name that dataPaths are prefixed with, "data" by default).
+
+
+## Options
+
+Defaults:
+
+```javascript
+{
+ // validation and reporting options:
+ $data: false,
+ allErrors: false,
+ verbose: false,
+ $comment: false, // NEW in Ajv version 6.0
+ jsonPointers: false,
+ uniqueItems: true,
+ unicode: true,
+ nullable: false,
+ format: 'fast',
+ formats: {},
+ unknownFormats: true,
+ schemas: {},
+ logger: undefined,
+ // referenced schema options:
+ schemaId: '$id',
+ missingRefs: true,
+ extendRefs: 'ignore', // recommended 'fail'
+ loadSchema: undefined, // function(uri: string): Promise {}
+ // options to modify validated data:
+ removeAdditional: false,
+ useDefaults: false,
+ coerceTypes: false,
+ // strict mode options
+ strictDefaults: false,
+ strictKeywords: false,
+ strictNumbers: false,
+ // asynchronous validation options:
+ transpile: undefined, // requires ajv-async package
+ // advanced options:
+ meta: true,
+ validateSchema: true,
+ addUsedSchema: true,
+ inlineRefs: true,
+ passContext: false,
+ loopRequired: Infinity,
+ ownProperties: false,
+ multipleOfPrecision: false,
+ errorDataPath: 'object', // deprecated
+ messages: true,
+ sourceCode: false,
+ processCode: undefined, // function (str: string, schema: object): string {}
+ cache: new Cache,
+ serialize: undefined
+}
+```
+
+##### Validation and reporting options
+
+- _$data_: support [$data references](#data-reference). Draft 6 meta-schema that is added by default will be extended to allow them. If you want to use another meta-schema you need to use $dataMetaSchema method to add support for $data reference. See [API](#api).
+- _allErrors_: check all rules collecting all errors. Default is to return after the first error.
+- _verbose_: include the reference to the part of the schema (`schema` and `parentSchema`) and validated data in errors (false by default).
+- _$comment_ (NEW in Ajv version 6.0): log or pass the value of `$comment` keyword to a function. Option values:
+ - `false` (default): ignore $comment keyword.
+ - `true`: log the keyword value to console.
+ - function: pass the keyword value, its schema path and root schema to the specified function
+- _jsonPointers_: set `dataPath` property of errors using [JSON Pointers](https://tools.ietf.org/html/rfc6901) instead of JavaScript property access notation.
+- _uniqueItems_: validate `uniqueItems` keyword (true by default).
+- _unicode_: calculate correct length of strings with unicode pairs (true by default). Pass `false` to use `.length` of strings that is faster, but gives "incorrect" lengths of strings with unicode pairs - each unicode pair is counted as two characters.
+- _nullable_: support keyword "nullable" from [Open API 3 specification](https://swagger.io/docs/specification/data-models/data-types/).
+- _format_: formats validation mode. Option values:
+ - `"fast"` (default) - simplified and fast validation (see [Formats](#formats) for details of which formats are available and affected by this option).
+ - `"full"` - more restrictive and slow validation. E.g., 25:00:00 and 2015/14/33 will be invalid time and date in 'full' mode but it will be valid in 'fast' mode.
+ - `false` - ignore all format keywords.
+- _formats_: an object with custom formats. Keys and values will be passed to `addFormat` method.
+- _keywords_: an object with custom keywords. Keys and values will be passed to `addKeyword` method.
+- _unknownFormats_: handling of unknown formats. Option values:
+ - `true` (default) - if an unknown format is encountered the exception is thrown during schema compilation. If `format` keyword value is [$data reference](#data-reference) and it is unknown the validation will fail.
+ - `[String]` - an array of unknown format names that will be ignored. This option can be used to allow usage of third party schemas with format(s) for which you don't have definitions, but still fail if another unknown format is used. If `format` keyword value is [$data reference](#data-reference) and it is not in this array the validation will fail.
+ - `"ignore"` - to log warning during schema compilation and always pass validation (the default behaviour in versions before 5.0.0). This option is not recommended, as it allows to mistype format name and it won't be validated without any error message. This behaviour is required by JSON Schema specification.
+- _schemas_: an array or object of schemas that will be added to the instance. In case you pass the array the schemas must have IDs in them. When the object is passed the method `addSchema(value, key)` will be called for each schema in this object.
+- _logger_: sets the logging method. Default is the global `console` object that should have methods `log`, `warn` and `error`. See [Error logging](#error-logging). Option values:
+ - custom logger - it should have methods `log`, `warn` and `error`. If any of these methods is missing an exception will be thrown.
+ - `false` - logging is disabled.
+
+
+##### Referenced schema options
+
+- _schemaId_: this option defines which keywords are used as schema URI. Option value:
+ - `"$id"` (default) - only use `$id` keyword as schema URI (as specified in JSON Schema draft-06/07), ignore `id` keyword (if it is present a warning will be logged).
+ - `"id"` - only use `id` keyword as schema URI (as specified in JSON Schema draft-04), ignore `$id` keyword (if it is present a warning will be logged).
+ - `"auto"` - use both `$id` and `id` keywords as schema URI. If both are present (in the same schema object) and different the exception will be thrown during schema compilation.
+- _missingRefs_: handling of missing referenced schemas. Option values:
+ - `true` (default) - if the reference cannot be resolved during compilation the exception is thrown. The thrown error has properties `missingRef` (with hash fragment) and `missingSchema` (without it). Both properties are resolved relative to the current base id (usually schema id, unless it was substituted).
+ - `"ignore"` - to log error during compilation and always pass validation.
+ - `"fail"` - to log error and successfully compile schema but fail validation if this rule is checked.
+- _extendRefs_: validation of other keywords when `$ref` is present in the schema. Option values:
+ - `"ignore"` (default) - when `$ref` is used other keywords are ignored (as per [JSON Reference](https://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03#section-3) standard). A warning will be logged during the schema compilation.
+ - `"fail"` (recommended) - if other validation keywords are used together with `$ref` the exception will be thrown when the schema is compiled. This option is recommended to make sure schema has no keywords that are ignored, which can be confusing.
+ - `true` - validate all keywords in the schemas with `$ref` (the default behaviour in versions before 5.0.0).
+- _loadSchema_: asynchronous function that will be used to load remote schemas when `compileAsync` [method](#api-compileAsync) is used and some reference is missing (option `missingRefs` should NOT be 'fail' or 'ignore'). This function should accept remote schema uri as a parameter and return a Promise that resolves to a schema. See example in [Asynchronous compilation](#asynchronous-schema-compilation).
+
+
+##### Options to modify validated data
+
+- _removeAdditional_: remove additional properties - see example in [Filtering data](#filtering-data). This option is not used if schema is added with `addMetaSchema` method. Option values:
+ - `false` (default) - not to remove additional properties
+ - `"all"` - all additional properties are removed, regardless of `additionalProperties` keyword in schema (and no validation is made for them).
+ - `true` - only additional properties with `additionalProperties` keyword equal to `false` are removed.
+ - `"failing"` - additional properties that fail schema validation will be removed (where `additionalProperties` keyword is `false` or schema).
+- _useDefaults_: replace missing or undefined properties and items with the values from corresponding `default` keywords. Default behaviour is to ignore `default` keywords. This option is not used if schema is added with `addMetaSchema` method. See examples in [Assigning defaults](#assigning-defaults). Option values:
+ - `false` (default) - do not use defaults
+ - `true` - insert defaults by value (object literal is used).
+ - `"empty"` - in addition to missing or undefined, use defaults for properties and items that are equal to `null` or `""` (an empty string).
+ - `"shared"` (deprecated) - insert defaults by reference. If the default is an object, it will be shared by all instances of validated data. If you modify the inserted default in the validated data, it will be modified in the schema as well.
+- _coerceTypes_: change data type of data to match `type` keyword. See the example in [Coercing data types](#coercing-data-types) and [coercion rules](https://github.com/ajv-validator/ajv/blob/master/COERCION.md). Option values:
+ - `false` (default) - no type coercion.
+ - `true` - coerce scalar data types.
+ - `"array"` - in addition to coercions between scalar types, coerce scalar data to an array with one element and vice versa (as required by the schema).
+
+
+##### Strict mode options
+
+- _strictDefaults_: report ignored `default` keywords in schemas. Option values:
+ - `false` (default) - ignored defaults are not reported
+ - `true` - if an ignored default is present, throw an error
+ - `"log"` - if an ignored default is present, log warning
+- _strictKeywords_: report unknown keywords in schemas. Option values:
+ - `false` (default) - unknown keywords are not reported
+ - `true` - if an unknown keyword is present, throw an error
+ - `"log"` - if an unknown keyword is present, log warning
+- _strictNumbers_: validate numbers strictly, failing validation for NaN and Infinity. Option values:
+ - `false` (default) - NaN or Infinity will pass validation for numeric types
+ - `true` - NaN or Infinity will not pass validation for numeric types
+
+##### Asynchronous validation options
+
+- _transpile_: Requires [ajv-async](https://github.com/ajv-validator/ajv-async) package. It determines whether Ajv transpiles compiled asynchronous validation function. Option values:
+ - `undefined` (default) - transpile with [nodent](https://github.com/MatAtBread/nodent) if async functions are not supported.
+ - `true` - always transpile with nodent.
+ - `false` - do not transpile; if async functions are not supported an exception will be thrown.
+
+
+##### Advanced options
+
+- _meta_: add [meta-schema](http://json-schema.org/documentation.html) so it can be used by other schemas (true by default). If an object is passed, it will be used as the default meta-schema for schemas that have no `$schema` keyword. This default meta-schema MUST have `$schema` keyword.
+- _validateSchema_: validate added/compiled schemas against meta-schema (true by default). `$schema` property in the schema can be http://json-schema.org/draft-07/schema or absent (draft-07 meta-schema will be used) or can be a reference to the schema previously added with `addMetaSchema` method. Option values:
+ - `true` (default) - if the validation fails, throw the exception.
+ - `"log"` - if the validation fails, log error.
+ - `false` - skip schema validation.
+- _addUsedSchema_: by default methods `compile` and `validate` add schemas to the instance if they have `$id` (or `id`) property that doesn't start with "#". If `$id` is present and it is not unique the exception will be thrown. Set this option to `false` to skip adding schemas to the instance and the `$id` uniqueness check when these methods are used. This option does not affect `addSchema` method.
+- _inlineRefs_: Affects compilation of referenced schemas. Option values:
+ - `true` (default) - the referenced schemas that don't have refs in them are inlined, regardless of their size - that substantially improves performance at the cost of the bigger size of compiled schema functions.
+ - `false` - to not inline referenced schemas (they will be compiled as separate functions).
+ - integer number - to limit the maximum number of keywords of the schema that will be inlined.
+- _passContext_: pass validation context to custom keyword functions. If this option is `true` and you pass some context to the compiled validation function with `validate.call(context, data)`, the `context` will be available as `this` in your custom keywords. By default `this` is Ajv instance.
+- _loopRequired_: by default `required` keyword is compiled into a single expression (or a sequence of statements in `allErrors` mode). In case of a very large number of properties in this keyword it may result in a very big validation function. Pass integer to set the number of properties above which `required` keyword will be validated in a loop - smaller validation function size but also worse performance.
+- _ownProperties_: by default Ajv iterates over all enumerable object properties; when this option is `true` only own enumerable object properties (i.e. found directly on the object rather than on its prototype) are iterated. Contributed by @mbroadst.
+- _multipleOfPrecision_: by default `multipleOf` keyword is validated by comparing the result of division with parseInt() of that result. It works for dividers that are bigger than 1. For small dividers such as 0.01 the result of the division is usually not integer (even when it should be integer, see issue [#84](https://github.com/ajv-validator/ajv/issues/84)). If you need to use fractional dividers set this option to some positive integer N to have `multipleOf` validated using this formula: `Math.abs(Math.round(division) - division) < 1e-N` (it is slower but allows for float arithmetics deviations).
+- _errorDataPath_ (deprecated): set `dataPath` to point to 'object' (default) or to 'property' when validating keywords `required`, `additionalProperties` and `dependencies`.
+- _messages_: Include human-readable messages in errors. `true` by default. `false` can be passed when custom messages are used (e.g. with [ajv-i18n](https://github.com/ajv-validator/ajv-i18n)).
+- _sourceCode_: add `sourceCode` property to validating function (for debugging; this code can be different from the result of toString call).
+- _processCode_: an optional function to process generated code before it is passed to Function constructor. It can be used to either beautify (the validating function is generated without line-breaks) or to transpile code. Starting from version 5.0.0 this option replaced options:
+ - `beautify` that formatted the generated function using [js-beautify](https://github.com/beautify-web/js-beautify). If you want to beautify the generated code pass a function calling `require('js-beautify').js_beautify` as `processCode: code => js_beautify(code)`.
+ - `transpile` that transpiled asynchronous validation function. You can still use `transpile` option with [ajv-async](https://github.com/ajv-validator/ajv-async) package. See [Asynchronous validation](#asynchronous-validation) for more information.
+- _cache_: an optional instance of cache to store compiled schemas using stable-stringified schema as a key. For example, set-associative cache [sacjs](https://github.com/epoberezkin/sacjs) can be used. If not passed then a simple hash is used which is good enough for the common use case (a limited number of statically defined schemas). Cache should have methods `put(key, value)`, `get(key)`, `del(key)` and `clear()`.
+- _serialize_: an optional function to serialize schema to cache key. Pass `false` to use schema itself as a key (e.g., if WeakMap used as a cache). By default [fast-json-stable-stringify](https://github.com/epoberezkin/fast-json-stable-stringify) is used.
+
+
+## Validation errors
+
+In case of validation failure, Ajv assigns the array of errors to `errors` property of validation function (or to `errors` property of Ajv instance when `validate` or `validateSchema` methods were called). In case of [asynchronous validation](#asynchronous-validation), the returned promise is rejected with exception `Ajv.ValidationError` that has `errors` property.
+
+
+### Error objects
+
+Each error is an object with the following properties:
+
+- _keyword_: validation keyword.
+- _dataPath_: the path to the part of the data that was validated. By default `dataPath` uses JavaScript property access notation (e.g., `".prop[1].subProp"`). When the option `jsonPointers` is true (see [Options](#options)) `dataPath` will be set using JSON pointer standard (e.g., `"/prop/1/subProp"`).
+- _schemaPath_: the path (JSON-pointer as a URI fragment) to the schema of the keyword that failed validation.
+- _params_: the object with the additional information about error that can be used to create custom error messages (e.g., using [ajv-i18n](https://github.com/ajv-validator/ajv-i18n) package). See below for parameters set by all keywords.
+- _message_: the standard error message (can be excluded with option `messages` set to false).
+- _schema_: the schema of the keyword (added with `verbose` option).
+- _parentSchema_: the schema containing the keyword (added with `verbose` option)
+- _data_: the data validated by the keyword (added with `verbose` option).
+
+__Please note__: `propertyNames` keyword schema validation errors have an additional property `propertyName`, `dataPath` points to the object. After schema validation for each property name, if it is invalid an additional error is added with the property `keyword` equal to `"propertyNames"`.
+
+
+### Error parameters
+
+Properties of `params` object in errors depend on the keyword that failed validation.
+
+- `maxItems`, `minItems`, `maxLength`, `minLength`, `maxProperties`, `minProperties` - property `limit` (number, the schema of the keyword).
+- `additionalItems` - property `limit` (the maximum number of allowed items in case when `items` keyword is an array of schemas and `additionalItems` is false).
+- `additionalProperties` - property `additionalProperty` (the property not used in `properties` and `patternProperties` keywords).
+- `dependencies` - properties:
+ - `property` (dependent property),
+ - `missingProperty` (required missing dependency - only the first one is reported currently)
+ - `deps` (required dependencies, comma separated list as a string),
+ - `depsCount` (the number of required dependencies).
+- `format` - property `format` (the schema of the keyword).
+- `maximum`, `minimum` - properties:
+ - `limit` (number, the schema of the keyword),
+ - `exclusive` (boolean, the schema of `exclusiveMaximum` or `exclusiveMinimum`),
+ - `comparison` (string, comparison operation to compare the data to the limit, with the data on the left and the limit on the right; can be "<", "<=", ">", ">=")
+- `multipleOf` - property `multipleOf` (the schema of the keyword)
+- `pattern` - property `pattern` (the schema of the keyword)
+- `required` - property `missingProperty` (required property that is missing).
+- `propertyNames` - property `propertyName` (an invalid property name).
+- `patternRequired` (in ajv-keywords) - property `missingPattern` (required pattern that did not match any property).
+- `type` - property `type` (required type(s), a string, can be a comma-separated list)
+- `uniqueItems` - properties `i` and `j` (indices of duplicate items).
+- `const` - property `allowedValue` pointing to the value (the schema of the keyword).
+- `enum` - property `allowedValues` pointing to the array of values (the schema of the keyword).
+- `$ref` - property `ref` with the referenced schema URI.
+- `oneOf` - property `passingSchemas` (array of indices of passing schemas, null if no schema passes).
+- custom keywords (in case keyword definition doesn't create errors) - property `keyword` (the keyword name).
+
+
+### Error logging
+
+Using the `logger` option when initiallizing Ajv will allow you to define custom logging. Here you can build upon the exisiting logging. The use of other logging packages is supported as long as the package or its associated wrapper exposes the required methods. If any of the required methods are missing an exception will be thrown.
+- **Required Methods**: `log`, `warn`, `error`
+
+```javascript
+var otherLogger = new OtherLogger();
+var ajv = new Ajv({
+ logger: {
+ log: console.log.bind(console),
+ warn: function warn() {
+ otherLogger.logWarn.apply(otherLogger, arguments);
+ },
+ error: function error() {
+ otherLogger.logError.apply(otherLogger, arguments);
+ console.error.apply(console, arguments);
+ }
+ }
+});
+```
+
+
+## Plugins
+
+Ajv can be extended with plugins that add custom keywords, formats or functions to process generated code. When such plugin is published as npm package it is recommended that it follows these conventions:
+
+- it exports a function
+- this function accepts ajv instance as the first parameter and returns the same instance to allow chaining
+- this function can accept an optional configuration as the second parameter
+
+If you have published a useful plugin please submit a PR to add it to the next section.
+
+
+## Related packages
+
+- [ajv-async](https://github.com/ajv-validator/ajv-async) - plugin to configure async validation mode
+- [ajv-bsontype](https://github.com/BoLaMN/ajv-bsontype) - plugin to validate mongodb's bsonType formats
+- [ajv-cli](https://github.com/jessedc/ajv-cli) - command line interface
+- [ajv-errors](https://github.com/ajv-validator/ajv-errors) - plugin for custom error messages
+- [ajv-i18n](https://github.com/ajv-validator/ajv-i18n) - internationalised error messages
+- [ajv-istanbul](https://github.com/ajv-validator/ajv-istanbul) - plugin to instrument generated validation code to measure test coverage of your schemas
+- [ajv-keywords](https://github.com/ajv-validator/ajv-keywords) - plugin with custom validation keywords (select, typeof, etc.)
+- [ajv-merge-patch](https://github.com/ajv-validator/ajv-merge-patch) - plugin with keywords $merge and $patch
+- [ajv-pack](https://github.com/ajv-validator/ajv-pack) - produces a compact module exporting validation functions
+- [ajv-formats-draft2019](https://github.com/luzlab/ajv-formats-draft2019) - format validators for draft2019 that aren't already included in ajv (ie. `idn-hostname`, `idn-email`, `iri`, `iri-reference` and `duration`).
+
+## Some packages using Ajv
+
+- [webpack](https://github.com/webpack/webpack) - a module bundler. Its main purpose is to bundle JavaScript files for usage in a browser
+- [jsonscript-js](https://github.com/JSONScript/jsonscript-js) - the interpreter for [JSONScript](http://www.jsonscript.org) - scripted processing of existing endpoints and services
+- [osprey-method-handler](https://github.com/mulesoft-labs/osprey-method-handler) - Express middleware for validating requests and responses based on a RAML method object, used in [osprey](https://github.com/mulesoft/osprey) - validating API proxy generated from a RAML definition
+- [har-validator](https://github.com/ahmadnassri/har-validator) - HTTP Archive (HAR) validator
+- [jsoneditor](https://github.com/josdejong/jsoneditor) - a web-based tool to view, edit, format, and validate JSON http://jsoneditoronline.org
+- [JSON Schema Lint](https://github.com/nickcmaynard/jsonschemalint) - a web tool to validate JSON/YAML document against a single JSON Schema http://jsonschemalint.com
+- [objection](https://github.com/vincit/objection.js) - SQL-friendly ORM for Node.js
+- [table](https://github.com/gajus/table) - formats data into a string table
+- [ripple-lib](https://github.com/ripple/ripple-lib) - a JavaScript API for interacting with [Ripple](https://ripple.com) in Node.js and the browser
+- [restbase](https://github.com/wikimedia/restbase) - distributed storage with REST API & dispatcher for backend services built to provide a low-latency & high-throughput API for Wikipedia / Wikimedia content
+- [hippie-swagger](https://github.com/CacheControl/hippie-swagger) - [Hippie](https://github.com/vesln/hippie) wrapper that provides end to end API testing with swagger validation
+- [react-form-controlled](https://github.com/seeden/react-form-controlled) - React controlled form components with validation
+- [rabbitmq-schema](https://github.com/tjmehta/rabbitmq-schema) - a schema definition module for RabbitMQ graphs and messages
+- [@query/schema](https://www.npmjs.com/package/@query/schema) - stream filtering with a URI-safe query syntax parsing to JSON Schema
+- [chai-ajv-json-schema](https://github.com/peon374/chai-ajv-json-schema) - chai plugin to us JSON Schema with expect in mocha tests
+- [grunt-jsonschema-ajv](https://github.com/SignpostMarv/grunt-jsonschema-ajv) - Grunt plugin for validating files against JSON Schema
+- [extract-text-webpack-plugin](https://github.com/webpack-contrib/extract-text-webpack-plugin) - extract text from bundle into a file
+- [electron-builder](https://github.com/electron-userland/electron-builder) - a solution to package and build a ready for distribution Electron app
+- [addons-linter](https://github.com/mozilla/addons-linter) - Mozilla Add-ons Linter
+- [gh-pages-generator](https://github.com/epoberezkin/gh-pages-generator) - multi-page site generator converting markdown files to GitHub pages
+- [ESLint](https://github.com/eslint/eslint) - the pluggable linting utility for JavaScript and JSX
+
+
+## Tests
+
+```
+npm install
+git submodule update --init
+npm test
+```
+
+## Contributing
+
+All validation functions are generated using doT templates in [dot](https://github.com/ajv-validator/ajv/tree/master/lib/dot) folder. Templates are precompiled so doT is not a run-time dependency.
+
+`npm run build` - compiles templates to [dotjs](https://github.com/ajv-validator/ajv/tree/master/lib/dotjs) folder.
+
+`npm run watch` - automatically compiles templates when files in dot folder change
+
+Please see [Contributing guidelines](https://github.com/ajv-validator/ajv/blob/master/CONTRIBUTING.md)
+
+
+## Changes history
+
+See https://github.com/ajv-validator/ajv/releases
+
+__Please note__: [Changes in version 7.0.0-beta](https://github.com/ajv-validator/ajv/releases/tag/v7.0.0-beta.0)
+
+[Version 6.0.0](https://github.com/ajv-validator/ajv/releases/tag/v6.0.0).
+
+## Code of conduct
+
+Please review and follow the [Code of conduct](https://github.com/ajv-validator/ajv/blob/master/CODE_OF_CONDUCT.md).
+
+Please report any unacceptable behaviour to ajv.validator@gmail.com - it will be reviewed by the project team.
+
+
+## Open-source software support
+
+Ajv is a part of [Tidelift subscription](https://tidelift.com/subscription/pkg/npm-ajv?utm_source=npm-ajv&utm_medium=referral&utm_campaign=readme) - it provides a centralised support to open-source software users, in addition to the support provided by software maintainers.
+
+
+## License
+
+[MIT](https://github.com/ajv-validator/ajv/blob/master/LICENSE)
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/ajv/package.json b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/ajv/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..559a933c8c1c0395b77bdd9daa064f650d4445ef
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/ajv/package.json
@@ -0,0 +1,106 @@
+{
+ "name": "ajv",
+ "version": "6.12.6",
+ "description": "Another JSON Schema Validator",
+ "main": "lib/ajv.js",
+ "typings": "lib/ajv.d.ts",
+ "files": [
+ "lib/",
+ "dist/",
+ "scripts/",
+ "LICENSE",
+ ".tonic_example.js"
+ ],
+ "scripts": {
+ "eslint": "eslint lib/{compile/,}*.js spec/{**/,}*.js scripts --ignore-pattern spec/JSON-Schema-Test-Suite",
+ "jshint": "jshint lib/{compile/,}*.js",
+ "lint": "npm run jshint && npm run eslint",
+ "test-spec": "mocha spec/{**/,}*.spec.js -R spec",
+ "test-fast": "AJV_FAST_TEST=true npm run test-spec",
+ "test-debug": "npm run test-spec -- --inspect-brk",
+ "test-cov": "nyc npm run test-spec",
+ "test-ts": "tsc --target ES5 --noImplicitAny --noEmit spec/typescript/index.ts",
+ "bundle": "del-cli dist && node ./scripts/bundle.js . Ajv pure_getters",
+ "bundle-beautify": "node ./scripts/bundle.js js-beautify",
+ "build": "del-cli lib/dotjs/*.js \"!lib/dotjs/index.js\" && node scripts/compile-dots.js",
+ "test-karma": "karma start",
+ "test-browser": "del-cli .browser && npm run bundle && scripts/prepare-tests && npm run test-karma",
+ "test-all": "npm run test-cov && if-node-version 10 npm run test-browser",
+ "test": "npm run lint && npm run build && npm run test-all",
+ "prepublish": "npm run build && npm run bundle",
+ "watch": "watch \"npm run build\" ./lib/dot"
+ },
+ "nyc": {
+ "exclude": [
+ "**/spec/**",
+ "node_modules"
+ ],
+ "reporter": [
+ "lcov",
+ "text-summary"
+ ]
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/ajv-validator/ajv.git"
+ },
+ "keywords": [
+ "JSON",
+ "schema",
+ "validator",
+ "validation",
+ "jsonschema",
+ "json-schema",
+ "json-schema-validator",
+ "json-schema-validation"
+ ],
+ "author": "Evgeny Poberezkin",
+ "license": "MIT",
+ "bugs": {
+ "url": "https://github.com/ajv-validator/ajv/issues"
+ },
+ "homepage": "https://github.com/ajv-validator/ajv",
+ "tonicExampleFilename": ".tonic_example.js",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.1",
+ "fast-json-stable-stringify": "^2.0.0",
+ "json-schema-traverse": "^0.4.1",
+ "uri-js": "^4.2.2"
+ },
+ "devDependencies": {
+ "ajv-async": "^1.0.0",
+ "bluebird": "^3.5.3",
+ "brfs": "^2.0.0",
+ "browserify": "^16.2.0",
+ "chai": "^4.0.1",
+ "coveralls": "^3.0.1",
+ "del-cli": "^3.0.0",
+ "dot": "^1.0.3",
+ "eslint": "^7.3.1",
+ "gh-pages-generator": "^0.2.3",
+ "glob": "^7.0.0",
+ "if-node-version": "^1.0.0",
+ "js-beautify": "^1.7.3",
+ "jshint": "^2.10.2",
+ "json-schema-test": "^2.0.0",
+ "karma": "^5.0.0",
+ "karma-chrome-launcher": "^3.0.0",
+ "karma-mocha": "^2.0.0",
+ "karma-sauce-launcher": "^4.1.3",
+ "mocha": "^8.0.1",
+ "nyc": "^15.0.0",
+ "pre-commit": "^1.1.1",
+ "require-globify": "^1.3.0",
+ "typescript": "^3.9.5",
+ "uglify-js": "^3.6.9",
+ "watch": "^1.0.0"
+ },
+ "collective": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/ajv"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+}
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/ansi-styles/index.d.ts b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/ansi-styles/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..44a907e580f1055a36d44111fda9463ed1cd2d26
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/ansi-styles/index.d.ts
@@ -0,0 +1,345 @@
+declare type CSSColor =
+ | 'aliceblue'
+ | 'antiquewhite'
+ | 'aqua'
+ | 'aquamarine'
+ | 'azure'
+ | 'beige'
+ | 'bisque'
+ | 'black'
+ | 'blanchedalmond'
+ | 'blue'
+ | 'blueviolet'
+ | 'brown'
+ | 'burlywood'
+ | 'cadetblue'
+ | 'chartreuse'
+ | 'chocolate'
+ | 'coral'
+ | 'cornflowerblue'
+ | 'cornsilk'
+ | 'crimson'
+ | 'cyan'
+ | 'darkblue'
+ | 'darkcyan'
+ | 'darkgoldenrod'
+ | 'darkgray'
+ | 'darkgreen'
+ | 'darkgrey'
+ | 'darkkhaki'
+ | 'darkmagenta'
+ | 'darkolivegreen'
+ | 'darkorange'
+ | 'darkorchid'
+ | 'darkred'
+ | 'darksalmon'
+ | 'darkseagreen'
+ | 'darkslateblue'
+ | 'darkslategray'
+ | 'darkslategrey'
+ | 'darkturquoise'
+ | 'darkviolet'
+ | 'deeppink'
+ | 'deepskyblue'
+ | 'dimgray'
+ | 'dimgrey'
+ | 'dodgerblue'
+ | 'firebrick'
+ | 'floralwhite'
+ | 'forestgreen'
+ | 'fuchsia'
+ | 'gainsboro'
+ | 'ghostwhite'
+ | 'gold'
+ | 'goldenrod'
+ | 'gray'
+ | 'green'
+ | 'greenyellow'
+ | 'grey'
+ | 'honeydew'
+ | 'hotpink'
+ | 'indianred'
+ | 'indigo'
+ | 'ivory'
+ | 'khaki'
+ | 'lavender'
+ | 'lavenderblush'
+ | 'lawngreen'
+ | 'lemonchiffon'
+ | 'lightblue'
+ | 'lightcoral'
+ | 'lightcyan'
+ | 'lightgoldenrodyellow'
+ | 'lightgray'
+ | 'lightgreen'
+ | 'lightgrey'
+ | 'lightpink'
+ | 'lightsalmon'
+ | 'lightseagreen'
+ | 'lightskyblue'
+ | 'lightslategray'
+ | 'lightslategrey'
+ | 'lightsteelblue'
+ | 'lightyellow'
+ | 'lime'
+ | 'limegreen'
+ | 'linen'
+ | 'magenta'
+ | 'maroon'
+ | 'mediumaquamarine'
+ | 'mediumblue'
+ | 'mediumorchid'
+ | 'mediumpurple'
+ | 'mediumseagreen'
+ | 'mediumslateblue'
+ | 'mediumspringgreen'
+ | 'mediumturquoise'
+ | 'mediumvioletred'
+ | 'midnightblue'
+ | 'mintcream'
+ | 'mistyrose'
+ | 'moccasin'
+ | 'navajowhite'
+ | 'navy'
+ | 'oldlace'
+ | 'olive'
+ | 'olivedrab'
+ | 'orange'
+ | 'orangered'
+ | 'orchid'
+ | 'palegoldenrod'
+ | 'palegreen'
+ | 'paleturquoise'
+ | 'palevioletred'
+ | 'papayawhip'
+ | 'peachpuff'
+ | 'peru'
+ | 'pink'
+ | 'plum'
+ | 'powderblue'
+ | 'purple'
+ | 'rebeccapurple'
+ | 'red'
+ | 'rosybrown'
+ | 'royalblue'
+ | 'saddlebrown'
+ | 'salmon'
+ | 'sandybrown'
+ | 'seagreen'
+ | 'seashell'
+ | 'sienna'
+ | 'silver'
+ | 'skyblue'
+ | 'slateblue'
+ | 'slategray'
+ | 'slategrey'
+ | 'snow'
+ | 'springgreen'
+ | 'steelblue'
+ | 'tan'
+ | 'teal'
+ | 'thistle'
+ | 'tomato'
+ | 'turquoise'
+ | 'violet'
+ | 'wheat'
+ | 'white'
+ | 'whitesmoke'
+ | 'yellow'
+ | 'yellowgreen';
+
+declare namespace ansiStyles {
+ interface ColorConvert {
+ /**
+ The RGB color space.
+
+ @param red - (`0`-`255`)
+ @param green - (`0`-`255`)
+ @param blue - (`0`-`255`)
+ */
+ rgb(red: number, green: number, blue: number): string;
+
+ /**
+ The RGB HEX color space.
+
+ @param hex - A hexadecimal string containing RGB data.
+ */
+ hex(hex: string): string;
+
+ /**
+ @param keyword - A CSS color name.
+ */
+ keyword(keyword: CSSColor): string;
+
+ /**
+ The HSL color space.
+
+ @param hue - (`0`-`360`)
+ @param saturation - (`0`-`100`)
+ @param lightness - (`0`-`100`)
+ */
+ hsl(hue: number, saturation: number, lightness: number): string;
+
+ /**
+ The HSV color space.
+
+ @param hue - (`0`-`360`)
+ @param saturation - (`0`-`100`)
+ @param value - (`0`-`100`)
+ */
+ hsv(hue: number, saturation: number, value: number): string;
+
+ /**
+ The HSV color space.
+
+ @param hue - (`0`-`360`)
+ @param whiteness - (`0`-`100`)
+ @param blackness - (`0`-`100`)
+ */
+ hwb(hue: number, whiteness: number, blackness: number): string;
+
+ /**
+ Use a [4-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4-bit) to set text color.
+ */
+ ansi(ansi: number): string;
+
+ /**
+ Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+ */
+ ansi256(ansi: number): string;
+ }
+
+ interface CSPair {
+ /**
+ The ANSI terminal control sequence for starting this style.
+ */
+ readonly open: string;
+
+ /**
+ The ANSI terminal control sequence for ending this style.
+ */
+ readonly close: string;
+ }
+
+ interface ColorBase {
+ readonly ansi: ColorConvert;
+ readonly ansi256: ColorConvert;
+ readonly ansi16m: ColorConvert;
+
+ /**
+ The ANSI terminal control sequence for ending this color.
+ */
+ readonly close: string;
+ }
+
+ interface Modifier {
+ /**
+ Resets the current color chain.
+ */
+ readonly reset: CSPair;
+
+ /**
+ Make text bold.
+ */
+ readonly bold: CSPair;
+
+ /**
+ Emitting only a small amount of light.
+ */
+ readonly dim: CSPair;
+
+ /**
+ Make text italic. (Not widely supported)
+ */
+ readonly italic: CSPair;
+
+ /**
+ Make text underline. (Not widely supported)
+ */
+ readonly underline: CSPair;
+
+ /**
+ Inverse background and foreground colors.
+ */
+ readonly inverse: CSPair;
+
+ /**
+ Prints the text, but makes it invisible.
+ */
+ readonly hidden: CSPair;
+
+ /**
+ Puts a horizontal line through the center of the text. (Not widely supported)
+ */
+ readonly strikethrough: CSPair;
+ }
+
+ interface ForegroundColor {
+ readonly black: CSPair;
+ readonly red: CSPair;
+ readonly green: CSPair;
+ readonly yellow: CSPair;
+ readonly blue: CSPair;
+ readonly cyan: CSPair;
+ readonly magenta: CSPair;
+ readonly white: CSPair;
+
+ /**
+ Alias for `blackBright`.
+ */
+ readonly gray: CSPair;
+
+ /**
+ Alias for `blackBright`.
+ */
+ readonly grey: CSPair;
+
+ readonly blackBright: CSPair;
+ readonly redBright: CSPair;
+ readonly greenBright: CSPair;
+ readonly yellowBright: CSPair;
+ readonly blueBright: CSPair;
+ readonly cyanBright: CSPair;
+ readonly magentaBright: CSPair;
+ readonly whiteBright: CSPair;
+ }
+
+ interface BackgroundColor {
+ readonly bgBlack: CSPair;
+ readonly bgRed: CSPair;
+ readonly bgGreen: CSPair;
+ readonly bgYellow: CSPair;
+ readonly bgBlue: CSPair;
+ readonly bgCyan: CSPair;
+ readonly bgMagenta: CSPair;
+ readonly bgWhite: CSPair;
+
+ /**
+ Alias for `bgBlackBright`.
+ */
+ readonly bgGray: CSPair;
+
+ /**
+ Alias for `bgBlackBright`.
+ */
+ readonly bgGrey: CSPair;
+
+ readonly bgBlackBright: CSPair;
+ readonly bgRedBright: CSPair;
+ readonly bgGreenBright: CSPair;
+ readonly bgYellowBright: CSPair;
+ readonly bgBlueBright: CSPair;
+ readonly bgCyanBright: CSPair;
+ readonly bgMagentaBright: CSPair;
+ readonly bgWhiteBright: CSPair;
+ }
+}
+
+declare const ansiStyles: {
+ readonly modifier: ansiStyles.Modifier;
+ readonly color: ansiStyles.ForegroundColor & ansiStyles.ColorBase;
+ readonly bgColor: ansiStyles.BackgroundColor & ansiStyles.ColorBase;
+ readonly codes: ReadonlyMap
+
+## Install
+
+```
+$ npm install ansi-styles
+```
+
+## Usage
+
+```js
+const style = require('ansi-styles');
+
+console.log(`${style.green.open}Hello world!${style.green.close}`);
+
+
+// Color conversion between 16/256/truecolor
+// NOTE: If conversion goes to 16 colors or 256 colors, the original color
+// may be degraded to fit that color palette. This means terminals
+// that do not support 16 million colors will best-match the
+// original color.
+console.log(style.bgColor.ansi.hsl(120, 80, 72) + 'Hello world!' + style.bgColor.close);
+console.log(style.color.ansi256.rgb(199, 20, 250) + 'Hello world!' + style.color.close);
+console.log(style.color.ansi16m.hex('#abcdef') + 'Hello world!' + style.color.close);
+```
+
+## API
+
+Each style has an `open` and `close` property.
+
+## Styles
+
+### Modifiers
+
+- `reset`
+- `bold`
+- `dim`
+- `italic` *(Not widely supported)*
+- `underline`
+- `inverse`
+- `hidden`
+- `strikethrough` *(Not widely supported)*
+
+### Colors
+
+- `black`
+- `red`
+- `green`
+- `yellow`
+- `blue`
+- `magenta`
+- `cyan`
+- `white`
+- `blackBright` (alias: `gray`, `grey`)
+- `redBright`
+- `greenBright`
+- `yellowBright`
+- `blueBright`
+- `magentaBright`
+- `cyanBright`
+- `whiteBright`
+
+### Background colors
+
+- `bgBlack`
+- `bgRed`
+- `bgGreen`
+- `bgYellow`
+- `bgBlue`
+- `bgMagenta`
+- `bgCyan`
+- `bgWhite`
+- `bgBlackBright` (alias: `bgGray`, `bgGrey`)
+- `bgRedBright`
+- `bgGreenBright`
+- `bgYellowBright`
+- `bgBlueBright`
+- `bgMagentaBright`
+- `bgCyanBright`
+- `bgWhiteBright`
+
+## Advanced usage
+
+By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module.
+
+- `style.modifier`
+- `style.color`
+- `style.bgColor`
+
+###### Example
+
+```js
+console.log(style.color.green.open);
+```
+
+Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values.
+
+###### Example
+
+```js
+console.log(style.codes.get(36));
+//=> 39
+```
+
+## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728)
+
+`ansi-styles` uses the [`color-convert`](https://github.com/Qix-/color-convert) package to allow for converting between various colors and ANSI escapes, with support for 256 and 16 million colors.
+
+The following color spaces from `color-convert` are supported:
+
+- `rgb`
+- `hex`
+- `keyword`
+- `hsl`
+- `hsv`
+- `hwb`
+- `ansi`
+- `ansi256`
+
+To use these, call the associated conversion function with the intended output, for example:
+
+```js
+style.color.ansi.rgb(100, 200, 15); // RGB to 16 color ansi foreground code
+style.bgColor.ansi.rgb(100, 200, 15); // RGB to 16 color ansi background code
+
+style.color.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+style.bgColor.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code
+
+style.color.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color foreground code
+style.bgColor.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color background code
+```
+
+## Related
+
+- [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+## For enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of `ansi-styles` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-ansi-styles?utm_source=npm-ansi-styles&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/CHANGELOG.md b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc39ed6952f87adcd961d07749e1ffe7a2b7335b
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/CHANGELOG.md
@@ -0,0 +1,216 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+## [2.0.1] - 2020-08-29
+### Fixed
+- Fix issue with `process.argv` when used with interpreters (`coffee`, `ts-node`, etc.), #150.
+
+
+## [2.0.0] - 2020-08-14
+### Changed
+- Full rewrite. Now port from python 3.9.0 & more precise following.
+ See [doc](./doc) for difference and migration info.
+- node.js 10+ required
+- Removed most of local docs in favour of original ones.
+
+
+## [1.0.10] - 2018-02-15
+### Fixed
+- Use .concat instead of + for arrays, #122.
+
+
+## [1.0.9] - 2016-09-29
+### Changed
+- Rerelease after 1.0.8 - deps cleanup.
+
+
+## [1.0.8] - 2016-09-29
+### Changed
+- Maintenance (deps bump, fix node 6.5+ tests, coverage report).
+
+
+## [1.0.7] - 2016-03-17
+### Changed
+- Teach `addArgument` to accept string arg names. #97, @tomxtobin.
+
+
+## [1.0.6] - 2016-02-06
+### Changed
+- Maintenance: moved to eslint & updated CS.
+
+
+## [1.0.5] - 2016-02-05
+### Changed
+- Removed lodash dependency to significantly reduce install size.
+ Thanks to @mourner.
+
+
+## [1.0.4] - 2016-01-17
+### Changed
+- Maintenance: lodash update to 4.0.0.
+
+
+## [1.0.3] - 2015-10-27
+### Fixed
+- Fix parse `=` in args: `--examplepath="C:\myfolder\env=x64"`. #84, @CatWithApple.
+
+
+## [1.0.2] - 2015-03-22
+### Changed
+- Relaxed lodash version dependency.
+
+
+## [1.0.1] - 2015-02-20
+### Changed
+- Changed dependencies to be compatible with ancient nodejs.
+
+
+## [1.0.0] - 2015-02-19
+### Changed
+- Maintenance release.
+- Replaced `underscore` with `lodash`.
+- Bumped version to 1.0.0 to better reflect semver meaning.
+- HISTORY.md -> CHANGELOG.md
+
+
+## [0.1.16] - 2013-12-01
+### Changed
+- Maintenance release. Updated dependencies and docs.
+
+
+## [0.1.15] - 2013-05-13
+### Fixed
+- Fixed #55, @trebor89
+
+
+## [0.1.14] - 2013-05-12
+### Fixed
+- Fixed #62, @maxtaco
+
+
+## [0.1.13] - 2013-04-08
+### Changed
+- Added `.npmignore` to reduce package size
+
+
+## [0.1.12] - 2013-02-10
+### Fixed
+- Fixed conflictHandler (#46), @hpaulj
+
+
+## [0.1.11] - 2013-02-07
+### Added
+- Added 70+ tests (ported from python), @hpaulj
+- Added conflictHandler, @applepicke
+- Added fromfilePrefixChar, @hpaulj
+
+### Fixed
+- Multiple bugfixes, @hpaulj
+
+
+## [0.1.10] - 2012-12-30
+### Added
+- Added [mutual exclusion](http://docs.python.org/dev/library/argparse.html#mutual-exclusion)
+ support, thanks to @hpaulj
+
+### Fixed
+- Fixed options check for `storeConst` & `appendConst` actions, thanks to @hpaulj
+
+
+## [0.1.9] - 2012-12-27
+### Fixed
+- Fixed option dest interferens with other options (issue #23), thanks to @hpaulj
+- Fixed default value behavior with `*` positionals, thanks to @hpaulj
+- Improve `getDefault()` behavior, thanks to @hpaulj
+- Improve negative argument parsing, thanks to @hpaulj
+
+
+## [0.1.8] - 2012-12-01
+### Fixed
+- Fixed parser parents (issue #19), thanks to @hpaulj
+- Fixed negative argument parse (issue #20), thanks to @hpaulj
+
+
+## [0.1.7] - 2012-10-14
+### Fixed
+- Fixed 'choices' argument parse (issue #16)
+- Fixed stderr output (issue #15)
+
+
+## [0.1.6] - 2012-09-09
+### Fixed
+- Fixed check for conflict of options (thanks to @tomxtobin)
+
+
+## [0.1.5] - 2012-09-03
+### Fixed
+- Fix parser #setDefaults method (thanks to @tomxtobin)
+
+
+## [0.1.4] - 2012-07-30
+### Fixed
+- Fixed pseudo-argument support (thanks to @CGamesPlay)
+- Fixed addHelp default (should be true), if not set (thanks to @benblank)
+
+
+## [0.1.3] - 2012-06-27
+### Fixed
+- Fixed formatter api name: Formatter -> HelpFormatter
+
+
+## [0.1.2] - 2012-05-29
+### Fixed
+- Removed excess whitespace in help
+- Fixed error reporting, when parcer with subcommands
+ called with empty arguments
+
+### Added
+- Added basic tests
+
+
+## [0.1.1] - 2012-05-23
+### Fixed
+- Fixed line wrapping in help formatter
+- Added better error reporting on invalid arguments
+
+
+## [0.1.0] - 2012-05-16
+### Added
+- First release.
+
+
+[2.0.1]: https://github.com/nodeca/argparse/compare/2.0.0...2.0.1
+[2.0.0]: https://github.com/nodeca/argparse/compare/1.0.10...2.0.0
+[1.0.10]: https://github.com/nodeca/argparse/compare/1.0.9...1.0.10
+[1.0.9]: https://github.com/nodeca/argparse/compare/1.0.8...1.0.9
+[1.0.8]: https://github.com/nodeca/argparse/compare/1.0.7...1.0.8
+[1.0.7]: https://github.com/nodeca/argparse/compare/1.0.6...1.0.7
+[1.0.6]: https://github.com/nodeca/argparse/compare/1.0.5...1.0.6
+[1.0.5]: https://github.com/nodeca/argparse/compare/1.0.4...1.0.5
+[1.0.4]: https://github.com/nodeca/argparse/compare/1.0.3...1.0.4
+[1.0.3]: https://github.com/nodeca/argparse/compare/1.0.2...1.0.3
+[1.0.2]: https://github.com/nodeca/argparse/compare/1.0.1...1.0.2
+[1.0.1]: https://github.com/nodeca/argparse/compare/1.0.0...1.0.1
+[1.0.0]: https://github.com/nodeca/argparse/compare/0.1.16...1.0.0
+[0.1.16]: https://github.com/nodeca/argparse/compare/0.1.15...0.1.16
+[0.1.15]: https://github.com/nodeca/argparse/compare/0.1.14...0.1.15
+[0.1.14]: https://github.com/nodeca/argparse/compare/0.1.13...0.1.14
+[0.1.13]: https://github.com/nodeca/argparse/compare/0.1.12...0.1.13
+[0.1.12]: https://github.com/nodeca/argparse/compare/0.1.11...0.1.12
+[0.1.11]: https://github.com/nodeca/argparse/compare/0.1.10...0.1.11
+[0.1.10]: https://github.com/nodeca/argparse/compare/0.1.9...0.1.10
+[0.1.9]: https://github.com/nodeca/argparse/compare/0.1.8...0.1.9
+[0.1.8]: https://github.com/nodeca/argparse/compare/0.1.7...0.1.8
+[0.1.7]: https://github.com/nodeca/argparse/compare/0.1.6...0.1.7
+[0.1.6]: https://github.com/nodeca/argparse/compare/0.1.5...0.1.6
+[0.1.5]: https://github.com/nodeca/argparse/compare/0.1.4...0.1.5
+[0.1.4]: https://github.com/nodeca/argparse/compare/0.1.3...0.1.4
+[0.1.3]: https://github.com/nodeca/argparse/compare/0.1.2...0.1.3
+[0.1.2]: https://github.com/nodeca/argparse/compare/0.1.1...0.1.2
+[0.1.1]: https://github.com/nodeca/argparse/compare/0.1.0...0.1.1
+[0.1.0]: https://github.com/nodeca/argparse/releases/tag/0.1.0
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/LICENSE b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..66a3ac80d729a3a5bdfd22002d34be59a6daf222
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/LICENSE
@@ -0,0 +1,254 @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC. Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team. In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation. In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition). Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+ Release Derived Year Owner GPL-
+ from compatible? (1)
+
+ 0.9.0 thru 1.2 1991-1995 CWI yes
+ 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
+ 1.6 1.5.2 2000 CNRI no
+ 2.0 1.6 2000 BeOpen.com no
+ 1.6.1 1.6 2001 CNRI yes (2)
+ 2.1 2.0+1.6.1 2001 PSF no
+ 2.0.1 2.0+1.6.1 2001 PSF yes
+ 2.1.1 2.1+2.0.1 2001 PSF yes
+ 2.1.2 2.1.1 2002 PSF yes
+ 2.1.3 2.1.2 2002 PSF yes
+ 2.2 and above 2.1.1 2001-now PSF yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+ the GPL. All Python licenses, unlike the GPL, let you distribute
+ a modified version without making your changes open source. The
+ GPL-compatible licenses make it possible to combine Python with
+ other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+ because its license has a choice of law clause. According to
+ CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+ is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee. This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions. Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee. This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party. As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee. Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement. This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013. This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee. This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+ ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands. All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/README.md b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..550b5c9b7b00aaa18ba240b485e5b31598ef04b2
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/README.md
@@ -0,0 +1,84 @@
+argparse
+========
+
+[](http://travis-ci.org/nodeca/argparse)
+[](https://www.npmjs.org/package/argparse)
+
+CLI arguments parser for node.js, with [sub-commands](https://docs.python.org/3.9/library/argparse.html#sub-commands) support. Port of python's [argparse](http://docs.python.org/dev/library/argparse.html) (version [3.9.0](https://github.com/python/cpython/blob/v3.9.0rc1/Lib/argparse.py)).
+
+**Difference with original.**
+
+- JS has no keyword arguments support.
+ - Pass options instead: `new ArgumentParser({ description: 'example', add_help: true })`.
+- JS has no python's types `int`, `float`, ...
+ - Use string-typed names: `.add_argument('-b', { type: 'int', help: 'help' })`.
+- `%r` format specifier uses `require('util').inspect()`.
+
+More details in [doc](./doc).
+
+
+Example
+-------
+
+`test.js` file:
+
+```javascript
+#!/usr/bin/env node
+'use strict';
+
+const { ArgumentParser } = require('argparse');
+const { version } = require('./package.json');
+
+const parser = new ArgumentParser({
+ description: 'Argparse example'
+});
+
+parser.add_argument('-v', '--version', { action: 'version', version });
+parser.add_argument('-f', '--foo', { help: 'foo bar' });
+parser.add_argument('-b', '--bar', { help: 'bar foo' });
+parser.add_argument('--baz', { help: 'baz bar' });
+
+console.dir(parser.parse_args());
+```
+
+Display help:
+
+```
+$ ./test.js -h
+usage: test.js [-h] [-v] [-f FOO] [-b BAR] [--baz BAZ]
+
+Argparse example
+
+optional arguments:
+ -h, --help show this help message and exit
+ -v, --version show program's version number and exit
+ -f FOO, --foo FOO foo bar
+ -b BAR, --bar BAR bar foo
+ --baz BAZ baz bar
+```
+
+Parse arguments:
+
+```
+$ ./test.js -f=3 --bar=4 --baz 5
+{ foo: '3', bar: '4', baz: '5' }
+```
+
+
+API docs
+--------
+
+Since this is a port with minimal divergence, there's no separate documentation.
+Use original one instead, with notes about difference.
+
+1. [Original doc](https://docs.python.org/3.9/library/argparse.html).
+2. [Original tutorial](https://docs.python.org/3.9/howto/argparse.html).
+3. [Difference with python](./doc).
+
+
+argparse for enterprise
+-----------------------
+
+Available as part of the Tidelift Subscription
+
+The maintainers of argparse and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-argparse?utm_source=npm-argparse&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/argparse.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/argparse.js
new file mode 100644
index 0000000000000000000000000000000000000000..2b8c8c63177af9757a44926cfc3ab7d9878c9387
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/argparse.js
@@ -0,0 +1,3707 @@
+// Port of python's argparse module, version 3.9.0:
+// https://github.com/python/cpython/blob/v3.9.0rc1/Lib/argparse.py
+
+'use strict'
+
+// Copyright (C) 2010-2020 Python Software Foundation.
+// Copyright (C) 2020 argparse.js authors
+
+/*
+ * Command-line parsing library
+ *
+ * This module is an optparse-inspired command-line parsing library that:
+ *
+ * - handles both optional and positional arguments
+ * - produces highly informative usage messages
+ * - supports parsers that dispatch to sub-parsers
+ *
+ * The following is a simple usage example that sums integers from the
+ * command-line and writes the result to a file::
+ *
+ * parser = argparse.ArgumentParser(
+ * description='sum the integers at the command line')
+ * parser.add_argument(
+ * 'integers', metavar='int', nargs='+', type=int,
+ * help='an integer to be summed')
+ * parser.add_argument(
+ * '--log', default=sys.stdout, type=argparse.FileType('w'),
+ * help='the file where the sum should be written')
+ * args = parser.parse_args()
+ * args.log.write('%s' % sum(args.integers))
+ * args.log.close()
+ *
+ * The module contains the following public classes:
+ *
+ * - ArgumentParser -- The main entry point for command-line parsing. As the
+ * example above shows, the add_argument() method is used to populate
+ * the parser with actions for optional and positional arguments. Then
+ * the parse_args() method is invoked to convert the args at the
+ * command-line into an object with attributes.
+ *
+ * - ArgumentError -- The exception raised by ArgumentParser objects when
+ * there are errors with the parser's actions. Errors raised while
+ * parsing the command-line are caught by ArgumentParser and emitted
+ * as command-line messages.
+ *
+ * - FileType -- A factory for defining types of files to be created. As the
+ * example above shows, instances of FileType are typically passed as
+ * the type= argument of add_argument() calls.
+ *
+ * - Action -- The base class for parser actions. Typically actions are
+ * selected by passing strings like 'store_true' or 'append_const' to
+ * the action= argument of add_argument(). However, for greater
+ * customization of ArgumentParser actions, subclasses of Action may
+ * be defined and passed as the action= argument.
+ *
+ * - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
+ * ArgumentDefaultsHelpFormatter -- Formatter classes which
+ * may be passed as the formatter_class= argument to the
+ * ArgumentParser constructor. HelpFormatter is the default,
+ * RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
+ * not to change the formatting for help text, and
+ * ArgumentDefaultsHelpFormatter adds information about argument defaults
+ * to the help.
+ *
+ * All other classes in this module are considered implementation details.
+ * (Also note that HelpFormatter and RawDescriptionHelpFormatter are only
+ * considered public as object names -- the API of the formatter objects is
+ * still considered an implementation detail.)
+ */
+
+const SUPPRESS = '==SUPPRESS=='
+
+const OPTIONAL = '?'
+const ZERO_OR_MORE = '*'
+const ONE_OR_MORE = '+'
+const PARSER = 'A...'
+const REMAINDER = '...'
+const _UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
+
+
+// ==================================
+// Utility functions used for porting
+// ==================================
+const assert = require('assert')
+const util = require('util')
+const fs = require('fs')
+const sub = require('./lib/sub')
+const path = require('path')
+const repr = util.inspect
+
+function get_argv() {
+ // omit first argument (which is assumed to be interpreter - `node`, `coffee`, `ts-node`, etc.)
+ return process.argv.slice(1)
+}
+
+function get_terminal_size() {
+ return {
+ columns: +process.env.COLUMNS || process.stdout.columns || 80
+ }
+}
+
+function hasattr(object, name) {
+ return Object.prototype.hasOwnProperty.call(object, name)
+}
+
+function getattr(object, name, value) {
+ return hasattr(object, name) ? object[name] : value
+}
+
+function setattr(object, name, value) {
+ object[name] = value
+}
+
+function setdefault(object, name, value) {
+ if (!hasattr(object, name)) object[name] = value
+ return object[name]
+}
+
+function delattr(object, name) {
+ delete object[name]
+}
+
+function range(from, to, step=1) {
+ // range(10) is equivalent to range(0, 10)
+ if (arguments.length === 1) [ to, from ] = [ from, 0 ]
+ if (typeof from !== 'number' || typeof to !== 'number' || typeof step !== 'number') {
+ throw new TypeError('argument cannot be interpreted as an integer')
+ }
+ if (step === 0) throw new TypeError('range() arg 3 must not be zero')
+
+ let result = []
+ if (step > 0) {
+ for (let i = from; i < to; i += step) result.push(i)
+ } else {
+ for (let i = from; i > to; i += step) result.push(i)
+ }
+ return result
+}
+
+function splitlines(str, keepends = false) {
+ let result
+ if (!keepends) {
+ result = str.split(/\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029]/)
+ } else {
+ result = []
+ let parts = str.split(/(\r\n|[\n\r\v\f\x1c\x1d\x1e\x85\u2028\u2029])/)
+ for (let i = 0; i < parts.length; i += 2) {
+ result.push(parts[i] + (i + 1 < parts.length ? parts[i + 1] : ''))
+ }
+ }
+ if (!result[result.length - 1]) result.pop()
+ return result
+}
+
+function _string_lstrip(string, prefix_chars) {
+ let idx = 0
+ while (idx < string.length && prefix_chars.includes(string[idx])) idx++
+ return idx ? string.slice(idx) : string
+}
+
+function _string_split(string, sep, maxsplit) {
+ let result = string.split(sep)
+ if (result.length > maxsplit) {
+ result = result.slice(0, maxsplit).concat([ result.slice(maxsplit).join(sep) ])
+ }
+ return result
+}
+
+function _array_equal(array1, array2) {
+ if (array1.length !== array2.length) return false
+ for (let i = 0; i < array1.length; i++) {
+ if (array1[i] !== array2[i]) return false
+ }
+ return true
+}
+
+function _array_remove(array, item) {
+ let idx = array.indexOf(item)
+ if (idx === -1) throw new TypeError(sub('%r not in list', item))
+ array.splice(idx, 1)
+}
+
+// normalize choices to array;
+// this isn't required in python because `in` and `map` operators work with anything,
+// but in js dealing with multiple types here is too clunky
+function _choices_to_array(choices) {
+ if (choices === undefined) {
+ return []
+ } else if (Array.isArray(choices)) {
+ return choices
+ } else if (choices !== null && typeof choices[Symbol.iterator] === 'function') {
+ return Array.from(choices)
+ } else if (typeof choices === 'object' && choices !== null) {
+ return Object.keys(choices)
+ } else {
+ throw new Error(sub('invalid choices value: %r', choices))
+ }
+}
+
+// decorator that allows a class to be called without new
+function _callable(cls) {
+ let result = { // object is needed for inferred class name
+ [cls.name]: function (...args) {
+ let this_class = new.target === result || !new.target
+ return Reflect.construct(cls, args, this_class ? cls : new.target)
+ }
+ }
+ result[cls.name].prototype = cls.prototype
+ // fix default tag for toString, e.g. [object Action] instead of [object Object]
+ cls.prototype[Symbol.toStringTag] = cls.name
+ return result[cls.name]
+}
+
+function _alias(object, from, to) {
+ try {
+ let name = object.constructor.name
+ Object.defineProperty(object, from, {
+ value: util.deprecate(object[to], sub('%s.%s() is renamed to %s.%s()',
+ name, from, name, to)),
+ enumerable: false
+ })
+ } catch {}
+}
+
+// decorator that allows snake_case class methods to be called with camelCase and vice versa
+function _camelcase_alias(_class) {
+ for (let name of Object.getOwnPropertyNames(_class.prototype)) {
+ let camelcase = name.replace(/\w_[a-z]/g, s => s[0] + s[2].toUpperCase())
+ if (camelcase !== name) _alias(_class.prototype, camelcase, name)
+ }
+ return _class
+}
+
+function _to_legacy_name(key) {
+ key = key.replace(/\w_[a-z]/g, s => s[0] + s[2].toUpperCase())
+ if (key === 'default') key = 'defaultValue'
+ if (key === 'const') key = 'constant'
+ return key
+}
+
+function _to_new_name(key) {
+ if (key === 'defaultValue') key = 'default'
+ if (key === 'constant') key = 'const'
+ key = key.replace(/[A-Z]/g, c => '_' + c.toLowerCase())
+ return key
+}
+
+// parse options
+let no_default = Symbol('no_default_value')
+function _parse_opts(args, descriptor) {
+ function get_name() {
+ let stack = new Error().stack.split('\n')
+ .map(x => x.match(/^ at (.*) \(.*\)$/))
+ .filter(Boolean)
+ .map(m => m[1])
+ .map(fn => fn.match(/[^ .]*$/)[0])
+
+ if (stack.length && stack[0] === get_name.name) stack.shift()
+ if (stack.length && stack[0] === _parse_opts.name) stack.shift()
+ return stack.length ? stack[0] : ''
+ }
+
+ args = Array.from(args)
+ let kwargs = {}
+ let result = []
+ let last_opt = args.length && args[args.length - 1]
+
+ if (typeof last_opt === 'object' && last_opt !== null && !Array.isArray(last_opt) &&
+ (!last_opt.constructor || last_opt.constructor.name === 'Object')) {
+ kwargs = Object.assign({}, args.pop())
+ }
+
+ // LEGACY (v1 compatibility): camelcase
+ let renames = []
+ for (let key of Object.keys(descriptor)) {
+ let old_name = _to_legacy_name(key)
+ if (old_name !== key && (old_name in kwargs)) {
+ if (key in kwargs) {
+ // default and defaultValue specified at the same time, happens often in old tests
+ //throw new TypeError(sub('%s() got multiple values for argument %r', get_name(), key))
+ } else {
+ kwargs[key] = kwargs[old_name]
+ }
+ renames.push([ old_name, key ])
+ delete kwargs[old_name]
+ }
+ }
+ if (renames.length) {
+ let name = get_name()
+ deprecate('camelcase_' + name, sub('%s(): following options are renamed: %s',
+ name, renames.map(([ a, b ]) => sub('%r -> %r', a, b))))
+ }
+ // end
+
+ let missing_positionals = []
+ let positional_count = args.length
+
+ for (let [ key, def ] of Object.entries(descriptor)) {
+ if (key[0] === '*') {
+ if (key.length > 0 && key[1] === '*') {
+ // LEGACY (v1 compatibility): camelcase
+ let renames = []
+ for (let key of Object.keys(kwargs)) {
+ let new_name = _to_new_name(key)
+ if (new_name !== key && (key in kwargs)) {
+ if (new_name in kwargs) {
+ // default and defaultValue specified at the same time, happens often in old tests
+ //throw new TypeError(sub('%s() got multiple values for argument %r', get_name(), new_name))
+ } else {
+ kwargs[new_name] = kwargs[key]
+ }
+ renames.push([ key, new_name ])
+ delete kwargs[key]
+ }
+ }
+ if (renames.length) {
+ let name = get_name()
+ deprecate('camelcase_' + name, sub('%s(): following options are renamed: %s',
+ name, renames.map(([ a, b ]) => sub('%r -> %r', a, b))))
+ }
+ // end
+ result.push(kwargs)
+ kwargs = {}
+ } else {
+ result.push(args)
+ args = []
+ }
+ } else if (key in kwargs && args.length > 0) {
+ throw new TypeError(sub('%s() got multiple values for argument %r', get_name(), key))
+ } else if (key in kwargs) {
+ result.push(kwargs[key])
+ delete kwargs[key]
+ } else if (args.length > 0) {
+ result.push(args.shift())
+ } else if (def !== no_default) {
+ result.push(def)
+ } else {
+ missing_positionals.push(key)
+ }
+ }
+
+ if (Object.keys(kwargs).length) {
+ throw new TypeError(sub('%s() got an unexpected keyword argument %r',
+ get_name(), Object.keys(kwargs)[0]))
+ }
+
+ if (args.length) {
+ let from = Object.entries(descriptor).filter(([ k, v ]) => k[0] !== '*' && v !== no_default).length
+ let to = Object.entries(descriptor).filter(([ k ]) => k[0] !== '*').length
+ throw new TypeError(sub('%s() takes %s positional argument%s but %s %s given',
+ get_name(),
+ from === to ? sub('from %s to %s', from, to) : to,
+ from === to && to === 1 ? '' : 's',
+ positional_count,
+ positional_count === 1 ? 'was' : 'were'))
+ }
+
+ if (missing_positionals.length) {
+ let strs = missing_positionals.map(repr)
+ if (strs.length > 1) strs[strs.length - 1] = 'and ' + strs[strs.length - 1]
+ let str_joined = strs.join(strs.length === 2 ? '' : ', ')
+ throw new TypeError(sub('%s() missing %i required positional argument%s: %s',
+ get_name(), strs.length, strs.length === 1 ? '' : 's', str_joined))
+ }
+
+ return result
+}
+
+let _deprecations = {}
+function deprecate(id, string) {
+ _deprecations[id] = _deprecations[id] || util.deprecate(() => {}, string)
+ _deprecations[id]()
+}
+
+
+// =============================
+// Utility functions and classes
+// =============================
+function _AttributeHolder(cls = Object) {
+ /*
+ * Abstract base class that provides __repr__.
+ *
+ * The __repr__ method returns a string in the format::
+ * ClassName(attr=name, attr=name, ...)
+ * The attributes are determined either by a class-level attribute,
+ * '_kwarg_names', or by inspecting the instance __dict__.
+ */
+
+ return class _AttributeHolder extends cls {
+ [util.inspect.custom]() {
+ let type_name = this.constructor.name
+ let arg_strings = []
+ let star_args = {}
+ for (let arg of this._get_args()) {
+ arg_strings.push(repr(arg))
+ }
+ for (let [ name, value ] of this._get_kwargs()) {
+ if (/^[a-z_][a-z0-9_$]*$/i.test(name)) {
+ arg_strings.push(sub('%s=%r', name, value))
+ } else {
+ star_args[name] = value
+ }
+ }
+ if (Object.keys(star_args).length) {
+ arg_strings.push(sub('**%s', repr(star_args)))
+ }
+ return sub('%s(%s)', type_name, arg_strings.join(', '))
+ }
+
+ toString() {
+ return this[util.inspect.custom]()
+ }
+
+ _get_kwargs() {
+ return Object.entries(this)
+ }
+
+ _get_args() {
+ return []
+ }
+ }
+}
+
+
+function _copy_items(items) {
+ if (items === undefined) {
+ return []
+ }
+ return items.slice(0)
+}
+
+
+// ===============
+// Formatting Help
+// ===============
+const HelpFormatter = _camelcase_alias(_callable(class HelpFormatter {
+ /*
+ * Formatter for generating usage messages and argument help strings.
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ */
+
+ constructor() {
+ let [
+ prog,
+ indent_increment,
+ max_help_position,
+ width
+ ] = _parse_opts(arguments, {
+ prog: no_default,
+ indent_increment: 2,
+ max_help_position: 24,
+ width: undefined
+ })
+
+ // default setting for width
+ if (width === undefined) {
+ width = get_terminal_size().columns
+ width -= 2
+ }
+
+ this._prog = prog
+ this._indent_increment = indent_increment
+ this._max_help_position = Math.min(max_help_position,
+ Math.max(width - 20, indent_increment * 2))
+ this._width = width
+
+ this._current_indent = 0
+ this._level = 0
+ this._action_max_length = 0
+
+ this._root_section = this._Section(this, undefined)
+ this._current_section = this._root_section
+
+ this._whitespace_matcher = /[ \t\n\r\f\v]+/g // equivalent to python /\s+/ with ASCII flag
+ this._long_break_matcher = /\n\n\n+/g
+ }
+
+ // ===============================
+ // Section and indentation methods
+ // ===============================
+ _indent() {
+ this._current_indent += this._indent_increment
+ this._level += 1
+ }
+
+ _dedent() {
+ this._current_indent -= this._indent_increment
+ assert(this._current_indent >= 0, 'Indent decreased below 0.')
+ this._level -= 1
+ }
+
+ _add_item(func, args) {
+ this._current_section.items.push([ func, args ])
+ }
+
+ // ========================
+ // Message building methods
+ // ========================
+ start_section(heading) {
+ this._indent()
+ let section = this._Section(this, this._current_section, heading)
+ this._add_item(section.format_help.bind(section), [])
+ this._current_section = section
+ }
+
+ end_section() {
+ this._current_section = this._current_section.parent
+ this._dedent()
+ }
+
+ add_text(text) {
+ if (text !== SUPPRESS && text !== undefined) {
+ this._add_item(this._format_text.bind(this), [text])
+ }
+ }
+
+ add_usage(usage, actions, groups, prefix = undefined) {
+ if (usage !== SUPPRESS) {
+ let args = [ usage, actions, groups, prefix ]
+ this._add_item(this._format_usage.bind(this), args)
+ }
+ }
+
+ add_argument(action) {
+ if (action.help !== SUPPRESS) {
+
+ // find all invocations
+ let invocations = [this._format_action_invocation(action)]
+ for (let subaction of this._iter_indented_subactions(action)) {
+ invocations.push(this._format_action_invocation(subaction))
+ }
+
+ // update the maximum item length
+ let invocation_length = Math.max(...invocations.map(invocation => invocation.length))
+ let action_length = invocation_length + this._current_indent
+ this._action_max_length = Math.max(this._action_max_length,
+ action_length)
+
+ // add the item to the list
+ this._add_item(this._format_action.bind(this), [action])
+ }
+ }
+
+ add_arguments(actions) {
+ for (let action of actions) {
+ this.add_argument(action)
+ }
+ }
+
+ // =======================
+ // Help-formatting methods
+ // =======================
+ format_help() {
+ let help = this._root_section.format_help()
+ if (help) {
+ help = help.replace(this._long_break_matcher, '\n\n')
+ help = help.replace(/^\n+|\n+$/g, '') + '\n'
+ }
+ return help
+ }
+
+ _join_parts(part_strings) {
+ return part_strings.filter(part => part && part !== SUPPRESS).join('')
+ }
+
+ _format_usage(usage, actions, groups, prefix) {
+ if (prefix === undefined) {
+ prefix = 'usage: '
+ }
+
+ // if usage is specified, use that
+ if (usage !== undefined) {
+ usage = sub(usage, { prog: this._prog })
+
+ // if no optionals or positionals are available, usage is just prog
+ } else if (usage === undefined && !actions.length) {
+ usage = sub('%(prog)s', { prog: this._prog })
+
+ // if optionals and positionals are available, calculate usage
+ } else if (usage === undefined) {
+ let prog = sub('%(prog)s', { prog: this._prog })
+
+ // split optionals from positionals
+ let optionals = []
+ let positionals = []
+ for (let action of actions) {
+ if (action.option_strings.length) {
+ optionals.push(action)
+ } else {
+ positionals.push(action)
+ }
+ }
+
+ // build full usage string
+ let action_usage = this._format_actions_usage([].concat(optionals).concat(positionals), groups)
+ usage = [ prog, action_usage ].map(String).join(' ')
+
+ // wrap the usage parts if it's too long
+ let text_width = this._width - this._current_indent
+ if (prefix.length + usage.length > text_width) {
+
+ // break usage into wrappable parts
+ let part_regexp = /\(.*?\)+(?=\s|$)|\[.*?\]+(?=\s|$)|\S+/g
+ let opt_usage = this._format_actions_usage(optionals, groups)
+ let pos_usage = this._format_actions_usage(positionals, groups)
+ let opt_parts = opt_usage.match(part_regexp) || []
+ let pos_parts = pos_usage.match(part_regexp) || []
+ assert(opt_parts.join(' ') === opt_usage)
+ assert(pos_parts.join(' ') === pos_usage)
+
+ // helper for wrapping lines
+ let get_lines = (parts, indent, prefix = undefined) => {
+ let lines = []
+ let line = []
+ let line_len
+ if (prefix !== undefined) {
+ line_len = prefix.length - 1
+ } else {
+ line_len = indent.length - 1
+ }
+ for (let part of parts) {
+ if (line_len + 1 + part.length > text_width && line) {
+ lines.push(indent + line.join(' '))
+ line = []
+ line_len = indent.length - 1
+ }
+ line.push(part)
+ line_len += part.length + 1
+ }
+ if (line.length) {
+ lines.push(indent + line.join(' '))
+ }
+ if (prefix !== undefined) {
+ lines[0] = lines[0].slice(indent.length)
+ }
+ return lines
+ }
+
+ let lines
+
+ // if prog is short, follow it with optionals or positionals
+ if (prefix.length + prog.length <= 0.75 * text_width) {
+ let indent = ' '.repeat(prefix.length + prog.length + 1)
+ if (opt_parts.length) {
+ lines = get_lines([prog].concat(opt_parts), indent, prefix)
+ lines = lines.concat(get_lines(pos_parts, indent))
+ } else if (pos_parts.length) {
+ lines = get_lines([prog].concat(pos_parts), indent, prefix)
+ } else {
+ lines = [prog]
+ }
+
+ // if prog is long, put it on its own line
+ } else {
+ let indent = ' '.repeat(prefix.length)
+ let parts = [].concat(opt_parts).concat(pos_parts)
+ lines = get_lines(parts, indent)
+ if (lines.length > 1) {
+ lines = []
+ lines = lines.concat(get_lines(opt_parts, indent))
+ lines = lines.concat(get_lines(pos_parts, indent))
+ }
+ lines = [prog].concat(lines)
+ }
+
+ // join lines into usage
+ usage = lines.join('\n')
+ }
+ }
+
+ // prefix with 'usage:'
+ return sub('%s%s\n\n', prefix, usage)
+ }
+
+ _format_actions_usage(actions, groups) {
+ // find group indices and identify actions in groups
+ let group_actions = new Set()
+ let inserts = {}
+ for (let group of groups) {
+ let start = actions.indexOf(group._group_actions[0])
+ if (start === -1) {
+ continue
+ } else {
+ let end = start + group._group_actions.length
+ if (_array_equal(actions.slice(start, end), group._group_actions)) {
+ for (let action of group._group_actions) {
+ group_actions.add(action)
+ }
+ if (!group.required) {
+ if (start in inserts) {
+ inserts[start] += ' ['
+ } else {
+ inserts[start] = '['
+ }
+ if (end in inserts) {
+ inserts[end] += ']'
+ } else {
+ inserts[end] = ']'
+ }
+ } else {
+ if (start in inserts) {
+ inserts[start] += ' ('
+ } else {
+ inserts[start] = '('
+ }
+ if (end in inserts) {
+ inserts[end] += ')'
+ } else {
+ inserts[end] = ')'
+ }
+ }
+ for (let i of range(start + 1, end)) {
+ inserts[i] = '|'
+ }
+ }
+ }
+ }
+
+ // collect all actions format strings
+ let parts = []
+ for (let [ i, action ] of Object.entries(actions)) {
+
+ // suppressed arguments are marked with None
+ // remove | separators for suppressed arguments
+ if (action.help === SUPPRESS) {
+ parts.push(undefined)
+ if (inserts[+i] === '|') {
+ delete inserts[+i]
+ } else if (inserts[+i + 1] === '|') {
+ delete inserts[+i + 1]
+ }
+
+ // produce all arg strings
+ } else if (!action.option_strings.length) {
+ let default_value = this._get_default_metavar_for_positional(action)
+ let part = this._format_args(action, default_value)
+
+ // if it's in a group, strip the outer []
+ if (group_actions.has(action)) {
+ if (part[0] === '[' && part[part.length - 1] === ']') {
+ part = part.slice(1, -1)
+ }
+ }
+
+ // add the action string to the list
+ parts.push(part)
+
+ // produce the first way to invoke the option in brackets
+ } else {
+ let option_string = action.option_strings[0]
+ let part
+
+ // if the Optional doesn't take a value, format is:
+ // -s or --long
+ if (action.nargs === 0) {
+ part = action.format_usage()
+
+ // if the Optional takes a value, format is:
+ // -s ARGS or --long ARGS
+ } else {
+ let default_value = this._get_default_metavar_for_optional(action)
+ let args_string = this._format_args(action, default_value)
+ part = sub('%s %s', option_string, args_string)
+ }
+
+ // make it look optional if it's not required or in a group
+ if (!action.required && !group_actions.has(action)) {
+ part = sub('[%s]', part)
+ }
+
+ // add the action string to the list
+ parts.push(part)
+ }
+ }
+
+ // insert things at the necessary indices
+ for (let i of Object.keys(inserts).map(Number).sort((a, b) => b - a)) {
+ parts.splice(+i, 0, inserts[+i])
+ }
+
+ // join all the action items with spaces
+ let text = parts.filter(Boolean).join(' ')
+
+ // clean up separators for mutually exclusive groups
+ text = text.replace(/([\[(]) /g, '$1')
+ text = text.replace(/ ([\])])/g, '$1')
+ text = text.replace(/[\[(] *[\])]/g, '')
+ text = text.replace(/\(([^|]*)\)/g, '$1', text)
+ text = text.trim()
+
+ // return the text
+ return text
+ }
+
+ _format_text(text) {
+ if (text.includes('%(prog)')) {
+ text = sub(text, { prog: this._prog })
+ }
+ let text_width = Math.max(this._width - this._current_indent, 11)
+ let indent = ' '.repeat(this._current_indent)
+ return this._fill_text(text, text_width, indent) + '\n\n'
+ }
+
+ _format_action(action) {
+ // determine the required width and the entry label
+ let help_position = Math.min(this._action_max_length + 2,
+ this._max_help_position)
+ let help_width = Math.max(this._width - help_position, 11)
+ let action_width = help_position - this._current_indent - 2
+ let action_header = this._format_action_invocation(action)
+ let indent_first
+
+ // no help; start on same line and add a final newline
+ if (!action.help) {
+ let tup = [ this._current_indent, '', action_header ]
+ action_header = sub('%*s%s\n', ...tup)
+
+ // short action name; start on the same line and pad two spaces
+ } else if (action_header.length <= action_width) {
+ let tup = [ this._current_indent, '', action_width, action_header ]
+ action_header = sub('%*s%-*s ', ...tup)
+ indent_first = 0
+
+ // long action name; start on the next line
+ } else {
+ let tup = [ this._current_indent, '', action_header ]
+ action_header = sub('%*s%s\n', ...tup)
+ indent_first = help_position
+ }
+
+ // collect the pieces of the action help
+ let parts = [action_header]
+
+ // if there was help for the action, add lines of help text
+ if (action.help) {
+ let help_text = this._expand_help(action)
+ let help_lines = this._split_lines(help_text, help_width)
+ parts.push(sub('%*s%s\n', indent_first, '', help_lines[0]))
+ for (let line of help_lines.slice(1)) {
+ parts.push(sub('%*s%s\n', help_position, '', line))
+ }
+
+ // or add a newline if the description doesn't end with one
+ } else if (!action_header.endsWith('\n')) {
+ parts.push('\n')
+ }
+
+ // if there are any sub-actions, add their help as well
+ for (let subaction of this._iter_indented_subactions(action)) {
+ parts.push(this._format_action(subaction))
+ }
+
+ // return a single string
+ return this._join_parts(parts)
+ }
+
+ _format_action_invocation(action) {
+ if (!action.option_strings.length) {
+ let default_value = this._get_default_metavar_for_positional(action)
+ let metavar = this._metavar_formatter(action, default_value)(1)[0]
+ return metavar
+
+ } else {
+ let parts = []
+
+ // if the Optional doesn't take a value, format is:
+ // -s, --long
+ if (action.nargs === 0) {
+ parts = parts.concat(action.option_strings)
+
+ // if the Optional takes a value, format is:
+ // -s ARGS, --long ARGS
+ } else {
+ let default_value = this._get_default_metavar_for_optional(action)
+ let args_string = this._format_args(action, default_value)
+ for (let option_string of action.option_strings) {
+ parts.push(sub('%s %s', option_string, args_string))
+ }
+ }
+
+ return parts.join(', ')
+ }
+ }
+
+ _metavar_formatter(action, default_metavar) {
+ let result
+ if (action.metavar !== undefined) {
+ result = action.metavar
+ } else if (action.choices !== undefined) {
+ let choice_strs = _choices_to_array(action.choices).map(String)
+ result = sub('{%s}', choice_strs.join(','))
+ } else {
+ result = default_metavar
+ }
+
+ function format(tuple_size) {
+ if (Array.isArray(result)) {
+ return result
+ } else {
+ return Array(tuple_size).fill(result)
+ }
+ }
+ return format
+ }
+
+ _format_args(action, default_metavar) {
+ let get_metavar = this._metavar_formatter(action, default_metavar)
+ let result
+ if (action.nargs === undefined) {
+ result = sub('%s', ...get_metavar(1))
+ } else if (action.nargs === OPTIONAL) {
+ result = sub('[%s]', ...get_metavar(1))
+ } else if (action.nargs === ZERO_OR_MORE) {
+ let metavar = get_metavar(1)
+ if (metavar.length === 2) {
+ result = sub('[%s [%s ...]]', ...metavar)
+ } else {
+ result = sub('[%s ...]', ...metavar)
+ }
+ } else if (action.nargs === ONE_OR_MORE) {
+ result = sub('%s [%s ...]', ...get_metavar(2))
+ } else if (action.nargs === REMAINDER) {
+ result = '...'
+ } else if (action.nargs === PARSER) {
+ result = sub('%s ...', ...get_metavar(1))
+ } else if (action.nargs === SUPPRESS) {
+ result = ''
+ } else {
+ let formats
+ try {
+ formats = range(action.nargs).map(() => '%s')
+ } catch (err) {
+ throw new TypeError('invalid nargs value')
+ }
+ result = sub(formats.join(' '), ...get_metavar(action.nargs))
+ }
+ return result
+ }
+
+ _expand_help(action) {
+ let params = Object.assign({ prog: this._prog }, action)
+ for (let name of Object.keys(params)) {
+ if (params[name] === SUPPRESS) {
+ delete params[name]
+ }
+ }
+ for (let name of Object.keys(params)) {
+ if (params[name] && params[name].name) {
+ params[name] = params[name].name
+ }
+ }
+ if (params.choices !== undefined) {
+ let choices_str = _choices_to_array(params.choices).map(String).join(', ')
+ params.choices = choices_str
+ }
+ // LEGACY (v1 compatibility): camelcase
+ for (let key of Object.keys(params)) {
+ let old_name = _to_legacy_name(key)
+ if (old_name !== key) {
+ params[old_name] = params[key]
+ }
+ }
+ // end
+ return sub(this._get_help_string(action), params)
+ }
+
+ * _iter_indented_subactions(action) {
+ if (typeof action._get_subactions === 'function') {
+ this._indent()
+ yield* action._get_subactions()
+ this._dedent()
+ }
+ }
+
+ _split_lines(text, width) {
+ text = text.replace(this._whitespace_matcher, ' ').trim()
+ // The textwrap module is used only for formatting help.
+ // Delay its import for speeding up the common usage of argparse.
+ let textwrap = require('./lib/textwrap')
+ return textwrap.wrap(text, { width })
+ }
+
+ _fill_text(text, width, indent) {
+ text = text.replace(this._whitespace_matcher, ' ').trim()
+ let textwrap = require('./lib/textwrap')
+ return textwrap.fill(text, { width,
+ initial_indent: indent,
+ subsequent_indent: indent })
+ }
+
+ _get_help_string(action) {
+ return action.help
+ }
+
+ _get_default_metavar_for_optional(action) {
+ return action.dest.toUpperCase()
+ }
+
+ _get_default_metavar_for_positional(action) {
+ return action.dest
+ }
+}))
+
+HelpFormatter.prototype._Section = _callable(class _Section {
+
+ constructor(formatter, parent, heading = undefined) {
+ this.formatter = formatter
+ this.parent = parent
+ this.heading = heading
+ this.items = []
+ }
+
+ format_help() {
+ // format the indented section
+ if (this.parent !== undefined) {
+ this.formatter._indent()
+ }
+ let item_help = this.formatter._join_parts(this.items.map(([ func, args ]) => func.apply(null, args)))
+ if (this.parent !== undefined) {
+ this.formatter._dedent()
+ }
+
+ // return nothing if the section was empty
+ if (!item_help) {
+ return ''
+ }
+
+ // add the heading if the section was non-empty
+ let heading
+ if (this.heading !== SUPPRESS && this.heading !== undefined) {
+ let current_indent = this.formatter._current_indent
+ heading = sub('%*s%s:\n', current_indent, '', this.heading)
+ } else {
+ heading = ''
+ }
+
+ // join the section-initial newline, the heading and the help
+ return this.formatter._join_parts(['\n', heading, item_help, '\n'])
+ }
+})
+
+
+const RawDescriptionHelpFormatter = _camelcase_alias(_callable(class RawDescriptionHelpFormatter extends HelpFormatter {
+ /*
+ * Help message formatter which retains any formatting in descriptions.
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ */
+
+ _fill_text(text, width, indent) {
+ return splitlines(text, true).map(line => indent + line).join('')
+ }
+}))
+
+
+const RawTextHelpFormatter = _camelcase_alias(_callable(class RawTextHelpFormatter extends RawDescriptionHelpFormatter {
+ /*
+ * Help message formatter which retains formatting of all help text.
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ */
+
+ _split_lines(text/*, width*/) {
+ return splitlines(text)
+ }
+}))
+
+
+const ArgumentDefaultsHelpFormatter = _camelcase_alias(_callable(class ArgumentDefaultsHelpFormatter extends HelpFormatter {
+ /*
+ * Help message formatter which adds default values to argument help.
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ */
+
+ _get_help_string(action) {
+ let help = action.help
+ // LEGACY (v1 compatibility): additional check for defaultValue needed
+ if (!action.help.includes('%(default)') && !action.help.includes('%(defaultValue)')) {
+ if (action.default !== SUPPRESS) {
+ let defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
+ if (action.option_strings.length || defaulting_nargs.includes(action.nargs)) {
+ help += ' (default: %(default)s)'
+ }
+ }
+ }
+ return help
+ }
+}))
+
+
+const MetavarTypeHelpFormatter = _camelcase_alias(_callable(class MetavarTypeHelpFormatter extends HelpFormatter {
+ /*
+ * Help message formatter which uses the argument 'type' as the default
+ * metavar value (instead of the argument 'dest')
+ *
+ * Only the name of this class is considered a public API. All the methods
+ * provided by the class are considered an implementation detail.
+ */
+
+ _get_default_metavar_for_optional(action) {
+ return typeof action.type === 'function' ? action.type.name : action.type
+ }
+
+ _get_default_metavar_for_positional(action) {
+ return typeof action.type === 'function' ? action.type.name : action.type
+ }
+}))
+
+
+// =====================
+// Options and Arguments
+// =====================
+function _get_action_name(argument) {
+ if (argument === undefined) {
+ return undefined
+ } else if (argument.option_strings.length) {
+ return argument.option_strings.join('/')
+ } else if (![ undefined, SUPPRESS ].includes(argument.metavar)) {
+ return argument.metavar
+ } else if (![ undefined, SUPPRESS ].includes(argument.dest)) {
+ return argument.dest
+ } else {
+ return undefined
+ }
+}
+
+
+const ArgumentError = _callable(class ArgumentError extends Error {
+ /*
+ * An error from creating or using an argument (optional or positional).
+ *
+ * The string value of this exception is the message, augmented with
+ * information about the argument that caused it.
+ */
+
+ constructor(argument, message) {
+ super()
+ this.name = 'ArgumentError'
+ this._argument_name = _get_action_name(argument)
+ this._message = message
+ this.message = this.str()
+ }
+
+ str() {
+ let format
+ if (this._argument_name === undefined) {
+ format = '%(message)s'
+ } else {
+ format = 'argument %(argument_name)s: %(message)s'
+ }
+ return sub(format, { message: this._message,
+ argument_name: this._argument_name })
+ }
+})
+
+
+const ArgumentTypeError = _callable(class ArgumentTypeError extends Error {
+ /*
+ * An error from trying to convert a command line string to a type.
+ */
+
+ constructor(message) {
+ super(message)
+ this.name = 'ArgumentTypeError'
+ }
+})
+
+
+// ==============
+// Action classes
+// ==============
+const Action = _camelcase_alias(_callable(class Action extends _AttributeHolder(Function) {
+ /*
+ * Information about how to convert command line strings to Python objects.
+ *
+ * Action objects are used by an ArgumentParser to represent the information
+ * needed to parse a single argument from one or more strings from the
+ * command line. The keyword arguments to the Action constructor are also
+ * all attributes of Action instances.
+ *
+ * Keyword Arguments:
+ *
+ * - option_strings -- A list of command-line option strings which
+ * should be associated with this action.
+ *
+ * - dest -- The name of the attribute to hold the created object(s)
+ *
+ * - nargs -- The number of command-line arguments that should be
+ * consumed. By default, one argument will be consumed and a single
+ * value will be produced. Other values include:
+ * - N (an integer) consumes N arguments (and produces a list)
+ * - '?' consumes zero or one arguments
+ * - '*' consumes zero or more arguments (and produces a list)
+ * - '+' consumes one or more arguments (and produces a list)
+ * Note that the difference between the default and nargs=1 is that
+ * with the default, a single value will be produced, while with
+ * nargs=1, a list containing a single value will be produced.
+ *
+ * - const -- The value to be produced if the option is specified and the
+ * option uses an action that takes no values.
+ *
+ * - default -- The value to be produced if the option is not specified.
+ *
+ * - type -- A callable that accepts a single string argument, and
+ * returns the converted value. The standard Python types str, int,
+ * float, and complex are useful examples of such callables. If None,
+ * str is used.
+ *
+ * - choices -- A container of values that should be allowed. If not None,
+ * after a command-line argument has been converted to the appropriate
+ * type, an exception will be raised if it is not a member of this
+ * collection.
+ *
+ * - required -- True if the action must always be specified at the
+ * command line. This is only meaningful for optional command-line
+ * arguments.
+ *
+ * - help -- The help string describing the argument.
+ *
+ * - metavar -- The name to be used for the option's argument with the
+ * help string. If None, the 'dest' value will be used as the name.
+ */
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ nargs,
+ const_value,
+ default_value,
+ type,
+ choices,
+ required,
+ help,
+ metavar
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ nargs: undefined,
+ const: undefined,
+ default: undefined,
+ type: undefined,
+ choices: undefined,
+ required: false,
+ help: undefined,
+ metavar: undefined
+ })
+
+ // when this class is called as a function, redirect it to .call() method of itself
+ super('return arguments.callee.call.apply(arguments.callee, arguments)')
+
+ this.option_strings = option_strings
+ this.dest = dest
+ this.nargs = nargs
+ this.const = const_value
+ this.default = default_value
+ this.type = type
+ this.choices = choices
+ this.required = required
+ this.help = help
+ this.metavar = metavar
+ }
+
+ _get_kwargs() {
+ let names = [
+ 'option_strings',
+ 'dest',
+ 'nargs',
+ 'const',
+ 'default',
+ 'type',
+ 'choices',
+ 'help',
+ 'metavar'
+ ]
+ return names.map(name => [ name, getattr(this, name) ])
+ }
+
+ format_usage() {
+ return this.option_strings[0]
+ }
+
+ call(/*parser, namespace, values, option_string = undefined*/) {
+ throw new Error('.call() not defined')
+ }
+}))
+
+
+const BooleanOptionalAction = _camelcase_alias(_callable(class BooleanOptionalAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ default_value,
+ type,
+ choices,
+ required,
+ help,
+ metavar
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ default: undefined,
+ type: undefined,
+ choices: undefined,
+ required: false,
+ help: undefined,
+ metavar: undefined
+ })
+
+ let _option_strings = []
+ for (let option_string of option_strings) {
+ _option_strings.push(option_string)
+
+ if (option_string.startsWith('--')) {
+ option_string = '--no-' + option_string.slice(2)
+ _option_strings.push(option_string)
+ }
+ }
+
+ if (help !== undefined && default_value !== undefined) {
+ help += ` (default: ${default_value})`
+ }
+
+ super({
+ option_strings: _option_strings,
+ dest,
+ nargs: 0,
+ default: default_value,
+ type,
+ choices,
+ required,
+ help,
+ metavar
+ })
+ }
+
+ call(parser, namespace, values, option_string = undefined) {
+ if (this.option_strings.includes(option_string)) {
+ setattr(namespace, this.dest, !option_string.startsWith('--no-'))
+ }
+ }
+
+ format_usage() {
+ return this.option_strings.join(' | ')
+ }
+}))
+
+
+const _StoreAction = _callable(class _StoreAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ nargs,
+ const_value,
+ default_value,
+ type,
+ choices,
+ required,
+ help,
+ metavar
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ nargs: undefined,
+ const: undefined,
+ default: undefined,
+ type: undefined,
+ choices: undefined,
+ required: false,
+ help: undefined,
+ metavar: undefined
+ })
+
+ if (nargs === 0) {
+ throw new TypeError('nargs for store actions must be != 0; if you ' +
+ 'have nothing to store, actions such as store ' +
+ 'true or store const may be more appropriate')
+ }
+ if (const_value !== undefined && nargs !== OPTIONAL) {
+ throw new TypeError(sub('nargs must be %r to supply const', OPTIONAL))
+ }
+ super({
+ option_strings,
+ dest,
+ nargs,
+ const: const_value,
+ default: default_value,
+ type,
+ choices,
+ required,
+ help,
+ metavar
+ })
+ }
+
+ call(parser, namespace, values/*, option_string = undefined*/) {
+ setattr(namespace, this.dest, values)
+ }
+})
+
+
+const _StoreConstAction = _callable(class _StoreConstAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ const_value,
+ default_value,
+ required,
+ help
+ //, metavar
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ const: no_default,
+ default: undefined,
+ required: false,
+ help: undefined,
+ metavar: undefined
+ })
+
+ super({
+ option_strings,
+ dest,
+ nargs: 0,
+ const: const_value,
+ default: default_value,
+ required,
+ help
+ })
+ }
+
+ call(parser, namespace/*, values, option_string = undefined*/) {
+ setattr(namespace, this.dest, this.const)
+ }
+})
+
+
+const _StoreTrueAction = _callable(class _StoreTrueAction extends _StoreConstAction {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ default_value,
+ required,
+ help
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ default: false,
+ required: false,
+ help: undefined
+ })
+
+ super({
+ option_strings,
+ dest,
+ const: true,
+ default: default_value,
+ required,
+ help
+ })
+ }
+})
+
+
+const _StoreFalseAction = _callable(class _StoreFalseAction extends _StoreConstAction {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ default_value,
+ required,
+ help
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ default: true,
+ required: false,
+ help: undefined
+ })
+
+ super({
+ option_strings,
+ dest,
+ const: false,
+ default: default_value,
+ required,
+ help
+ })
+ }
+})
+
+
+const _AppendAction = _callable(class _AppendAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ nargs,
+ const_value,
+ default_value,
+ type,
+ choices,
+ required,
+ help,
+ metavar
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ nargs: undefined,
+ const: undefined,
+ default: undefined,
+ type: undefined,
+ choices: undefined,
+ required: false,
+ help: undefined,
+ metavar: undefined
+ })
+
+ if (nargs === 0) {
+ throw new TypeError('nargs for append actions must be != 0; if arg ' +
+ 'strings are not supplying the value to append, ' +
+ 'the append const action may be more appropriate')
+ }
+ if (const_value !== undefined && nargs !== OPTIONAL) {
+ throw new TypeError(sub('nargs must be %r to supply const', OPTIONAL))
+ }
+ super({
+ option_strings,
+ dest,
+ nargs,
+ const: const_value,
+ default: default_value,
+ type,
+ choices,
+ required,
+ help,
+ metavar
+ })
+ }
+
+ call(parser, namespace, values/*, option_string = undefined*/) {
+ let items = getattr(namespace, this.dest, undefined)
+ items = _copy_items(items)
+ items.push(values)
+ setattr(namespace, this.dest, items)
+ }
+})
+
+
+const _AppendConstAction = _callable(class _AppendConstAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ const_value,
+ default_value,
+ required,
+ help,
+ metavar
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ const: no_default,
+ default: undefined,
+ required: false,
+ help: undefined,
+ metavar: undefined
+ })
+
+ super({
+ option_strings,
+ dest,
+ nargs: 0,
+ const: const_value,
+ default: default_value,
+ required,
+ help,
+ metavar
+ })
+ }
+
+ call(parser, namespace/*, values, option_string = undefined*/) {
+ let items = getattr(namespace, this.dest, undefined)
+ items = _copy_items(items)
+ items.push(this.const)
+ setattr(namespace, this.dest, items)
+ }
+})
+
+
+const _CountAction = _callable(class _CountAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ default_value,
+ required,
+ help
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: no_default,
+ default: undefined,
+ required: false,
+ help: undefined
+ })
+
+ super({
+ option_strings,
+ dest,
+ nargs: 0,
+ default: default_value,
+ required,
+ help
+ })
+ }
+
+ call(parser, namespace/*, values, option_string = undefined*/) {
+ let count = getattr(namespace, this.dest, undefined)
+ if (count === undefined) {
+ count = 0
+ }
+ setattr(namespace, this.dest, count + 1)
+ }
+})
+
+
+const _HelpAction = _callable(class _HelpAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ dest,
+ default_value,
+ help
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ dest: SUPPRESS,
+ default: SUPPRESS,
+ help: undefined
+ })
+
+ super({
+ option_strings,
+ dest,
+ default: default_value,
+ nargs: 0,
+ help
+ })
+ }
+
+ call(parser/*, namespace, values, option_string = undefined*/) {
+ parser.print_help()
+ parser.exit()
+ }
+})
+
+
+const _VersionAction = _callable(class _VersionAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ version,
+ dest,
+ default_value,
+ help
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ version: undefined,
+ dest: SUPPRESS,
+ default: SUPPRESS,
+ help: "show program's version number and exit"
+ })
+
+ super({
+ option_strings,
+ dest,
+ default: default_value,
+ nargs: 0,
+ help
+ })
+ this.version = version
+ }
+
+ call(parser/*, namespace, values, option_string = undefined*/) {
+ let version = this.version
+ if (version === undefined) {
+ version = parser.version
+ }
+ let formatter = parser._get_formatter()
+ formatter.add_text(version)
+ parser._print_message(formatter.format_help(), process.stdout)
+ parser.exit()
+ }
+})
+
+
+const _SubParsersAction = _camelcase_alias(_callable(class _SubParsersAction extends Action {
+
+ constructor() {
+ let [
+ option_strings,
+ prog,
+ parser_class,
+ dest,
+ required,
+ help,
+ metavar
+ ] = _parse_opts(arguments, {
+ option_strings: no_default,
+ prog: no_default,
+ parser_class: no_default,
+ dest: SUPPRESS,
+ required: false,
+ help: undefined,
+ metavar: undefined
+ })
+
+ let name_parser_map = {}
+
+ super({
+ option_strings,
+ dest,
+ nargs: PARSER,
+ choices: name_parser_map,
+ required,
+ help,
+ metavar
+ })
+
+ this._prog_prefix = prog
+ this._parser_class = parser_class
+ this._name_parser_map = name_parser_map
+ this._choices_actions = []
+ }
+
+ add_parser() {
+ let [
+ name,
+ kwargs
+ ] = _parse_opts(arguments, {
+ name: no_default,
+ '**kwargs': no_default
+ })
+
+ // set prog from the existing prefix
+ if (kwargs.prog === undefined) {
+ kwargs.prog = sub('%s %s', this._prog_prefix, name)
+ }
+
+ let aliases = getattr(kwargs, 'aliases', [])
+ delete kwargs.aliases
+
+ // create a pseudo-action to hold the choice help
+ if ('help' in kwargs) {
+ let help = kwargs.help
+ delete kwargs.help
+ let choice_action = this._ChoicesPseudoAction(name, aliases, help)
+ this._choices_actions.push(choice_action)
+ }
+
+ // create the parser and add it to the map
+ let parser = new this._parser_class(kwargs)
+ this._name_parser_map[name] = parser
+
+ // make parser available under aliases also
+ for (let alias of aliases) {
+ this._name_parser_map[alias] = parser
+ }
+
+ return parser
+ }
+
+ _get_subactions() {
+ return this._choices_actions
+ }
+
+ call(parser, namespace, values/*, option_string = undefined*/) {
+ let parser_name = values[0]
+ let arg_strings = values.slice(1)
+
+ // set the parser name if requested
+ if (this.dest !== SUPPRESS) {
+ setattr(namespace, this.dest, parser_name)
+ }
+
+ // select the parser
+ if (hasattr(this._name_parser_map, parser_name)) {
+ parser = this._name_parser_map[parser_name]
+ } else {
+ let args = {parser_name,
+ choices: this._name_parser_map.join(', ')}
+ let msg = sub('unknown parser %(parser_name)r (choices: %(choices)s)', args)
+ throw new ArgumentError(this, msg)
+ }
+
+ // parse all the remaining options into the namespace
+ // store any unrecognized options on the object, so that the top
+ // level parser can decide what to do with them
+
+ // In case this subparser defines new defaults, we parse them
+ // in a new namespace object and then update the original
+ // namespace for the relevant parts.
+ let subnamespace
+ [ subnamespace, arg_strings ] = parser.parse_known_args(arg_strings, undefined)
+ for (let [ key, value ] of Object.entries(subnamespace)) {
+ setattr(namespace, key, value)
+ }
+
+ if (arg_strings.length) {
+ setdefault(namespace, _UNRECOGNIZED_ARGS_ATTR, [])
+ getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).push(...arg_strings)
+ }
+ }
+}))
+
+
+_SubParsersAction.prototype._ChoicesPseudoAction = _callable(class _ChoicesPseudoAction extends Action {
+ constructor(name, aliases, help) {
+ let metavar = name, dest = name
+ if (aliases.length) {
+ metavar += sub(' (%s)', aliases.join(', '))
+ }
+ super({ option_strings: [], dest, help, metavar })
+ }
+})
+
+
+const _ExtendAction = _callable(class _ExtendAction extends _AppendAction {
+ call(parser, namespace, values/*, option_string = undefined*/) {
+ let items = getattr(namespace, this.dest, undefined)
+ items = _copy_items(items)
+ items = items.concat(values)
+ setattr(namespace, this.dest, items)
+ }
+})
+
+
+// ==============
+// Type classes
+// ==============
+const FileType = _callable(class FileType extends Function {
+ /*
+ * Factory for creating file object types
+ *
+ * Instances of FileType are typically passed as type= arguments to the
+ * ArgumentParser add_argument() method.
+ *
+ * Keyword Arguments:
+ * - mode -- A string indicating how the file is to be opened. Accepts the
+ * same values as the builtin open() function.
+ * - bufsize -- The file's desired buffer size. Accepts the same values as
+ * the builtin open() function.
+ * - encoding -- The file's encoding. Accepts the same values as the
+ * builtin open() function.
+ * - errors -- A string indicating how encoding and decoding errors are to
+ * be handled. Accepts the same value as the builtin open() function.
+ */
+
+ constructor() {
+ let [
+ flags,
+ encoding,
+ mode,
+ autoClose,
+ emitClose,
+ start,
+ end,
+ highWaterMark,
+ fs
+ ] = _parse_opts(arguments, {
+ flags: 'r',
+ encoding: undefined,
+ mode: undefined, // 0o666
+ autoClose: undefined, // true
+ emitClose: undefined, // false
+ start: undefined, // 0
+ end: undefined, // Infinity
+ highWaterMark: undefined, // 64 * 1024
+ fs: undefined
+ })
+
+ // when this class is called as a function, redirect it to .call() method of itself
+ super('return arguments.callee.call.apply(arguments.callee, arguments)')
+
+ Object.defineProperty(this, 'name', {
+ get() {
+ return sub('FileType(%r)', flags)
+ }
+ })
+ this._flags = flags
+ this._options = {}
+ if (encoding !== undefined) this._options.encoding = encoding
+ if (mode !== undefined) this._options.mode = mode
+ if (autoClose !== undefined) this._options.autoClose = autoClose
+ if (emitClose !== undefined) this._options.emitClose = emitClose
+ if (start !== undefined) this._options.start = start
+ if (end !== undefined) this._options.end = end
+ if (highWaterMark !== undefined) this._options.highWaterMark = highWaterMark
+ if (fs !== undefined) this._options.fs = fs
+ }
+
+ call(string) {
+ // the special argument "-" means sys.std{in,out}
+ if (string === '-') {
+ if (this._flags.includes('r')) {
+ return process.stdin
+ } else if (this._flags.includes('w')) {
+ return process.stdout
+ } else {
+ let msg = sub('argument "-" with mode %r', this._flags)
+ throw new TypeError(msg)
+ }
+ }
+
+ // all other arguments are used as file names
+ let fd
+ try {
+ fd = fs.openSync(string, this._flags, this._options.mode)
+ } catch (e) {
+ let args = { filename: string, error: e.message }
+ let message = "can't open '%(filename)s': %(error)s"
+ throw new ArgumentTypeError(sub(message, args))
+ }
+
+ let options = Object.assign({ fd, flags: this._flags }, this._options)
+ if (this._flags.includes('r')) {
+ return fs.createReadStream(undefined, options)
+ } else if (this._flags.includes('w')) {
+ return fs.createWriteStream(undefined, options)
+ } else {
+ let msg = sub('argument "%s" with mode %r', string, this._flags)
+ throw new TypeError(msg)
+ }
+ }
+
+ [util.inspect.custom]() {
+ let args = [ this._flags ]
+ let kwargs = Object.entries(this._options).map(([ k, v ]) => {
+ if (k === 'mode') v = { value: v, [util.inspect.custom]() { return '0o' + this.value.toString(8) } }
+ return [ k, v ]
+ })
+ let args_str = []
+ .concat(args.filter(arg => arg !== -1).map(repr))
+ .concat(kwargs.filter(([/*kw*/, arg]) => arg !== undefined)
+ .map(([kw, arg]) => sub('%s=%r', kw, arg)))
+ .join(', ')
+ return sub('%s(%s)', this.constructor.name, args_str)
+ }
+
+ toString() {
+ return this[util.inspect.custom]()
+ }
+})
+
+// ===========================
+// Optional and Positional Parsing
+// ===========================
+const Namespace = _callable(class Namespace extends _AttributeHolder() {
+ /*
+ * Simple object for storing attributes.
+ *
+ * Implements equality by attribute names and values, and provides a simple
+ * string representation.
+ */
+
+ constructor(options = {}) {
+ super()
+ Object.assign(this, options)
+ }
+})
+
+// unset string tag to mimic plain object
+Namespace.prototype[Symbol.toStringTag] = undefined
+
+
+const _ActionsContainer = _camelcase_alias(_callable(class _ActionsContainer {
+
+ constructor() {
+ let [
+ description,
+ prefix_chars,
+ argument_default,
+ conflict_handler
+ ] = _parse_opts(arguments, {
+ description: no_default,
+ prefix_chars: no_default,
+ argument_default: no_default,
+ conflict_handler: no_default
+ })
+
+ this.description = description
+ this.argument_default = argument_default
+ this.prefix_chars = prefix_chars
+ this.conflict_handler = conflict_handler
+
+ // set up registries
+ this._registries = {}
+
+ // register actions
+ this.register('action', undefined, _StoreAction)
+ this.register('action', 'store', _StoreAction)
+ this.register('action', 'store_const', _StoreConstAction)
+ this.register('action', 'store_true', _StoreTrueAction)
+ this.register('action', 'store_false', _StoreFalseAction)
+ this.register('action', 'append', _AppendAction)
+ this.register('action', 'append_const', _AppendConstAction)
+ this.register('action', 'count', _CountAction)
+ this.register('action', 'help', _HelpAction)
+ this.register('action', 'version', _VersionAction)
+ this.register('action', 'parsers', _SubParsersAction)
+ this.register('action', 'extend', _ExtendAction)
+ // LEGACY (v1 compatibility): camelcase variants
+ ;[ 'storeConst', 'storeTrue', 'storeFalse', 'appendConst' ].forEach(old_name => {
+ let new_name = _to_new_name(old_name)
+ this.register('action', old_name, util.deprecate(this._registry_get('action', new_name),
+ sub('{action: "%s"} is renamed to {action: "%s"}', old_name, new_name)))
+ })
+ // end
+
+ // raise an exception if the conflict handler is invalid
+ this._get_handler()
+
+ // action storage
+ this._actions = []
+ this._option_string_actions = {}
+
+ // groups
+ this._action_groups = []
+ this._mutually_exclusive_groups = []
+
+ // defaults storage
+ this._defaults = {}
+
+ // determines whether an "option" looks like a negative number
+ this._negative_number_matcher = /^-\d+$|^-\d*\.\d+$/
+
+ // whether or not there are any optionals that look like negative
+ // numbers -- uses a list so it can be shared and edited
+ this._has_negative_number_optionals = []
+ }
+
+ // ====================
+ // Registration methods
+ // ====================
+ register(registry_name, value, object) {
+ let registry = setdefault(this._registries, registry_name, {})
+ registry[value] = object
+ }
+
+ _registry_get(registry_name, value, default_value = undefined) {
+ return getattr(this._registries[registry_name], value, default_value)
+ }
+
+ // ==================================
+ // Namespace default accessor methods
+ // ==================================
+ set_defaults(kwargs) {
+ Object.assign(this._defaults, kwargs)
+
+ // if these defaults match any existing arguments, replace
+ // the previous default on the object with the new one
+ for (let action of this._actions) {
+ if (action.dest in kwargs) {
+ action.default = kwargs[action.dest]
+ }
+ }
+ }
+
+ get_default(dest) {
+ for (let action of this._actions) {
+ if (action.dest === dest && action.default !== undefined) {
+ return action.default
+ }
+ }
+ return this._defaults[dest]
+ }
+
+
+ // =======================
+ // Adding argument actions
+ // =======================
+ add_argument() {
+ /*
+ * add_argument(dest, ..., name=value, ...)
+ * add_argument(option_string, option_string, ..., name=value, ...)
+ */
+ let [
+ args,
+ kwargs
+ ] = _parse_opts(arguments, {
+ '*args': no_default,
+ '**kwargs': no_default
+ })
+ // LEGACY (v1 compatibility), old-style add_argument([ args ], { options })
+ if (args.length === 1 && Array.isArray(args[0])) {
+ args = args[0]
+ deprecate('argument-array',
+ sub('use add_argument(%(args)s, {...}) instead of add_argument([ %(args)s ], { ... })', {
+ args: args.map(repr).join(', ')
+ }))
+ }
+ // end
+
+ // if no positional args are supplied or only one is supplied and
+ // it doesn't look like an option string, parse a positional
+ // argument
+ let chars = this.prefix_chars
+ if (!args.length || args.length === 1 && !chars.includes(args[0][0])) {
+ if (args.length && 'dest' in kwargs) {
+ throw new TypeError('dest supplied twice for positional argument')
+ }
+ kwargs = this._get_positional_kwargs(...args, kwargs)
+
+ // otherwise, we're adding an optional argument
+ } else {
+ kwargs = this._get_optional_kwargs(...args, kwargs)
+ }
+
+ // if no default was supplied, use the parser-level default
+ if (!('default' in kwargs)) {
+ let dest = kwargs.dest
+ if (dest in this._defaults) {
+ kwargs.default = this._defaults[dest]
+ } else if (this.argument_default !== undefined) {
+ kwargs.default = this.argument_default
+ }
+ }
+
+ // create the action object, and add it to the parser
+ let action_class = this._pop_action_class(kwargs)
+ if (typeof action_class !== 'function') {
+ throw new TypeError(sub('unknown action "%s"', action_class))
+ }
+ // eslint-disable-next-line new-cap
+ let action = new action_class(kwargs)
+
+ // raise an error if the action type is not callable
+ let type_func = this._registry_get('type', action.type, action.type)
+ if (typeof type_func !== 'function') {
+ throw new TypeError(sub('%r is not callable', type_func))
+ }
+
+ if (type_func === FileType) {
+ throw new TypeError(sub('%r is a FileType class object, instance of it' +
+ ' must be passed', type_func))
+ }
+
+ // raise an error if the metavar does not match the type
+ if ('_get_formatter' in this) {
+ try {
+ this._get_formatter()._format_args(action, undefined)
+ } catch (err) {
+ // check for 'invalid nargs value' is an artifact of TypeError and ValueError in js being the same
+ if (err instanceof TypeError && err.message !== 'invalid nargs value') {
+ throw new TypeError('length of metavar tuple does not match nargs')
+ } else {
+ throw err
+ }
+ }
+ }
+
+ return this._add_action(action)
+ }
+
+ add_argument_group() {
+ let group = _ArgumentGroup(this, ...arguments)
+ this._action_groups.push(group)
+ return group
+ }
+
+ add_mutually_exclusive_group() {
+ // eslint-disable-next-line no-use-before-define
+ let group = _MutuallyExclusiveGroup(this, ...arguments)
+ this._mutually_exclusive_groups.push(group)
+ return group
+ }
+
+ _add_action(action) {
+ // resolve any conflicts
+ this._check_conflict(action)
+
+ // add to actions list
+ this._actions.push(action)
+ action.container = this
+
+ // index the action by any option strings it has
+ for (let option_string of action.option_strings) {
+ this._option_string_actions[option_string] = action
+ }
+
+ // set the flag if any option strings look like negative numbers
+ for (let option_string of action.option_strings) {
+ if (this._negative_number_matcher.test(option_string)) {
+ if (!this._has_negative_number_optionals.length) {
+ this._has_negative_number_optionals.push(true)
+ }
+ }
+ }
+
+ // return the created action
+ return action
+ }
+
+ _remove_action(action) {
+ _array_remove(this._actions, action)
+ }
+
+ _add_container_actions(container) {
+ // collect groups by titles
+ let title_group_map = {}
+ for (let group of this._action_groups) {
+ if (group.title in title_group_map) {
+ let msg = 'cannot merge actions - two groups are named %r'
+ throw new TypeError(sub(msg, group.title))
+ }
+ title_group_map[group.title] = group
+ }
+
+ // map each action to its group
+ let group_map = new Map()
+ for (let group of container._action_groups) {
+
+ // if a group with the title exists, use that, otherwise
+ // create a new group matching the container's group
+ if (!(group.title in title_group_map)) {
+ title_group_map[group.title] = this.add_argument_group({
+ title: group.title,
+ description: group.description,
+ conflict_handler: group.conflict_handler
+ })
+ }
+
+ // map the actions to their new group
+ for (let action of group._group_actions) {
+ group_map.set(action, title_group_map[group.title])
+ }
+ }
+
+ // add container's mutually exclusive groups
+ // NOTE: if add_mutually_exclusive_group ever gains title= and
+ // description= then this code will need to be expanded as above
+ for (let group of container._mutually_exclusive_groups) {
+ let mutex_group = this.add_mutually_exclusive_group({
+ required: group.required
+ })
+
+ // map the actions to their new mutex group
+ for (let action of group._group_actions) {
+ group_map.set(action, mutex_group)
+ }
+ }
+
+ // add all actions to this container or their group
+ for (let action of container._actions) {
+ group_map.get(action)._add_action(action)
+ }
+ }
+
+ _get_positional_kwargs() {
+ let [
+ dest,
+ kwargs
+ ] = _parse_opts(arguments, {
+ dest: no_default,
+ '**kwargs': no_default
+ })
+
+ // make sure required is not specified
+ if ('required' in kwargs) {
+ let msg = "'required' is an invalid argument for positionals"
+ throw new TypeError(msg)
+ }
+
+ // mark positional arguments as required if at least one is
+ // always required
+ if (![OPTIONAL, ZERO_OR_MORE].includes(kwargs.nargs)) {
+ kwargs.required = true
+ }
+ if (kwargs.nargs === ZERO_OR_MORE && !('default' in kwargs)) {
+ kwargs.required = true
+ }
+
+ // return the keyword arguments with no option strings
+ return Object.assign(kwargs, { dest, option_strings: [] })
+ }
+
+ _get_optional_kwargs() {
+ let [
+ args,
+ kwargs
+ ] = _parse_opts(arguments, {
+ '*args': no_default,
+ '**kwargs': no_default
+ })
+
+ // determine short and long option strings
+ let option_strings = []
+ let long_option_strings = []
+ let option_string
+ for (option_string of args) {
+ // error on strings that don't start with an appropriate prefix
+ if (!this.prefix_chars.includes(option_string[0])) {
+ let args = {option: option_string,
+ prefix_chars: this.prefix_chars}
+ let msg = 'invalid option string %(option)r: ' +
+ 'must start with a character %(prefix_chars)r'
+ throw new TypeError(sub(msg, args))
+ }
+
+ // strings starting with two prefix characters are long options
+ option_strings.push(option_string)
+ if (option_string.length > 1 && this.prefix_chars.includes(option_string[1])) {
+ long_option_strings.push(option_string)
+ }
+ }
+
+ // infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
+ let dest = kwargs.dest
+ delete kwargs.dest
+ if (dest === undefined) {
+ let dest_option_string
+ if (long_option_strings.length) {
+ dest_option_string = long_option_strings[0]
+ } else {
+ dest_option_string = option_strings[0]
+ }
+ dest = _string_lstrip(dest_option_string, this.prefix_chars)
+ if (!dest) {
+ let msg = 'dest= is required for options like %r'
+ throw new TypeError(sub(msg, option_string))
+ }
+ dest = dest.replace(/-/g, '_')
+ }
+
+ // return the updated keyword arguments
+ return Object.assign(kwargs, { dest, option_strings })
+ }
+
+ _pop_action_class(kwargs, default_value = undefined) {
+ let action = getattr(kwargs, 'action', default_value)
+ delete kwargs.action
+ return this._registry_get('action', action, action)
+ }
+
+ _get_handler() {
+ // determine function from conflict handler string
+ let handler_func_name = sub('_handle_conflict_%s', this.conflict_handler)
+ if (typeof this[handler_func_name] === 'function') {
+ return this[handler_func_name]
+ } else {
+ let msg = 'invalid conflict_resolution value: %r'
+ throw new TypeError(sub(msg, this.conflict_handler))
+ }
+ }
+
+ _check_conflict(action) {
+
+ // find all options that conflict with this option
+ let confl_optionals = []
+ for (let option_string of action.option_strings) {
+ if (hasattr(this._option_string_actions, option_string)) {
+ let confl_optional = this._option_string_actions[option_string]
+ confl_optionals.push([ option_string, confl_optional ])
+ }
+ }
+
+ // resolve any conflicts
+ if (confl_optionals.length) {
+ let conflict_handler = this._get_handler()
+ conflict_handler.call(this, action, confl_optionals)
+ }
+ }
+
+ _handle_conflict_error(action, conflicting_actions) {
+ let message = conflicting_actions.length === 1 ?
+ 'conflicting option string: %s' :
+ 'conflicting option strings: %s'
+ let conflict_string = conflicting_actions.map(([ option_string/*, action*/ ]) => option_string).join(', ')
+ throw new ArgumentError(action, sub(message, conflict_string))
+ }
+
+ _handle_conflict_resolve(action, conflicting_actions) {
+
+ // remove all conflicting options
+ for (let [ option_string, action ] of conflicting_actions) {
+
+ // remove the conflicting option
+ _array_remove(action.option_strings, option_string)
+ delete this._option_string_actions[option_string]
+
+ // if the option now has no option string, remove it from the
+ // container holding it
+ if (!action.option_strings.length) {
+ action.container._remove_action(action)
+ }
+ }
+ }
+}))
+
+
+const _ArgumentGroup = _callable(class _ArgumentGroup extends _ActionsContainer {
+
+ constructor() {
+ let [
+ container,
+ title,
+ description,
+ kwargs
+ ] = _parse_opts(arguments, {
+ container: no_default,
+ title: undefined,
+ description: undefined,
+ '**kwargs': no_default
+ })
+
+ // add any missing keyword arguments by checking the container
+ setdefault(kwargs, 'conflict_handler', container.conflict_handler)
+ setdefault(kwargs, 'prefix_chars', container.prefix_chars)
+ setdefault(kwargs, 'argument_default', container.argument_default)
+ super(Object.assign({ description }, kwargs))
+
+ // group attributes
+ this.title = title
+ this._group_actions = []
+
+ // share most attributes with the container
+ this._registries = container._registries
+ this._actions = container._actions
+ this._option_string_actions = container._option_string_actions
+ this._defaults = container._defaults
+ this._has_negative_number_optionals =
+ container._has_negative_number_optionals
+ this._mutually_exclusive_groups = container._mutually_exclusive_groups
+ }
+
+ _add_action(action) {
+ action = super._add_action(action)
+ this._group_actions.push(action)
+ return action
+ }
+
+ _remove_action(action) {
+ super._remove_action(action)
+ _array_remove(this._group_actions, action)
+ }
+})
+
+
+const _MutuallyExclusiveGroup = _callable(class _MutuallyExclusiveGroup extends _ArgumentGroup {
+
+ constructor() {
+ let [
+ container,
+ required
+ ] = _parse_opts(arguments, {
+ container: no_default,
+ required: false
+ })
+
+ super(container)
+ this.required = required
+ this._container = container
+ }
+
+ _add_action(action) {
+ if (action.required) {
+ let msg = 'mutually exclusive arguments must be optional'
+ throw new TypeError(msg)
+ }
+ action = this._container._add_action(action)
+ this._group_actions.push(action)
+ return action
+ }
+
+ _remove_action(action) {
+ this._container._remove_action(action)
+ _array_remove(this._group_actions, action)
+ }
+})
+
+
+const ArgumentParser = _camelcase_alias(_callable(class ArgumentParser extends _AttributeHolder(_ActionsContainer) {
+ /*
+ * Object for parsing command line strings into Python objects.
+ *
+ * Keyword Arguments:
+ * - prog -- The name of the program (default: sys.argv[0])
+ * - usage -- A usage message (default: auto-generated from arguments)
+ * - description -- A description of what the program does
+ * - epilog -- Text following the argument descriptions
+ * - parents -- Parsers whose arguments should be copied into this one
+ * - formatter_class -- HelpFormatter class for printing help messages
+ * - prefix_chars -- Characters that prefix optional arguments
+ * - fromfile_prefix_chars -- Characters that prefix files containing
+ * additional arguments
+ * - argument_default -- The default value for all arguments
+ * - conflict_handler -- String indicating how to handle conflicts
+ * - add_help -- Add a -h/-help option
+ * - allow_abbrev -- Allow long options to be abbreviated unambiguously
+ * - exit_on_error -- Determines whether or not ArgumentParser exits with
+ * error info when an error occurs
+ */
+
+ constructor() {
+ let [
+ prog,
+ usage,
+ description,
+ epilog,
+ parents,
+ formatter_class,
+ prefix_chars,
+ fromfile_prefix_chars,
+ argument_default,
+ conflict_handler,
+ add_help,
+ allow_abbrev,
+ exit_on_error,
+ debug, // LEGACY (v1 compatibility), debug mode
+ version // LEGACY (v1 compatibility), version
+ ] = _parse_opts(arguments, {
+ prog: undefined,
+ usage: undefined,
+ description: undefined,
+ epilog: undefined,
+ parents: [],
+ formatter_class: HelpFormatter,
+ prefix_chars: '-',
+ fromfile_prefix_chars: undefined,
+ argument_default: undefined,
+ conflict_handler: 'error',
+ add_help: true,
+ allow_abbrev: true,
+ exit_on_error: true,
+ debug: undefined, // LEGACY (v1 compatibility), debug mode
+ version: undefined // LEGACY (v1 compatibility), version
+ })
+
+ // LEGACY (v1 compatibility)
+ if (debug !== undefined) {
+ deprecate('debug',
+ 'The "debug" argument to ArgumentParser is deprecated. Please ' +
+ 'override ArgumentParser.exit function instead.'
+ )
+ }
+
+ if (version !== undefined) {
+ deprecate('version',
+ 'The "version" argument to ArgumentParser is deprecated. Please use ' +
+ "add_argument(..., { action: 'version', version: 'N', ... }) instead."
+ )
+ }
+ // end
+
+ super({
+ description,
+ prefix_chars,
+ argument_default,
+ conflict_handler
+ })
+
+ // default setting for prog
+ if (prog === undefined) {
+ prog = path.basename(get_argv()[0] || '')
+ }
+
+ this.prog = prog
+ this.usage = usage
+ this.epilog = epilog
+ this.formatter_class = formatter_class
+ this.fromfile_prefix_chars = fromfile_prefix_chars
+ this.add_help = add_help
+ this.allow_abbrev = allow_abbrev
+ this.exit_on_error = exit_on_error
+ // LEGACY (v1 compatibility), debug mode
+ this.debug = debug
+ // end
+
+ this._positionals = this.add_argument_group('positional arguments')
+ this._optionals = this.add_argument_group('optional arguments')
+ this._subparsers = undefined
+
+ // register types
+ function identity(string) {
+ return string
+ }
+ this.register('type', undefined, identity)
+ this.register('type', null, identity)
+ this.register('type', 'auto', identity)
+ this.register('type', 'int', function (x) {
+ let result = Number(x)
+ if (!Number.isInteger(result)) {
+ throw new TypeError(sub('could not convert string to int: %r', x))
+ }
+ return result
+ })
+ this.register('type', 'float', function (x) {
+ let result = Number(x)
+ if (isNaN(result)) {
+ throw new TypeError(sub('could not convert string to float: %r', x))
+ }
+ return result
+ })
+ this.register('type', 'str', String)
+ // LEGACY (v1 compatibility): custom types
+ this.register('type', 'string',
+ util.deprecate(String, 'use {type:"str"} or {type:String} instead of {type:"string"}'))
+ // end
+
+ // add help argument if necessary
+ // (using explicit default to override global argument_default)
+ let default_prefix = prefix_chars.includes('-') ? '-' : prefix_chars[0]
+ if (this.add_help) {
+ this.add_argument(
+ default_prefix + 'h',
+ default_prefix.repeat(2) + 'help',
+ {
+ action: 'help',
+ default: SUPPRESS,
+ help: 'show this help message and exit'
+ }
+ )
+ }
+ // LEGACY (v1 compatibility), version
+ if (version) {
+ this.add_argument(
+ default_prefix + 'v',
+ default_prefix.repeat(2) + 'version',
+ {
+ action: 'version',
+ default: SUPPRESS,
+ version: this.version,
+ help: "show program's version number and exit"
+ }
+ )
+ }
+ // end
+
+ // add parent arguments and defaults
+ for (let parent of parents) {
+ this._add_container_actions(parent)
+ Object.assign(this._defaults, parent._defaults)
+ }
+ }
+
+ // =======================
+ // Pretty __repr__ methods
+ // =======================
+ _get_kwargs() {
+ let names = [
+ 'prog',
+ 'usage',
+ 'description',
+ 'formatter_class',
+ 'conflict_handler',
+ 'add_help'
+ ]
+ return names.map(name => [ name, getattr(this, name) ])
+ }
+
+ // ==================================
+ // Optional/Positional adding methods
+ // ==================================
+ add_subparsers() {
+ let [
+ kwargs
+ ] = _parse_opts(arguments, {
+ '**kwargs': no_default
+ })
+
+ if (this._subparsers !== undefined) {
+ this.error('cannot have multiple subparser arguments')
+ }
+
+ // add the parser class to the arguments if it's not present
+ setdefault(kwargs, 'parser_class', this.constructor)
+
+ if ('title' in kwargs || 'description' in kwargs) {
+ let title = getattr(kwargs, 'title', 'subcommands')
+ let description = getattr(kwargs, 'description', undefined)
+ delete kwargs.title
+ delete kwargs.description
+ this._subparsers = this.add_argument_group(title, description)
+ } else {
+ this._subparsers = this._positionals
+ }
+
+ // prog defaults to the usage message of this parser, skipping
+ // optional arguments and with no "usage:" prefix
+ if (kwargs.prog === undefined) {
+ let formatter = this._get_formatter()
+ let positionals = this._get_positional_actions()
+ let groups = this._mutually_exclusive_groups
+ formatter.add_usage(this.usage, positionals, groups, '')
+ kwargs.prog = formatter.format_help().trim()
+ }
+
+ // create the parsers action and add it to the positionals list
+ let parsers_class = this._pop_action_class(kwargs, 'parsers')
+ // eslint-disable-next-line new-cap
+ let action = new parsers_class(Object.assign({ option_strings: [] }, kwargs))
+ this._subparsers._add_action(action)
+
+ // return the created parsers action
+ return action
+ }
+
+ _add_action(action) {
+ if (action.option_strings.length) {
+ this._optionals._add_action(action)
+ } else {
+ this._positionals._add_action(action)
+ }
+ return action
+ }
+
+ _get_optional_actions() {
+ return this._actions.filter(action => action.option_strings.length)
+ }
+
+ _get_positional_actions() {
+ return this._actions.filter(action => !action.option_strings.length)
+ }
+
+ // =====================================
+ // Command line argument parsing methods
+ // =====================================
+ parse_args(args = undefined, namespace = undefined) {
+ let argv
+ [ args, argv ] = this.parse_known_args(args, namespace)
+ if (argv && argv.length > 0) {
+ let msg = 'unrecognized arguments: %s'
+ this.error(sub(msg, argv.join(' ')))
+ }
+ return args
+ }
+
+ parse_known_args(args = undefined, namespace = undefined) {
+ if (args === undefined) {
+ args = get_argv().slice(1)
+ }
+
+ // default Namespace built from parser defaults
+ if (namespace === undefined) {
+ namespace = new Namespace()
+ }
+
+ // add any action defaults that aren't present
+ for (let action of this._actions) {
+ if (action.dest !== SUPPRESS) {
+ if (!hasattr(namespace, action.dest)) {
+ if (action.default !== SUPPRESS) {
+ setattr(namespace, action.dest, action.default)
+ }
+ }
+ }
+ }
+
+ // add any parser defaults that aren't present
+ for (let dest of Object.keys(this._defaults)) {
+ if (!hasattr(namespace, dest)) {
+ setattr(namespace, dest, this._defaults[dest])
+ }
+ }
+
+ // parse the arguments and exit if there are any errors
+ if (this.exit_on_error) {
+ try {
+ [ namespace, args ] = this._parse_known_args(args, namespace)
+ } catch (err) {
+ if (err instanceof ArgumentError) {
+ this.error(err.message)
+ } else {
+ throw err
+ }
+ }
+ } else {
+ [ namespace, args ] = this._parse_known_args(args, namespace)
+ }
+
+ if (hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR)) {
+ args = args.concat(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
+ delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
+ }
+
+ return [ namespace, args ]
+ }
+
+ _parse_known_args(arg_strings, namespace) {
+ // replace arg strings that are file references
+ if (this.fromfile_prefix_chars !== undefined) {
+ arg_strings = this._read_args_from_files(arg_strings)
+ }
+
+ // map all mutually exclusive arguments to the other arguments
+ // they can't occur with
+ let action_conflicts = new Map()
+ for (let mutex_group of this._mutually_exclusive_groups) {
+ let group_actions = mutex_group._group_actions
+ for (let [ i, mutex_action ] of Object.entries(mutex_group._group_actions)) {
+ let conflicts = action_conflicts.get(mutex_action) || []
+ conflicts = conflicts.concat(group_actions.slice(0, +i))
+ conflicts = conflicts.concat(group_actions.slice(+i + 1))
+ action_conflicts.set(mutex_action, conflicts)
+ }
+ }
+
+ // find all option indices, and determine the arg_string_pattern
+ // which has an 'O' if there is an option at an index,
+ // an 'A' if there is an argument, or a '-' if there is a '--'
+ let option_string_indices = {}
+ let arg_string_pattern_parts = []
+ let arg_strings_iter = Object.entries(arg_strings)[Symbol.iterator]()
+ for (let [ i, arg_string ] of arg_strings_iter) {
+
+ // all args after -- are non-options
+ if (arg_string === '--') {
+ arg_string_pattern_parts.push('-')
+ for ([ i, arg_string ] of arg_strings_iter) {
+ arg_string_pattern_parts.push('A')
+ }
+
+ // otherwise, add the arg to the arg strings
+ // and note the index if it was an option
+ } else {
+ let option_tuple = this._parse_optional(arg_string)
+ let pattern
+ if (option_tuple === undefined) {
+ pattern = 'A'
+ } else {
+ option_string_indices[i] = option_tuple
+ pattern = 'O'
+ }
+ arg_string_pattern_parts.push(pattern)
+ }
+ }
+
+ // join the pieces together to form the pattern
+ let arg_strings_pattern = arg_string_pattern_parts.join('')
+
+ // converts arg strings to the appropriate and then takes the action
+ let seen_actions = new Set()
+ let seen_non_default_actions = new Set()
+ let extras
+
+ let take_action = (action, argument_strings, option_string = undefined) => {
+ seen_actions.add(action)
+ let argument_values = this._get_values(action, argument_strings)
+
+ // error if this argument is not allowed with other previously
+ // seen arguments, assuming that actions that use the default
+ // value don't really count as "present"
+ if (argument_values !== action.default) {
+ seen_non_default_actions.add(action)
+ for (let conflict_action of action_conflicts.get(action) || []) {
+ if (seen_non_default_actions.has(conflict_action)) {
+ let msg = 'not allowed with argument %s'
+ let action_name = _get_action_name(conflict_action)
+ throw new ArgumentError(action, sub(msg, action_name))
+ }
+ }
+ }
+
+ // take the action if we didn't receive a SUPPRESS value
+ // (e.g. from a default)
+ if (argument_values !== SUPPRESS) {
+ action(this, namespace, argument_values, option_string)
+ }
+ }
+
+ // function to convert arg_strings into an optional action
+ let consume_optional = start_index => {
+
+ // get the optional identified at this index
+ let option_tuple = option_string_indices[start_index]
+ let [ action, option_string, explicit_arg ] = option_tuple
+
+ // identify additional optionals in the same arg string
+ // (e.g. -xyz is the same as -x -y -z if no args are required)
+ let action_tuples = []
+ let stop
+ for (;;) {
+
+ // if we found no optional action, skip it
+ if (action === undefined) {
+ extras.push(arg_strings[start_index])
+ return start_index + 1
+ }
+
+ // if there is an explicit argument, try to match the
+ // optional's string arguments to only this
+ if (explicit_arg !== undefined) {
+ let arg_count = this._match_argument(action, 'A')
+
+ // if the action is a single-dash option and takes no
+ // arguments, try to parse more single-dash options out
+ // of the tail of the option string
+ let chars = this.prefix_chars
+ if (arg_count === 0 && !chars.includes(option_string[1])) {
+ action_tuples.push([ action, [], option_string ])
+ let char = option_string[0]
+ option_string = char + explicit_arg[0]
+ let new_explicit_arg = explicit_arg.slice(1) || undefined
+ let optionals_map = this._option_string_actions
+ if (hasattr(optionals_map, option_string)) {
+ action = optionals_map[option_string]
+ explicit_arg = new_explicit_arg
+ } else {
+ let msg = 'ignored explicit argument %r'
+ throw new ArgumentError(action, sub(msg, explicit_arg))
+ }
+
+ // if the action expect exactly one argument, we've
+ // successfully matched the option; exit the loop
+ } else if (arg_count === 1) {
+ stop = start_index + 1
+ let args = [ explicit_arg ]
+ action_tuples.push([ action, args, option_string ])
+ break
+
+ // error if a double-dash option did not use the
+ // explicit argument
+ } else {
+ let msg = 'ignored explicit argument %r'
+ throw new ArgumentError(action, sub(msg, explicit_arg))
+ }
+
+ // if there is no explicit argument, try to match the
+ // optional's string arguments with the following strings
+ // if successful, exit the loop
+ } else {
+ let start = start_index + 1
+ let selected_patterns = arg_strings_pattern.slice(start)
+ let arg_count = this._match_argument(action, selected_patterns)
+ stop = start + arg_count
+ let args = arg_strings.slice(start, stop)
+ action_tuples.push([ action, args, option_string ])
+ break
+ }
+ }
+
+ // add the Optional to the list and return the index at which
+ // the Optional's string args stopped
+ assert(action_tuples.length)
+ for (let [ action, args, option_string ] of action_tuples) {
+ take_action(action, args, option_string)
+ }
+ return stop
+ }
+
+ // the list of Positionals left to be parsed; this is modified
+ // by consume_positionals()
+ let positionals = this._get_positional_actions()
+
+ // function to convert arg_strings into positional actions
+ let consume_positionals = start_index => {
+ // match as many Positionals as possible
+ let selected_pattern = arg_strings_pattern.slice(start_index)
+ let arg_counts = this._match_arguments_partial(positionals, selected_pattern)
+
+ // slice off the appropriate arg strings for each Positional
+ // and add the Positional and its args to the list
+ for (let i = 0; i < positionals.length && i < arg_counts.length; i++) {
+ let action = positionals[i]
+ let arg_count = arg_counts[i]
+ let args = arg_strings.slice(start_index, start_index + arg_count)
+ start_index += arg_count
+ take_action(action, args)
+ }
+
+ // slice off the Positionals that we just parsed and return the
+ // index at which the Positionals' string args stopped
+ positionals = positionals.slice(arg_counts.length)
+ return start_index
+ }
+
+ // consume Positionals and Optionals alternately, until we have
+ // passed the last option string
+ extras = []
+ let start_index = 0
+ let max_option_string_index = Math.max(-1, ...Object.keys(option_string_indices).map(Number))
+ while (start_index <= max_option_string_index) {
+
+ // consume any Positionals preceding the next option
+ let next_option_string_index = Math.min(
+ // eslint-disable-next-line no-loop-func
+ ...Object.keys(option_string_indices).map(Number).filter(index => index >= start_index)
+ )
+ if (start_index !== next_option_string_index) {
+ let positionals_end_index = consume_positionals(start_index)
+
+ // only try to parse the next optional if we didn't consume
+ // the option string during the positionals parsing
+ if (positionals_end_index > start_index) {
+ start_index = positionals_end_index
+ continue
+ } else {
+ start_index = positionals_end_index
+ }
+ }
+
+ // if we consumed all the positionals we could and we're not
+ // at the index of an option string, there were extra arguments
+ if (!(start_index in option_string_indices)) {
+ let strings = arg_strings.slice(start_index, next_option_string_index)
+ extras = extras.concat(strings)
+ start_index = next_option_string_index
+ }
+
+ // consume the next optional and any arguments for it
+ start_index = consume_optional(start_index)
+ }
+
+ // consume any positionals following the last Optional
+ let stop_index = consume_positionals(start_index)
+
+ // if we didn't consume all the argument strings, there were extras
+ extras = extras.concat(arg_strings.slice(stop_index))
+
+ // make sure all required actions were present and also convert
+ // action defaults which were not given as arguments
+ let required_actions = []
+ for (let action of this._actions) {
+ if (!seen_actions.has(action)) {
+ if (action.required) {
+ required_actions.push(_get_action_name(action))
+ } else {
+ // Convert action default now instead of doing it before
+ // parsing arguments to avoid calling convert functions
+ // twice (which may fail) if the argument was given, but
+ // only if it was defined already in the namespace
+ if (action.default !== undefined &&
+ typeof action.default === 'string' &&
+ hasattr(namespace, action.dest) &&
+ action.default === getattr(namespace, action.dest)) {
+ setattr(namespace, action.dest,
+ this._get_value(action, action.default))
+ }
+ }
+ }
+ }
+
+ if (required_actions.length) {
+ this.error(sub('the following arguments are required: %s',
+ required_actions.join(', ')))
+ }
+
+ // make sure all required groups had one option present
+ for (let group of this._mutually_exclusive_groups) {
+ if (group.required) {
+ let no_actions_used = true
+ for (let action of group._group_actions) {
+ if (seen_non_default_actions.has(action)) {
+ no_actions_used = false
+ break
+ }
+ }
+
+ // if no actions were used, report the error
+ if (no_actions_used) {
+ let names = group._group_actions
+ .filter(action => action.help !== SUPPRESS)
+ .map(action => _get_action_name(action))
+ let msg = 'one of the arguments %s is required'
+ this.error(sub(msg, names.join(' ')))
+ }
+ }
+ }
+
+ // return the updated namespace and the extra arguments
+ return [ namespace, extras ]
+ }
+
+ _read_args_from_files(arg_strings) {
+ // expand arguments referencing files
+ let new_arg_strings = []
+ for (let arg_string of arg_strings) {
+
+ // for regular arguments, just add them back into the list
+ if (!arg_string || !this.fromfile_prefix_chars.includes(arg_string[0])) {
+ new_arg_strings.push(arg_string)
+
+ // replace arguments referencing files with the file content
+ } else {
+ try {
+ let args_file = fs.readFileSync(arg_string.slice(1), 'utf8')
+ let arg_strings = []
+ for (let arg_line of splitlines(args_file)) {
+ for (let arg of this.convert_arg_line_to_args(arg_line)) {
+ arg_strings.push(arg)
+ }
+ }
+ arg_strings = this._read_args_from_files(arg_strings)
+ new_arg_strings = new_arg_strings.concat(arg_strings)
+ } catch (err) {
+ this.error(err.message)
+ }
+ }
+ }
+
+ // return the modified argument list
+ return new_arg_strings
+ }
+
+ convert_arg_line_to_args(arg_line) {
+ return [arg_line]
+ }
+
+ _match_argument(action, arg_strings_pattern) {
+ // match the pattern for this action to the arg strings
+ let nargs_pattern = this._get_nargs_pattern(action)
+ let match = arg_strings_pattern.match(new RegExp('^' + nargs_pattern))
+
+ // raise an exception if we weren't able to find a match
+ if (match === null) {
+ let nargs_errors = {
+ undefined: 'expected one argument',
+ [OPTIONAL]: 'expected at most one argument',
+ [ONE_OR_MORE]: 'expected at least one argument'
+ }
+ let msg = nargs_errors[action.nargs]
+ if (msg === undefined) {
+ msg = sub(action.nargs === 1 ? 'expected %s argument' : 'expected %s arguments', action.nargs)
+ }
+ throw new ArgumentError(action, msg)
+ }
+
+ // return the number of arguments matched
+ return match[1].length
+ }
+
+ _match_arguments_partial(actions, arg_strings_pattern) {
+ // progressively shorten the actions list by slicing off the
+ // final actions until we find a match
+ let result = []
+ for (let i of range(actions.length, 0, -1)) {
+ let actions_slice = actions.slice(0, i)
+ let pattern = actions_slice.map(action => this._get_nargs_pattern(action)).join('')
+ let match = arg_strings_pattern.match(new RegExp('^' + pattern))
+ if (match !== null) {
+ result = result.concat(match.slice(1).map(string => string.length))
+ break
+ }
+ }
+
+ // return the list of arg string counts
+ return result
+ }
+
+ _parse_optional(arg_string) {
+ // if it's an empty string, it was meant to be a positional
+ if (!arg_string) {
+ return undefined
+ }
+
+ // if it doesn't start with a prefix, it was meant to be positional
+ if (!this.prefix_chars.includes(arg_string[0])) {
+ return undefined
+ }
+
+ // if the option string is present in the parser, return the action
+ if (arg_string in this._option_string_actions) {
+ let action = this._option_string_actions[arg_string]
+ return [ action, arg_string, undefined ]
+ }
+
+ // if it's just a single character, it was meant to be positional
+ if (arg_string.length === 1) {
+ return undefined
+ }
+
+ // if the option string before the "=" is present, return the action
+ if (arg_string.includes('=')) {
+ let [ option_string, explicit_arg ] = _string_split(arg_string, '=', 1)
+ if (option_string in this._option_string_actions) {
+ let action = this._option_string_actions[option_string]
+ return [ action, option_string, explicit_arg ]
+ }
+ }
+
+ // search through all possible prefixes of the option string
+ // and all actions in the parser for possible interpretations
+ let option_tuples = this._get_option_tuples(arg_string)
+
+ // if multiple actions match, the option string was ambiguous
+ if (option_tuples.length > 1) {
+ let options = option_tuples.map(([ /*action*/, option_string/*, explicit_arg*/ ]) => option_string).join(', ')
+ let args = {option: arg_string, matches: options}
+ let msg = 'ambiguous option: %(option)s could match %(matches)s'
+ this.error(sub(msg, args))
+
+ // if exactly one action matched, this segmentation is good,
+ // so return the parsed action
+ } else if (option_tuples.length === 1) {
+ let [ option_tuple ] = option_tuples
+ return option_tuple
+ }
+
+ // if it was not found as an option, but it looks like a negative
+ // number, it was meant to be positional
+ // unless there are negative-number-like options
+ if (this._negative_number_matcher.test(arg_string)) {
+ if (!this._has_negative_number_optionals.length) {
+ return undefined
+ }
+ }
+
+ // if it contains a space, it was meant to be a positional
+ if (arg_string.includes(' ')) {
+ return undefined
+ }
+
+ // it was meant to be an optional but there is no such option
+ // in this parser (though it might be a valid option in a subparser)
+ return [ undefined, arg_string, undefined ]
+ }
+
+ _get_option_tuples(option_string) {
+ let result = []
+
+ // option strings starting with two prefix characters are only
+ // split at the '='
+ let chars = this.prefix_chars
+ if (chars.includes(option_string[0]) && chars.includes(option_string[1])) {
+ if (this.allow_abbrev) {
+ let option_prefix, explicit_arg
+ if (option_string.includes('=')) {
+ [ option_prefix, explicit_arg ] = _string_split(option_string, '=', 1)
+ } else {
+ option_prefix = option_string
+ explicit_arg = undefined
+ }
+ for (let option_string of Object.keys(this._option_string_actions)) {
+ if (option_string.startsWith(option_prefix)) {
+ let action = this._option_string_actions[option_string]
+ let tup = [ action, option_string, explicit_arg ]
+ result.push(tup)
+ }
+ }
+ }
+
+ // single character options can be concatenated with their arguments
+ // but multiple character options always have to have their argument
+ // separate
+ } else if (chars.includes(option_string[0]) && !chars.includes(option_string[1])) {
+ let option_prefix = option_string
+ let explicit_arg = undefined
+ let short_option_prefix = option_string.slice(0, 2)
+ let short_explicit_arg = option_string.slice(2)
+
+ for (let option_string of Object.keys(this._option_string_actions)) {
+ if (option_string === short_option_prefix) {
+ let action = this._option_string_actions[option_string]
+ let tup = [ action, option_string, short_explicit_arg ]
+ result.push(tup)
+ } else if (option_string.startsWith(option_prefix)) {
+ let action = this._option_string_actions[option_string]
+ let tup = [ action, option_string, explicit_arg ]
+ result.push(tup)
+ }
+ }
+
+ // shouldn't ever get here
+ } else {
+ this.error(sub('unexpected option string: %s', option_string))
+ }
+
+ // return the collected option tuples
+ return result
+ }
+
+ _get_nargs_pattern(action) {
+ // in all examples below, we have to allow for '--' args
+ // which are represented as '-' in the pattern
+ let nargs = action.nargs
+ let nargs_pattern
+
+ // the default (None) is assumed to be a single argument
+ if (nargs === undefined) {
+ nargs_pattern = '(-*A-*)'
+
+ // allow zero or one arguments
+ } else if (nargs === OPTIONAL) {
+ nargs_pattern = '(-*A?-*)'
+
+ // allow zero or more arguments
+ } else if (nargs === ZERO_OR_MORE) {
+ nargs_pattern = '(-*[A-]*)'
+
+ // allow one or more arguments
+ } else if (nargs === ONE_OR_MORE) {
+ nargs_pattern = '(-*A[A-]*)'
+
+ // allow any number of options or arguments
+ } else if (nargs === REMAINDER) {
+ nargs_pattern = '([-AO]*)'
+
+ // allow one argument followed by any number of options or arguments
+ } else if (nargs === PARSER) {
+ nargs_pattern = '(-*A[-AO]*)'
+
+ // suppress action, like nargs=0
+ } else if (nargs === SUPPRESS) {
+ nargs_pattern = '(-*-*)'
+
+ // all others should be integers
+ } else {
+ nargs_pattern = sub('(-*%s-*)', 'A'.repeat(nargs).split('').join('-*'))
+ }
+
+ // if this is an optional action, -- is not allowed
+ if (action.option_strings.length) {
+ nargs_pattern = nargs_pattern.replace(/-\*/g, '')
+ nargs_pattern = nargs_pattern.replace(/-/g, '')
+ }
+
+ // return the pattern
+ return nargs_pattern
+ }
+
+ // ========================
+ // Alt command line argument parsing, allowing free intermix
+ // ========================
+
+ parse_intermixed_args(args = undefined, namespace = undefined) {
+ let argv
+ [ args, argv ] = this.parse_known_intermixed_args(args, namespace)
+ if (argv.length) {
+ let msg = 'unrecognized arguments: %s'
+ this.error(sub(msg, argv.join(' ')))
+ }
+ return args
+ }
+
+ parse_known_intermixed_args(args = undefined, namespace = undefined) {
+ // returns a namespace and list of extras
+ //
+ // positional can be freely intermixed with optionals. optionals are
+ // first parsed with all positional arguments deactivated. The 'extras'
+ // are then parsed. If the parser definition is incompatible with the
+ // intermixed assumptions (e.g. use of REMAINDER, subparsers) a
+ // TypeError is raised.
+ //
+ // positionals are 'deactivated' by setting nargs and default to
+ // SUPPRESS. This blocks the addition of that positional to the
+ // namespace
+
+ let extras
+ let positionals = this._get_positional_actions()
+ let a = positionals.filter(action => [ PARSER, REMAINDER ].includes(action.nargs))
+ if (a.length) {
+ throw new TypeError(sub('parse_intermixed_args: positional arg' +
+ ' with nargs=%s', a[0].nargs))
+ }
+
+ for (let group of this._mutually_exclusive_groups) {
+ for (let action of group._group_actions) {
+ if (positionals.includes(action)) {
+ throw new TypeError('parse_intermixed_args: positional in' +
+ ' mutuallyExclusiveGroup')
+ }
+ }
+ }
+
+ let save_usage
+ try {
+ save_usage = this.usage
+ let remaining_args
+ try {
+ if (this.usage === undefined) {
+ // capture the full usage for use in error messages
+ this.usage = this.format_usage().slice(7)
+ }
+ for (let action of positionals) {
+ // deactivate positionals
+ action.save_nargs = action.nargs
+ // action.nargs = 0
+ action.nargs = SUPPRESS
+ action.save_default = action.default
+ action.default = SUPPRESS
+ }
+ [ namespace, remaining_args ] = this.parse_known_args(args,
+ namespace)
+ for (let action of positionals) {
+ // remove the empty positional values from namespace
+ let attr = getattr(namespace, action.dest)
+ if (Array.isArray(attr) && attr.length === 0) {
+ // eslint-disable-next-line no-console
+ console.warn(sub('Do not expect %s in %s', action.dest, namespace))
+ delattr(namespace, action.dest)
+ }
+ }
+ } finally {
+ // restore nargs and usage before exiting
+ for (let action of positionals) {
+ action.nargs = action.save_nargs
+ action.default = action.save_default
+ }
+ }
+ let optionals = this._get_optional_actions()
+ try {
+ // parse positionals. optionals aren't normally required, but
+ // they could be, so make sure they aren't.
+ for (let action of optionals) {
+ action.save_required = action.required
+ action.required = false
+ }
+ for (let group of this._mutually_exclusive_groups) {
+ group.save_required = group.required
+ group.required = false
+ }
+ [ namespace, extras ] = this.parse_known_args(remaining_args,
+ namespace)
+ } finally {
+ // restore parser values before exiting
+ for (let action of optionals) {
+ action.required = action.save_required
+ }
+ for (let group of this._mutually_exclusive_groups) {
+ group.required = group.save_required
+ }
+ }
+ } finally {
+ this.usage = save_usage
+ }
+ return [ namespace, extras ]
+ }
+
+ // ========================
+ // Value conversion methods
+ // ========================
+ _get_values(action, arg_strings) {
+ // for everything but PARSER, REMAINDER args, strip out first '--'
+ if (![PARSER, REMAINDER].includes(action.nargs)) {
+ try {
+ _array_remove(arg_strings, '--')
+ } catch (err) {}
+ }
+
+ let value
+ // optional argument produces a default when not present
+ if (!arg_strings.length && action.nargs === OPTIONAL) {
+ if (action.option_strings.length) {
+ value = action.const
+ } else {
+ value = action.default
+ }
+ if (typeof value === 'string') {
+ value = this._get_value(action, value)
+ this._check_value(action, value)
+ }
+
+ // when nargs='*' on a positional, if there were no command-line
+ // args, use the default if it is anything other than None
+ } else if (!arg_strings.length && action.nargs === ZERO_OR_MORE &&
+ !action.option_strings.length) {
+ if (action.default !== undefined) {
+ value = action.default
+ } else {
+ value = arg_strings
+ }
+ this._check_value(action, value)
+
+ // single argument or optional argument produces a single value
+ } else if (arg_strings.length === 1 && [undefined, OPTIONAL].includes(action.nargs)) {
+ let arg_string = arg_strings[0]
+ value = this._get_value(action, arg_string)
+ this._check_value(action, value)
+
+ // REMAINDER arguments convert all values, checking none
+ } else if (action.nargs === REMAINDER) {
+ value = arg_strings.map(v => this._get_value(action, v))
+
+ // PARSER arguments convert all values, but check only the first
+ } else if (action.nargs === PARSER) {
+ value = arg_strings.map(v => this._get_value(action, v))
+ this._check_value(action, value[0])
+
+ // SUPPRESS argument does not put anything in the namespace
+ } else if (action.nargs === SUPPRESS) {
+ value = SUPPRESS
+
+ // all other types of nargs produce a list
+ } else {
+ value = arg_strings.map(v => this._get_value(action, v))
+ for (let v of value) {
+ this._check_value(action, v)
+ }
+ }
+
+ // return the converted value
+ return value
+ }
+
+ _get_value(action, arg_string) {
+ let type_func = this._registry_get('type', action.type, action.type)
+ if (typeof type_func !== 'function') {
+ let msg = '%r is not callable'
+ throw new ArgumentError(action, sub(msg, type_func))
+ }
+
+ // convert the value to the appropriate type
+ let result
+ try {
+ try {
+ result = type_func(arg_string)
+ } catch (err) {
+ // Dear TC39, why would you ever consider making es6 classes not callable?
+ // We had one universal interface, [[Call]], which worked for anything
+ // (with familiar this-instanceof guard for classes). Now we have two.
+ if (err instanceof TypeError &&
+ /Class constructor .* cannot be invoked without 'new'/.test(err.message)) {
+ // eslint-disable-next-line new-cap
+ result = new type_func(arg_string)
+ } else {
+ throw err
+ }
+ }
+
+ } catch (err) {
+ // ArgumentTypeErrors indicate errors
+ if (err instanceof ArgumentTypeError) {
+ //let name = getattr(action.type, 'name', repr(action.type))
+ let msg = err.message
+ throw new ArgumentError(action, msg)
+
+ // TypeErrors or ValueErrors also indicate errors
+ } else if (err instanceof TypeError) {
+ let name = getattr(action.type, 'name', repr(action.type))
+ let args = {type: name, value: arg_string}
+ let msg = 'invalid %(type)s value: %(value)r'
+ throw new ArgumentError(action, sub(msg, args))
+ } else {
+ throw err
+ }
+ }
+
+ // return the converted value
+ return result
+ }
+
+ _check_value(action, value) {
+ // converted value must be one of the choices (if specified)
+ if (action.choices !== undefined && !_choices_to_array(action.choices).includes(value)) {
+ let args = {value,
+ choices: _choices_to_array(action.choices).map(repr).join(', ')}
+ let msg = 'invalid choice: %(value)r (choose from %(choices)s)'
+ throw new ArgumentError(action, sub(msg, args))
+ }
+ }
+
+ // =======================
+ // Help-formatting methods
+ // =======================
+ format_usage() {
+ let formatter = this._get_formatter()
+ formatter.add_usage(this.usage, this._actions,
+ this._mutually_exclusive_groups)
+ return formatter.format_help()
+ }
+
+ format_help() {
+ let formatter = this._get_formatter()
+
+ // usage
+ formatter.add_usage(this.usage, this._actions,
+ this._mutually_exclusive_groups)
+
+ // description
+ formatter.add_text(this.description)
+
+ // positionals, optionals and user-defined groups
+ for (let action_group of this._action_groups) {
+ formatter.start_section(action_group.title)
+ formatter.add_text(action_group.description)
+ formatter.add_arguments(action_group._group_actions)
+ formatter.end_section()
+ }
+
+ // epilog
+ formatter.add_text(this.epilog)
+
+ // determine help from format above
+ return formatter.format_help()
+ }
+
+ _get_formatter() {
+ // eslint-disable-next-line new-cap
+ return new this.formatter_class({ prog: this.prog })
+ }
+
+ // =====================
+ // Help-printing methods
+ // =====================
+ print_usage(file = undefined) {
+ if (file === undefined) file = process.stdout
+ this._print_message(this.format_usage(), file)
+ }
+
+ print_help(file = undefined) {
+ if (file === undefined) file = process.stdout
+ this._print_message(this.format_help(), file)
+ }
+
+ _print_message(message, file = undefined) {
+ if (message) {
+ if (file === undefined) file = process.stderr
+ file.write(message)
+ }
+ }
+
+ // ===============
+ // Exiting methods
+ // ===============
+ exit(status = 0, message = undefined) {
+ if (message) {
+ this._print_message(message, process.stderr)
+ }
+ process.exit(status)
+ }
+
+ error(message) {
+ /*
+ * error(message: string)
+ *
+ * Prints a usage message incorporating the message to stderr and
+ * exits.
+ *
+ * If you override this in a subclass, it should not return -- it
+ * should either exit or raise an exception.
+ */
+
+ // LEGACY (v1 compatibility), debug mode
+ if (this.debug === true) throw new Error(message)
+ // end
+ this.print_usage(process.stderr)
+ let args = {prog: this.prog, message: message}
+ this.exit(2, sub('%(prog)s: error: %(message)s\n', args))
+ }
+}))
+
+
+module.exports = {
+ ArgumentParser,
+ ArgumentError,
+ ArgumentTypeError,
+ BooleanOptionalAction,
+ FileType,
+ HelpFormatter,
+ ArgumentDefaultsHelpFormatter,
+ RawDescriptionHelpFormatter,
+ RawTextHelpFormatter,
+ MetavarTypeHelpFormatter,
+ Namespace,
+ Action,
+ ONE_OR_MORE,
+ OPTIONAL,
+ PARSER,
+ REMAINDER,
+ SUPPRESS,
+ ZERO_OR_MORE
+}
+
+// LEGACY (v1 compatibility), Const alias
+Object.defineProperty(module.exports, 'Const', {
+ get() {
+ let result = {}
+ Object.entries({ ONE_OR_MORE, OPTIONAL, PARSER, REMAINDER, SUPPRESS, ZERO_OR_MORE }).forEach(([ n, v ]) => {
+ Object.defineProperty(result, n, {
+ get() {
+ deprecate(n, sub('use argparse.%s instead of argparse.Const.%s', n, n))
+ return v
+ }
+ })
+ })
+ Object.entries({ _UNRECOGNIZED_ARGS_ATTR }).forEach(([ n, v ]) => {
+ Object.defineProperty(result, n, {
+ get() {
+ deprecate(n, sub('argparse.Const.%s is an internal symbol and will no longer be available', n))
+ return v
+ }
+ })
+ })
+ return result
+ },
+ enumerable: false
+})
+// end
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/package.json b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..647d2aff18d2ac0bc73c4618e09a2a220bf7b36a
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/argparse/package.json
@@ -0,0 +1,31 @@
+{
+ "name": "argparse",
+ "description": "CLI arguments parser. Native port of python's argparse.",
+ "version": "2.0.1",
+ "keywords": [
+ "cli",
+ "parser",
+ "argparse",
+ "option",
+ "args"
+ ],
+ "main": "argparse.js",
+ "files": [
+ "argparse.js",
+ "lib/"
+ ],
+ "license": "Python-2.0",
+ "repository": "nodeca/argparse",
+ "scripts": {
+ "lint": "eslint .",
+ "test": "npm run lint && nyc mocha",
+ "coverage": "npm run test && nyc report --reporter html"
+ },
+ "devDependencies": {
+ "@babel/eslint-parser": "^7.11.0",
+ "@babel/plugin-syntax-class-properties": "^7.10.4",
+ "eslint": "^7.5.0",
+ "mocha": "^8.0.1",
+ "nyc": "^15.1.0"
+ }
+}
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/LICENSE b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..a194c884de0a9fac7ef89094e4800282dda23f17
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Anton Korzunov
+
+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.
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/README.md b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..74b34ff4414e6515ed9b3407c341ce3f9e48b343
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/README.md
@@ -0,0 +1,99 @@
+# aria-hidden
+
+[](https://nodei.co/npm/aria-hidden/)
+
+Hides from ARIA everything, except provided node(s).
+
+Helps to isolate modal dialogs and focused task - the content will be not accessible using
+accessible tools.
+
+Now with [HTML inert](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/inert) support
+
+# API
+
+Just call `hideOthers` with DOM-node you want to keep, and it will _hide_ everything else.
+`targetNode` could be placed anywhere - its siblings would be hidden, but it and its parents - not.
+
+> "hidden" in terms or `aria-hidden`
+
+```js
+import { hideOthers } from 'aria-hidden';
+
+const undo = hideOthers(exceptThisDOMnode);
+// everything else is "aria-hidden"
+
+// undo changes
+undo();
+```
+
+you also may limit the effect spread by providing top level node as a second parameter
+
+```js
+// keep only `anotherNode` node visible in #app
+// the rest of document will be untouched
+hideOthers(anotherNode, document.getElementById('app'));
+```
+
+> `parentNode` defaults to document.body
+
+# Inert
+
+While `aria-hidden` played important role in the past and will play in the future - the main
+use case always was around isolating content and making elements "transparent" not only for aria, but for
+user interaction as well.
+
+This is why you might consider using `inertOthers`
+
+```tsx
+import { hideOthers, inertOthers, supportsInert } from 'aria-hidden';
+
+// focus on element mean "hide others". Ideally disable interactions
+const focusOnElement = (node) => (supportsInert() ? inertOthers(node) : hideOthers(node));
+```
+
+the same function as above is already contructed and exported as
+
+```tsx
+import { suppressOthers } from 'aria-hidden';
+
+suppressOthers([keepThisNode, andThis]);
+```
+
+⚠️ Note - inert **will disable any interactions** with _suppressed_ elements ⚠️
+
+### Suppressing interactivity without inert
+
+One can `marker`, the third argument to a function, to mark hidden elements.
+Later one can create a style matching given marker to apply `pointer-events:none`
+
+```css
+[hidden-node] {
+ pointer-events: none;
+}
+```
+
+```tsx
+hideOthers(notThisOne, undefined /*parent = document*/, 'hidden-node');
+```
+
+Generally speaking the same can be achieved by addressing `[aria-hidden]` nodes, but
+not all `aria-hidden` nodes are expected to be non-interactive.
+Hence, it's better to separate concerns.
+
+# Inspiration
+
+Based on [smooth-ui](https://github.com/smooth-code/smooth-ui) modal dialogs.
+
+# See also
+
+- [inert](https://github.com/WICG/inert) - The HTML attribute/property to mark parts of the DOM tree as "inert".
+- [react-focus-lock](https://github.com/theKashey/react-focus-lock) to lock Focus inside modal.
+- [react-scroll-lock](https://github.com/theKashey/react-scroll-lock) to disable page scroll while modal is opened.
+
+# Size
+
+Code is 30 lines long
+
+# Licence
+
+MIT
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/package.json b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..dcb8d9c4dfe575e81d61e4902c568eff121929a2
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/aria-hidden/package.json
@@ -0,0 +1,71 @@
+{
+ "name": "aria-hidden",
+ "version": "1.2.6",
+ "description": "Cast aria-hidden to everything, except...",
+ "main": "dist/es5/index.js",
+ "sideEffects": false,
+ "scripts": {
+ "test": "jest",
+ "dev": "lib-builder dev",
+ "test:ci": "jest --runInBand --coverage",
+ "build": "lib-builder build && yarn size:report",
+ "prepublish": "yarn build",
+ "release": "yarn build && yarn test",
+ "lint": "lib-builder lint",
+ "format": "lib-builder format",
+ "size": "size-limit",
+ "size:report": "size-limit --json > .size.json",
+ "update": "lib-builder update",
+ "prepublish-only": "yarn build && yarn changelog",
+ "prepare": "husky install",
+ "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+ "changelog:rewrite": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0"
+ },
+ "author": "Anton Korzunov 
+
+[PostCSS] plugin to parse CSS and add vendor prefixes to CSS rules using values
+from [Can I Use]. It is recommended by Google and used in Twitter and Alibaba.
+
+Write your CSS rules without vendor prefixes (in fact, forget about them
+entirely):
+
+```css
+::placeholder {
+ color: gray;
+}
+
+.image {
+ background-image: url(image@1x.png);
+}
+@media (min-resolution: 2dppx) {
+ .image {
+ background-image: url(image@2x.png);
+ }
+}
+```
+
+Autoprefixer will use the data based on current browser popularity and property
+support to apply prefixes for you. You can try the [interactive demo]
+of Autoprefixer.
+
+```css
+::-moz-placeholder {
+ color: gray;
+}
+::placeholder {
+ color: gray;
+}
+
+.image {
+ background-image: url(image@1x.png);
+}
+@media (-webkit-min-device-pixel-ratio: 2),
+ (min-resolution: 2dppx) {
+ .image {
+ background-image: url(image@2x.png);
+ }
+}
+```
+
+Twitter account for news and releases: [@autoprefixer].
+
+
+
+
+
+[interactive demo]: https://autoprefixer.github.io/
+[@autoprefixer]: https://twitter.com/autoprefixer
+[Can I Use]: https://caniuse.com/
+[cult-img]: https://cultofmartians.com/assets/badges/badge.svg
+[PostCSS]: https://github.com/postcss/postcss
+[cult]: https://cultofmartians.com/tasks/autoprefixer-grid.html
+
+
+## Docs
+Read full docs **[here](https://github.com/postcss/autoprefixer#readme)**.
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/autoprefixer/package.json b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/autoprefixer/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..664c1b20a345c33b270b2cd4a353dd86e3914c22
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/autoprefixer/package.json
@@ -0,0 +1,49 @@
+{
+ "name": "autoprefixer",
+ "version": "10.4.21",
+ "description": "Parse CSS and add vendor prefixes to CSS rules using values from the Can I Use website",
+ "engines": {
+ "node": "^10 || ^12 || >=14"
+ },
+ "keywords": [
+ "autoprefixer",
+ "css",
+ "prefix",
+ "postcss",
+ "postcss-plugin"
+ ],
+ "main": "lib/autoprefixer.js",
+ "bin": "bin/autoprefixer",
+ "types": "lib/autoprefixer.d.ts",
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "author": "Andrey Sitnik
+
+
+## Performance
+
+Braces is not only screaming fast, it's also more accurate the other brace expansion libraries.
+
+### Better algorithms
+
+Fortunately there is a solution to the ["brace bomb" problem](#brace-matching-pitfalls): _don't expand brace patterns into an array when they're used for matching_.
+
+Instead, convert the pattern into an optimized regular expression. This is easier said than done, and braces is the only library that does this currently.
+
+**The proof is in the numbers**
+
+Minimatch gets exponentially slower as patterns increase in complexity, braces does not. The following results were generated using `braces()` and `minimatch.braceExpand()`, respectively.
+
+| **Pattern** | **braces** | **[minimatch][]** |
+| --------------------------- | ------------------- | ---------------------------- |
+| `{1..9007199254740991}`[^1] | `298 B` (5ms 459μs) | N/A (freezes) |
+| `{1..1000000000000000}` | `41 B` (1ms 15μs) | N/A (freezes) |
+| `{1..100000000000000}` | `40 B` (890μs) | N/A (freezes) |
+| `{1..10000000000000}` | `39 B` (2ms 49μs) | N/A (freezes) |
+| `{1..1000000000000}` | `38 B` (608μs) | N/A (freezes) |
+| `{1..100000000000}` | `37 B` (397μs) | N/A (freezes) |
+| `{1..10000000000}` | `35 B` (983μs) | N/A (freezes) |
+| `{1..1000000000}` | `34 B` (798μs) | N/A (freezes) |
+| `{1..100000000}` | `33 B` (733μs) | N/A (freezes) |
+| `{1..10000000}` | `32 B` (5ms 632μs) | `78.89 MB` (16s 388ms 569μs) |
+| `{1..1000000}` | `31 B` (1ms 381μs) | `6.89 MB` (1s 496ms 887μs) |
+| `{1..100000}` | `30 B` (950μs) | `588.89 kB` (146ms 921μs) |
+| `{1..10000}` | `29 B` (1ms 114μs) | `48.89 kB` (14ms 187μs) |
+| `{1..1000}` | `28 B` (760μs) | `3.89 kB` (1ms 453μs) |
+| `{1..100}` | `22 B` (345μs) | `291 B` (196μs) |
+| `{1..10}` | `10 B` (533μs) | `20 B` (37μs) |
+| `{1..3}` | `7 B` (190μs) | `5 B` (27μs) |
+
+### Faster algorithms
+
+When you need expansion, braces is still much faster.
+
+_(the following results were generated using `braces.expand()` and `minimatch.braceExpand()`, respectively)_
+
+| **Pattern** | **braces** | **[minimatch][]** |
+| --------------- | --------------------------- | ---------------------------- |
+| `{1..10000000}` | `78.89 MB` (2s 698ms 642μs) | `78.89 MB` (18s 601ms 974μs) |
+| `{1..1000000}` | `6.89 MB` (458ms 576μs) | `6.89 MB` (1s 491ms 621μs) |
+| `{1..100000}` | `588.89 kB` (20ms 728μs) | `588.89 kB` (156ms 919μs) |
+| `{1..10000}` | `48.89 kB` (2ms 202μs) | `48.89 kB` (13ms 641μs) |
+| `{1..1000}` | `3.89 kB` (1ms 796μs) | `3.89 kB` (1ms 958μs) |
+| `{1..100}` | `291 B` (424μs) | `291 B` (211μs) |
+| `{1..10}` | `20 B` (487μs) | `20 B` (72μs) |
+| `{1..3}` | `5 B` (166μs) | `5 B` (27μs) |
+
+If you'd like to run these comparisons yourself, see [test/support/generate.js](test/support/generate.js).
+
+## Benchmarks
+
+### Running benchmarks
+
+Install dev dependencies:
+
+```bash
+npm i -d && npm benchmark
+```
+
+### Latest results
+
+Braces is more accurate, without sacrificing performance.
+
+```bash
+● expand - range (expanded)
+ braces x 53,167 ops/sec ±0.12% (102 runs sampled)
+ minimatch x 11,378 ops/sec ±0.10% (102 runs sampled)
+● expand - range (optimized for regex)
+ braces x 373,442 ops/sec ±0.04% (100 runs sampled)
+ minimatch x 3,262 ops/sec ±0.18% (100 runs sampled)
+● expand - nested ranges (expanded)
+ braces x 33,921 ops/sec ±0.09% (99 runs sampled)
+ minimatch x 10,855 ops/sec ±0.28% (100 runs sampled)
+● expand - nested ranges (optimized for regex)
+ braces x 287,479 ops/sec ±0.52% (98 runs sampled)
+ minimatch x 3,219 ops/sec ±0.28% (101 runs sampled)
+● expand - set (expanded)
+ braces x 238,243 ops/sec ±0.19% (97 runs sampled)
+ minimatch x 538,268 ops/sec ±0.31% (96 runs sampled)
+● expand - set (optimized for regex)
+ braces x 321,844 ops/sec ±0.10% (97 runs sampled)
+ minimatch x 140,600 ops/sec ±0.15% (100 runs sampled)
+● expand - nested sets (expanded)
+ braces x 165,371 ops/sec ±0.42% (96 runs sampled)
+ minimatch x 337,720 ops/sec ±0.28% (100 runs sampled)
+● expand - nested sets (optimized for regex)
+ braces x 242,948 ops/sec ±0.12% (99 runs sampled)
+ minimatch x 87,403 ops/sec ±0.79% (96 runs sampled)
+```
+
+## About
+
+More about brace expansion (click to expand)
+ +There are two main types of brace expansion: + +1. **lists**: which are defined using comma-separated values inside curly braces: `{a,b,c}` +2. **sequences**: which are defined using a starting value and an ending value, separated by two dots: `a{1..3}b`. Optionally, a third argument may be passed to define a "step" or increment to use: `a{1..100..10}b`. These are also sometimes referred to as "ranges". + +Here are some example brace patterns to illustrate how they work: + +**Sets** + +``` +{a,b,c} => a b c +{a,b,c}{1,2} => a1 a2 b1 b2 c1 c2 +``` + +**Sequences** + +``` +{1..9} => 1 2 3 4 5 6 7 8 9 +{4..-4} => 4 3 2 1 0 -1 -2 -3 -4 +{1..20..3} => 1 4 7 10 13 16 19 +{a..j} => a b c d e f g h i j +{j..a} => j i h g f e d c b a +{a..z..3} => a d g j m p s v y +``` + +**Combination** + +Sets and sequences can be mixed together or used along with any other strings. + +``` +{a,b,c}{1..3} => a1 a2 a3 b1 b2 b3 c1 c2 c3 +foo/{a,b,c}/bar => foo/a/bar foo/b/bar foo/c/bar +``` + +The fact that braces can be "expanded" from relatively simple patterns makes them ideal for quickly generating test fixtures, file paths, and similar use cases. + +## Brace matching + +In addition to _expansion_, brace patterns are also useful for performing regular-expression-like matching. + +For example, the pattern `foo/{1..3}/bar` would match any of following strings: + +``` +foo/1/bar +foo/2/bar +foo/3/bar +``` + +But not: + +``` +baz/1/qux +baz/2/qux +baz/3/qux +``` + +Braces can also be combined with [glob patterns](https://github.com/jonschlinkert/micromatch) to perform more advanced wildcard matching. For example, the pattern `*/{1..3}/*` would match any of following strings: + +``` +foo/1/bar +foo/2/bar +foo/3/bar +baz/1/qux +baz/2/qux +baz/3/qux +``` + +## Brace matching pitfalls + +Although brace patterns offer a user-friendly way of matching ranges or sets of strings, there are also some major disadvantages and potential risks you should be aware of. + +### tldr + +**"brace bombs"** + +- brace expansion can eat up a huge amount of processing resources +- as brace patterns increase _linearly in size_, the system resources required to expand the pattern increase exponentially +- users can accidentally (or intentially) exhaust your system's resources resulting in the equivalent of a DoS attack (bonus: no programming knowledge is required!) + +For a more detailed explanation with examples, see the [geometric complexity](#geometric-complexity) section. + +### The solution + +Jump to the [performance section](#performance) to see how Braces solves this problem in comparison to other libraries. + +### Geometric complexity + +At minimum, brace patterns with sets limited to two elements have quadradic or `O(n^2)` complexity. But the complexity of the algorithm increases exponentially as the number of sets, _and elements per set_, increases, which is `O(n^c)`. + +For example, the following sets demonstrate quadratic (`O(n^2)`) complexity: + +``` +{1,2}{3,4} => (2X2) => 13 14 23 24 +{1,2}{3,4}{5,6} => (2X2X2) => 135 136 145 146 235 236 245 246 +``` + +But add an element to a set, and we get a n-fold Cartesian product with `O(n^c)` complexity: + +``` +{1,2,3}{4,5,6}{7,8,9} => (3X3X3) => 147 148 149 157 158 159 167 168 169 247 248 + 249 257 258 259 267 268 269 347 348 349 357 + 358 359 367 368 369 +``` + +Now, imagine how this complexity grows given that each element is a n-tuple: + +``` +{1..100}{1..100} => (100X100) => 10,000 elements (38.4 kB) +{1..100}{1..100}{1..100} => (100X100X100) => 1,000,000 elements (5.76 MB) +``` + +Although these examples are clearly contrived, they demonstrate how brace patterns can quickly grow out of control. + +**More information** + +Interested in learning more about brace expansion? + +- [linuxjournal/bash-brace-expansion](http://www.linuxjournal.com/content/bash-brace-expansion) +- [rosettacode/Brace_expansion](https://rosettacode.org/wiki/Brace_expansion) +- [cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) + +
+
+
+Contributing
+ +Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new). + +
+
+
+Running Tests
+ +Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command: + +```sh +$ npm install && npm test +``` + +
+
+
+### Contributors
+
+| **Commits** | **Contributor** |
+| ----------- | ------------------------------------------------------------- |
+| 197 | [jonschlinkert](https://github.com/jonschlinkert) |
+| 4 | [doowb](https://github.com/doowb) |
+| 1 | [es128](https://github.com/es128) |
+| 1 | [eush77](https://github.com/eush77) |
+| 1 | [hemanth](https://github.com/hemanth) |
+| 1 | [wtgtybhertgeghgtwtg](https://github.com/wtgtybhertgeghgtwtg) |
+
+### Author
+
+**Jon Schlinkert**
+
+- [GitHub Profile](https://github.com/jonschlinkert)
+- [Twitter Profile](https://twitter.com/jonschlinkert)
+- [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2019, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).
+
+---
+
+_This file was generated by [verb-generate-readme](https://github.com/verbose/verb-generate-readme), v0.8.0, on April 08, 2019._
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/braces/index.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/braces/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..d222c13b579d2d476dc26d692219dbaee1665b88
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/braces/index.js
@@ -0,0 +1,170 @@
+'use strict';
+
+const stringify = require('./lib/stringify');
+const compile = require('./lib/compile');
+const expand = require('./lib/expand');
+const parse = require('./lib/parse');
+
+/**
+ * Expand the given pattern or create a regex-compatible string.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces('{a,b,c}', { compile: true })); //=> ['(a|b|c)']
+ * console.log(braces('{a,b,c}')); //=> ['a', 'b', 'c']
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {String}
+ * @api public
+ */
+
+const braces = (input, options = {}) => {
+ let output = [];
+
+ if (Array.isArray(input)) {
+ for (const pattern of input) {
+ const result = braces.create(pattern, options);
+ if (Array.isArray(result)) {
+ output.push(...result);
+ } else {
+ output.push(result);
+ }
+ }
+ } else {
+ output = [].concat(braces.create(input, options));
+ }
+
+ if (options && options.expand === true && options.nodupes === true) {
+ output = [...new Set(output)];
+ }
+ return output;
+};
+
+/**
+ * Parse the given `str` with the given `options`.
+ *
+ * ```js
+ * // braces.parse(pattern, [, options]);
+ * const ast = braces.parse('a/{b,c}/d');
+ * console.log(ast);
+ * ```
+ * @param {String} pattern Brace pattern to parse
+ * @param {Object} options
+ * @return {Object} Returns an AST
+ * @api public
+ */
+
+braces.parse = (input, options = {}) => parse(input, options);
+
+/**
+ * Creates a braces string from an AST, or an AST node.
+ *
+ * ```js
+ * const braces = require('braces');
+ * let ast = braces.parse('foo/{a,b}/bar');
+ * console.log(stringify(ast.nodes[2])); //=> '{a,b}'
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.stringify = (input, options = {}) => {
+ if (typeof input === 'string') {
+ return stringify(braces.parse(input, options), options);
+ }
+ return stringify(input, options);
+};
+
+/**
+ * Compiles a brace pattern into a regex-compatible, optimized string.
+ * This method is called by the main [braces](#braces) function by default.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.compile('a/{b,c}/d'));
+ * //=> ['a/(b|c)/d']
+ * ```
+ * @param {String} `input` Brace pattern or AST.
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.compile = (input, options = {}) => {
+ if (typeof input === 'string') {
+ input = braces.parse(input, options);
+ }
+ return compile(input, options);
+};
+
+/**
+ * Expands a brace pattern into an array. This method is called by the
+ * main [braces](#braces) function when `options.expand` is true. Before
+ * using this method it's recommended that you read the [performance notes](#performance))
+ * and advantages of using [.compile](#compile) instead.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.expand('a/{b,c}/d'));
+ * //=> ['a/b/d', 'a/c/d'];
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.expand = (input, options = {}) => {
+ if (typeof input === 'string') {
+ input = braces.parse(input, options);
+ }
+
+ let result = expand(input, options);
+
+ // filter out empty strings if specified
+ if (options.noempty === true) {
+ result = result.filter(Boolean);
+ }
+
+ // filter out duplicates if specified
+ if (options.nodupes === true) {
+ result = [...new Set(result)];
+ }
+
+ return result;
+};
+
+/**
+ * Processes a brace pattern and returns either an expanded array
+ * (if `options.expand` is true), a highly optimized regex-compatible string.
+ * This method is called by the main [braces](#braces) function.
+ *
+ * ```js
+ * const braces = require('braces');
+ * console.log(braces.create('user-{200..300}/project-{a,b,c}-{1..10}'))
+ * //=> 'user-(20[0-9]|2[1-9][0-9]|300)/project-(a|b|c)-([1-9]|10)'
+ * ```
+ * @param {String} `pattern` Brace pattern
+ * @param {Object} `options`
+ * @return {Array} Returns an array of expanded values.
+ * @api public
+ */
+
+braces.create = (input, options = {}) => {
+ if (input === '' || input.length < 3) {
+ return [input];
+ }
+
+ return options.expand !== true
+ ? braces.compile(input, options)
+ : braces.expand(input, options);
+};
+
+/**
+ * Expose "braces"
+ */
+
+module.exports = braces;
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/braces/package.json b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/braces/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..c3c056e469726cdb0d0cb6cec73b3f79abf0eb23
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/braces/package.json
@@ -0,0 +1,77 @@
+{
+ "name": "braces",
+ "description": "Bash-like brace expansion, implemented in JavaScript. Safer than other brace expansion libs, with complete support for the Bash 4.3 braces specification, without sacrificing speed.",
+ "version": "3.0.3",
+ "homepage": "https://github.com/micromatch/braces",
+ "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+ "contributors": [
+ "Brian Woodward (https://twitter.com/doowb)",
+ "Elan Shanker (https://github.com/es128)",
+ "Eugene Sharygin (https://github.com/eush77)",
+ "hemanth.hm (http://h3manth.com)",
+ "Jon Schlinkert (http://twitter.com/jonschlinkert)"
+ ],
+ "repository": "micromatch/braces",
+ "bugs": {
+ "url": "https://github.com/micromatch/braces/issues"
+ },
+ "license": "MIT",
+ "files": [
+ "index.js",
+ "lib"
+ ],
+ "main": "index.js",
+ "engines": {
+ "node": ">=8"
+ },
+ "scripts": {
+ "test": "mocha",
+ "benchmark": "node benchmark"
+ },
+ "dependencies": {
+ "fill-range": "^7.1.1"
+ },
+ "devDependencies": {
+ "ansi-colors": "^3.2.4",
+ "bash-path": "^2.0.1",
+ "gulp-format-md": "^2.0.0",
+ "mocha": "^6.1.1"
+ },
+ "keywords": [
+ "alpha",
+ "alphabetical",
+ "bash",
+ "brace",
+ "braces",
+ "expand",
+ "expansion",
+ "filepath",
+ "fill",
+ "fs",
+ "glob",
+ "globbing",
+ "letter",
+ "match",
+ "matches",
+ "matching",
+ "number",
+ "numerical",
+ "path",
+ "range",
+ "ranges",
+ "sh"
+ ],
+ "verb": {
+ "toc": false,
+ "layout": "default",
+ "tasks": [
+ "readme"
+ ],
+ "lint": {
+ "reflinks": true
+ },
+ "plugins": [
+ "gulp-format-md"
+ ]
+ }
+}
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/LICENSE b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..90b6b91673374acb764c2a0a154a31ffb869466f
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2014 Andrey Sitnik Building docs
+ +_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_ + +To generate the readme, run the following command: + +```sh +$ npm install -g verbose/verb#dev verb-generate-readme && verb +``` + +
+
+The config to share target browsers and Node.js versions between different
+front-end tools. It is used in:
+
+* [Autoprefixer]
+* [Babel]
+* [postcss-preset-env]
+* [eslint-plugin-compat]
+* [stylelint-no-unsupported-browser-features]
+* [postcss-normalize]
+* [obsolete-webpack-plugin]
+
+All tools will find target browsers automatically,
+when you add the following to `package.json`:
+
+```json
+ "browserslist": [
+ "defaults and fully supports es6-module",
+ "maintained node versions"
+ ]
+```
+
+Or in `.browserslistrc` config:
+
+```yaml
+# Browsers that we support
+
+defaults and fully supports es6-module
+maintained node versions
+```
+
+Developers set their version lists using queries like `last 2 versions`
+to be free from updating versions manually.
+Browserslist will use [`caniuse-lite`] with [Can I Use] data for this queries.
+
+You can check how config works at our playground: [`browsersl.ist`](https://browsersl.ist/)
+
+
+ 
+
+
++
+
+ 
+
+
+[stylelint-no-unsupported-browser-features]: https://github.com/ismay/stylelint-no-unsupported-browser-features
+[obsolete-webpack-plugin]: https://github.com/ElemeFE/obsolete-webpack-plugin
+[eslint-plugin-compat]: https://github.com/amilajack/eslint-plugin-compat
+[Browserslist Example]: https://github.com/browserslist/browserslist-example
+[postcss-preset-env]: https://github.com/csstools/postcss-plugins/tree/main/plugin-packs/postcss-preset-env
+[postcss-normalize]: https://github.com/csstools/postcss-normalize
+[`browsersl.ist`]: https://browsersl.ist/
+[`caniuse-lite`]: https://github.com/ben-eb/caniuse-lite
+[Autoprefixer]: https://github.com/postcss/autoprefixer
+[Can I Use]: https://caniuse.com/
+[Babel]: https://github.com/babel/babel/tree/master/packages/babel-preset-env
+[cult-img]: https://cultofmartians.com/assets/badges/badge.svg
+[cult]: https://cultofmartians.com/done.html
+
+## Docs
+Read full docs **[here](https://github.com/browserslist/browserslist#readme)**.
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/browser.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/browser.js
new file mode 100644
index 0000000000000000000000000000000000000000..1a681fd3e2c2961af31e1e778b18723a0e119035
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/browser.js
@@ -0,0 +1,54 @@
+var BrowserslistError = require('./error')
+
+function noop() {}
+
+module.exports = {
+ loadQueries: function loadQueries() {
+ throw new BrowserslistError(
+ 'Sharable configs are not supported in client-side build of Browserslist'
+ )
+ },
+
+ getStat: function getStat(opts) {
+ return opts.stats
+ },
+
+ loadConfig: function loadConfig(opts) {
+ if (opts.config) {
+ throw new BrowserslistError(
+ 'Browserslist config are not supported in client-side build'
+ )
+ }
+ },
+
+ loadCountry: function loadCountry() {
+ throw new BrowserslistError(
+ 'Country statistics are not supported ' +
+ 'in client-side build of Browserslist'
+ )
+ },
+
+ loadFeature: function loadFeature() {
+ throw new BrowserslistError(
+ 'Supports queries are not available in client-side build of Browserslist'
+ )
+ },
+
+ currentNode: function currentNode(resolve, context) {
+ return resolve(['maintained node versions'], context)[0]
+ },
+
+ parseConfig: noop,
+
+ readConfig: noop,
+
+ findConfig: noop,
+
+ findConfigFile: noop,
+
+ clearCaches: noop,
+
+ oldDataWarning: noop,
+
+ env: {}
+}
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/cli.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/cli.js
new file mode 100644
index 0000000000000000000000000000000000000000..78c08d743a8e478c346029e241b1f795b646fbd2
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/cli.js
@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+var fs = require('fs')
+var updateDb = require('update-browserslist-db')
+
+var browserslist = require('./')
+var pkg = require('./package.json')
+
+var args = process.argv.slice(2)
+
+var USAGE =
+ 'Usage:\n' +
+ ' npx browserslist\n' +
+ ' npx browserslist "QUERIES"\n' +
+ ' npx browserslist --json "QUERIES"\n' +
+ ' npx browserslist --config="path/to/browserlist/file"\n' +
+ ' npx browserslist --coverage "QUERIES"\n' +
+ ' npx browserslist --coverage=US "QUERIES"\n' +
+ ' npx browserslist --coverage=US,RU,global "QUERIES"\n' +
+ ' npx browserslist --env="environment name defined in config"\n' +
+ ' npx browserslist --stats="path/to/browserlist/stats/file"\n' +
+ ' npx browserslist --mobile-to-desktop\n' +
+ ' npx browserslist --ignore-unknown-versions\n'
+
+function isArg(arg) {
+ return args.some(function (str) {
+ return str === arg || str.indexOf(arg + '=') === 0
+ })
+}
+
+function error(msg) {
+ process.stderr.write('browserslist: ' + msg + '\n')
+ process.exit(1)
+}
+
+if (isArg('--help') || isArg('-h')) {
+ process.stdout.write(pkg.description + '.\n\n' + USAGE + '\n')
+} else if (isArg('--version') || isArg('-v')) {
+ process.stdout.write('browserslist ' + pkg.version + '\n')
+} else if (isArg('--update-db')) {
+ /* c8 ignore next 8 */
+ process.stdout.write(
+ 'The --update-db command is deprecated.\n' +
+ 'Please use npx update-browserslist-db@latest instead.\n'
+ )
+ process.stdout.write('Browserslist DB update will still be made.\n')
+ updateDb(function (str) {
+ process.stdout.write(str)
+ })
+} else {
+ var mode = 'browsers'
+ var opts = {}
+ var queries
+ var areas
+
+ for (var i = 0; i < args.length; i++) {
+ if (args[i][0] !== '-') {
+ queries = args[i].replace(/^["']|["']$/g, '')
+ continue
+ }
+
+ var arg = args[i].split('=')
+ var name = arg[0]
+ var value = arg[1]
+
+ if (value) value = value.replace(/^["']|["']$/g, '')
+
+ if (name === '--config' || name === '-b') {
+ opts.config = value
+ } else if (name === '--env' || name === '-e') {
+ opts.env = value
+ } else if (name === '--stats' || name === '-s') {
+ opts.stats = value
+ } else if (name === '--coverage' || name === '-c') {
+ if (mode !== 'json') mode = 'coverage'
+ if (value) {
+ areas = value.split(',')
+ } else {
+ areas = ['global']
+ }
+ } else if (name === '--json') {
+ mode = 'json'
+ } else if (name === '--mobile-to-desktop') {
+ /* c8 ignore next */
+ opts.mobileToDesktop = true
+ } else if (name === '--ignore-unknown-versions') {
+ /* c8 ignore next */
+ opts.ignoreUnknownVersions = true
+ } else {
+ error('Unknown arguments ' + args[i] + '.\n\n' + USAGE)
+ }
+ }
+
+ var browsers
+ try {
+ browsers = browserslist(queries, opts)
+ } catch (e) {
+ if (e.name === 'BrowserslistError') {
+ error(e.message)
+ } /* c8 ignore start */ else {
+ throw e
+ } /* c8 ignore end */
+ }
+
+ var coverage
+ if (mode === 'browsers') {
+ browsers.forEach(function (browser) {
+ process.stdout.write(browser + '\n')
+ })
+ } else if (areas) {
+ coverage = areas.map(function (area) {
+ var stats
+ if (area !== 'global') {
+ stats = area
+ } else if (opts.stats) {
+ stats = JSON.parse(fs.readFileSync(opts.stats))
+ }
+ var result = browserslist.coverage(browsers, stats)
+ var round = Math.round(result * 100) / 100.0
+
+ return [area, round]
+ })
+
+ if (mode === 'coverage') {
+ var prefix = 'These browsers account for '
+ process.stdout.write(prefix)
+ coverage.forEach(function (data, index) {
+ var area = data[0]
+ var round = data[1]
+ var end = 'globally'
+ if (area && area !== 'global') {
+ end = 'in the ' + area.toUpperCase()
+ } else if (opts.stats) {
+ end = 'in custom statistics'
+ }
+
+ if (index !== 0) {
+ process.stdout.write(prefix.replace(/./g, ' '))
+ }
+
+ process.stdout.write(round + '% of all users ' + end + '\n')
+ })
+ }
+ }
+
+ if (mode === 'json') {
+ var data = { browsers: browsers }
+ if (coverage) {
+ data.coverage = coverage.reduce(function (object, j) {
+ object[j[0]] = j[1]
+ return object
+ }, {})
+ }
+ process.stdout.write(JSON.stringify(data, null, ' ') + '\n')
+ }
+}
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/error.d.ts b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/error.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..12ff92133a997520119a8473ff3a69d7b413d6bd
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/error.d.ts
@@ -0,0 +1,7 @@
+declare class BrowserslistError extends Error {
+ constructor(message: any)
+ name: 'BrowserslistError'
+ browserslist: true
+}
+
+export = BrowserslistError
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/error.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/error.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e5da7a823f4af93000b3a6798de0c31cec26340
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/error.js
@@ -0,0 +1,12 @@
+function BrowserslistError(message) {
+ this.name = 'BrowserslistError'
+ this.message = message
+ this.browserslist = true
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, BrowserslistError)
+ }
+}
+
+BrowserslistError.prototype = Error.prototype
+
+module.exports = BrowserslistError
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/index.d.ts b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a08176cc1ab9dfcac2e6ce65146ef051ace07140
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/index.d.ts
@@ -0,0 +1,224 @@
+/**
+ * Return array of browsers by selection queries.
+ *
+ * ```js
+ * browserslist('IE >= 10, IE 8') //=> ['ie 11', 'ie 10', 'ie 8']
+ * ```
+ *
+ * @param queries Browser queries.
+ * @param opts Options.
+ * @returns Array with browser names in Can I Use.
+ */
+declare function browserslist(
+ queries?: string | readonly string[] | null,
+ opts?: browserslist.Options
+): string[]
+
+declare namespace browserslist {
+ interface Query {
+ compose: 'or' | 'and'
+ type: string
+ query: string
+ not?: true
+ }
+
+ interface Options {
+ /**
+ * Path to processed file. It will be used to find config files.
+ */
+ path?: string | false
+ /**
+ * Processing environment. It will be used to take right queries
+ * from config file.
+ */
+ env?: string
+ /**
+ * Custom browser usage statistics for "> 1% in my stats" query.
+ */
+ stats?: Stats | string
+ /**
+ * Path to config file with queries.
+ */
+ config?: string
+ /**
+ * Do not throw on unknown version in direct query.
+ */
+ ignoreUnknownVersions?: boolean
+ /**
+ * Throw an error if env is not found.
+ */
+ throwOnMissing?: boolean
+ /**
+ * Disable security checks for extend query.
+ */
+ dangerousExtend?: boolean
+ /**
+ * Alias mobile browsers to the desktop version when Can I Use
+ * doesn’t have data about the specified version.
+ */
+ mobileToDesktop?: boolean
+ }
+
+ type Config = {
+ defaults: string[]
+ [section: string]: string[] | undefined
+ }
+
+ interface Stats {
+ [browser: string]: {
+ [version: string]: number
+ }
+ }
+
+ /**
+ * Browser names aliases.
+ */
+ let aliases: {
+ [alias: string]: string | undefined
+ }
+
+ /**
+ * Aliases to work with joined versions like `ios_saf 7.0-7.1`.
+ */
+ let versionAliases: {
+ [browser: string]:
+ | {
+ [version: string]: string | undefined
+ }
+ | undefined
+ }
+
+ /**
+ * Can I Use only provides a few versions for some browsers (e.g. `and_chr`).
+ *
+ * Fallback to a similar browser for unknown versions.
+ */
+ let desktopNames: {
+ [browser: string]: string | undefined
+ }
+
+ let data: {
+ [browser: string]:
+ | {
+ name: string
+ versions: string[]
+ released: string[]
+ releaseDate: {
+ [version: string]: number | undefined | null
+ }
+ }
+ | undefined
+ }
+
+ let nodeVersions: string[]
+
+ interface Usage {
+ [version: string]: number
+ }
+
+ let usage: {
+ global?: Usage
+ custom?: Usage | null
+ [country: string]: Usage | undefined | null
+ }
+
+ let cache: {
+ [feature: string]: {
+ [name: string]: {
+ [version: string]: string
+ }
+ }
+ }
+
+ /**
+ * Default browsers query
+ */
+ let defaults: readonly string[]
+
+ /**
+ * Which statistics should be used. Country code or custom statistics.
+ * Pass `"my stats"` to load statistics from `Browserslist` files.
+ */
+ type StatsOptions = string | 'my stats' | Stats | { dataByBrowser: Stats }
+
+ /**
+ * Return browsers market coverage.
+ *
+ * ```js
+ * browserslist.coverage(browserslist('> 1% in US'), 'US') //=> 83.1
+ * ```
+ *
+ * @param browsers Browsers names in Can I Use.
+ * @param stats Which statistics should be used.
+ * @returns Total market coverage for all selected browsers.
+ */
+ function coverage(browsers: readonly string[], stats?: StatsOptions): number
+
+ /**
+ * Get queries AST to analyze the config content.
+ *
+ * @param queries Browser queries.
+ * @param opts Options.
+ * @returns An array of the data of each query in the config.
+ */
+ function parse(
+ queries?: string | readonly string[] | null,
+ opts?: browserslist.Options
+ ): Query[]
+
+ /**
+ * Return queries for specific file inside the project.
+ *
+ * ```js
+ * browserslist.loadConfig({
+ * file: process.cwd()
+ * }) ?? browserslist.defaults
+ * ```
+ */
+ function loadConfig(options: LoadConfigOptions): string[] | undefined
+
+ function clearCaches(): void
+
+ function parseConfig(string: string): Config
+
+ function readConfig(file: string): Config
+
+ function findConfig(...pathSegments: string[]): Config | undefined
+
+ function findConfigFile(...pathSegments: string[]): string | undefined
+
+ interface LoadConfigOptions {
+ /**
+ * Path to config file
+ * */
+ config?: string
+
+ /**
+ * Path to file inside the project to find Browserslist config
+ * in closest folder
+ */
+ path?: string
+
+ /**
+ * Environment to choose part of config.
+ */
+ env?: string
+ }
+}
+
+declare global {
+ namespace NodeJS {
+ interface ProcessEnv {
+ BROWSERSLIST?: string
+ BROWSERSLIST_CONFIG?: string
+ BROWSERSLIST_DANGEROUS_EXTEND?: string
+ BROWSERSLIST_DISABLE_CACHE?: string
+ BROWSERSLIST_ENV?: string
+ BROWSERSLIST_IGNORE_OLD_DATA?: string
+ BROWSERSLIST_STATS?: string
+ BROWSERSLIST_ROOT_PATH?: string
+ }
+ }
+}
+
+export = browserslist
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/index.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..7419f581b75462a076e51e34d4385bb046d1aa47
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/index.js
@@ -0,0 +1,1246 @@
+var jsReleases = require('node-releases/data/processed/envs.json')
+var agents = require('caniuse-lite/dist/unpacker/agents').agents
+var e2c = require('electron-to-chromium/versions')
+var jsEOL = require('node-releases/data/release-schedule/release-schedule.json')
+var path = require('path')
+
+var BrowserslistError = require('./error')
+var env = require('./node')
+var parseWithoutCache = require('./parse') // Will load browser.js in webpack
+
+var YEAR = 365.259641 * 24 * 60 * 60 * 1000
+var ANDROID_EVERGREEN_FIRST = '37'
+var OP_MOB_BLINK_FIRST = 14
+
+// Helpers
+
+function isVersionsMatch(versionA, versionB) {
+ return (versionA + '.').indexOf(versionB + '.') === 0
+}
+
+function isEolReleased(name) {
+ var version = name.slice(1)
+ return browserslist.nodeVersions.some(function (i) {
+ return isVersionsMatch(i, version)
+ })
+}
+
+function normalize(versions) {
+ return versions.filter(function (version) {
+ return typeof version === 'string'
+ })
+}
+
+function normalizeElectron(version) {
+ var versionToUse = version
+ if (version.split('.').length === 3) {
+ versionToUse = version.split('.').slice(0, -1).join('.')
+ }
+ return versionToUse
+}
+
+function nameMapper(name) {
+ return function mapName(version) {
+ return name + ' ' + version
+ }
+}
+
+function getMajor(version) {
+ return parseInt(version.split('.')[0])
+}
+
+function getMajorVersions(released, number) {
+ if (released.length === 0) return []
+ var majorVersions = uniq(released.map(getMajor))
+ var minimum = majorVersions[majorVersions.length - number]
+ if (!minimum) {
+ return released
+ }
+ var selected = []
+ for (var i = released.length - 1; i >= 0; i--) {
+ if (minimum > getMajor(released[i])) break
+ selected.unshift(released[i])
+ }
+ return selected
+}
+
+function uniq(array) {
+ var filtered = []
+ for (var i = 0; i < array.length; i++) {
+ if (filtered.indexOf(array[i]) === -1) filtered.push(array[i])
+ }
+ return filtered
+}
+
+function fillUsage(result, name, data) {
+ for (var i in data) {
+ result[name + ' ' + i] = data[i]
+ }
+}
+
+function generateFilter(sign, version) {
+ version = parseFloat(version)
+ if (sign === '>') {
+ return function (v) {
+ return parseLatestFloat(v) > version
+ }
+ } else if (sign === '>=') {
+ return function (v) {
+ return parseLatestFloat(v) >= version
+ }
+ } else if (sign === '<') {
+ return function (v) {
+ return parseFloat(v) < version
+ }
+ } else {
+ return function (v) {
+ return parseFloat(v) <= version
+ }
+ }
+
+ function parseLatestFloat(v) {
+ return parseFloat(v.split('-')[1] || v)
+ }
+}
+
+function generateSemverFilter(sign, version) {
+ version = version.split('.').map(parseSimpleInt)
+ version[1] = version[1] || 0
+ version[2] = version[2] || 0
+ if (sign === '>') {
+ return function (v) {
+ v = v.split('.').map(parseSimpleInt)
+ return compareSemver(v, version) > 0
+ }
+ } else if (sign === '>=') {
+ return function (v) {
+ v = v.split('.').map(parseSimpleInt)
+ return compareSemver(v, version) >= 0
+ }
+ } else if (sign === '<') {
+ return function (v) {
+ v = v.split('.').map(parseSimpleInt)
+ return compareSemver(version, v) > 0
+ }
+ } else {
+ return function (v) {
+ v = v.split('.').map(parseSimpleInt)
+ return compareSemver(version, v) >= 0
+ }
+ }
+}
+
+function parseSimpleInt(x) {
+ return parseInt(x)
+}
+
+function compare(a, b) {
+ if (a < b) return -1
+ if (a > b) return +1
+ return 0
+}
+
+function compareSemver(a, b) {
+ return (
+ compare(parseInt(a[0]), parseInt(b[0])) ||
+ compare(parseInt(a[1] || '0'), parseInt(b[1] || '0')) ||
+ compare(parseInt(a[2] || '0'), parseInt(b[2] || '0'))
+ )
+}
+
+// this follows the npm-like semver behavior
+function semverFilterLoose(operator, range) {
+ range = range.split('.').map(parseSimpleInt)
+ if (typeof range[1] === 'undefined') {
+ range[1] = 'x'
+ }
+ // ignore any patch version because we only return minor versions
+ // range[2] = 'x'
+ switch (operator) {
+ case '<=':
+ return function (version) {
+ version = version.split('.').map(parseSimpleInt)
+ return compareSemverLoose(version, range) <= 0
+ }
+ case '>=':
+ default:
+ return function (version) {
+ version = version.split('.').map(parseSimpleInt)
+ return compareSemverLoose(version, range) >= 0
+ }
+ }
+}
+
+// this follows the npm-like semver behavior
+function compareSemverLoose(version, range) {
+ if (version[0] !== range[0]) {
+ return version[0] < range[0] ? -1 : +1
+ }
+ if (range[1] === 'x') {
+ return 0
+ }
+ if (version[1] !== range[1]) {
+ return version[1] < range[1] ? -1 : +1
+ }
+ return 0
+}
+
+function resolveVersion(data, version) {
+ if (data.versions.indexOf(version) !== -1) {
+ return version
+ } else if (browserslist.versionAliases[data.name][version]) {
+ return browserslist.versionAliases[data.name][version]
+ } else {
+ return false
+ }
+}
+
+function normalizeVersion(data, version) {
+ var resolved = resolveVersion(data, version)
+ if (resolved) {
+ return resolved
+ } else if (data.versions.length === 1) {
+ return data.versions[0]
+ } else {
+ return false
+ }
+}
+
+function filterByYear(since, context) {
+ since = since / 1000
+ return Object.keys(agents).reduce(function (selected, name) {
+ var data = byName(name, context)
+ if (!data) return selected
+ var versions = Object.keys(data.releaseDate).filter(function (v) {
+ var date = data.releaseDate[v]
+ return date !== null && date >= since
+ })
+ return selected.concat(versions.map(nameMapper(data.name)))
+ }, [])
+}
+
+function cloneData(data) {
+ return {
+ name: data.name,
+ versions: data.versions,
+ released: data.released,
+ releaseDate: data.releaseDate
+ }
+}
+
+function byName(name, context) {
+ name = name.toLowerCase()
+ name = browserslist.aliases[name] || name
+ if (context.mobileToDesktop && browserslist.desktopNames[name]) {
+ var desktop = browserslist.data[browserslist.desktopNames[name]]
+ if (name === 'android') {
+ return normalizeAndroidData(cloneData(browserslist.data[name]), desktop)
+ } else {
+ var cloned = cloneData(desktop)
+ cloned.name = name
+ return cloned
+ }
+ }
+ return browserslist.data[name]
+}
+
+function normalizeAndroidVersions(androidVersions, chromeVersions) {
+ var iFirstEvergreen = chromeVersions.indexOf(ANDROID_EVERGREEN_FIRST)
+ return androidVersions
+ .filter(function (version) {
+ return /^(?:[2-4]\.|[34]$)/.test(version)
+ })
+ .concat(chromeVersions.slice(iFirstEvergreen))
+}
+
+function copyObject(obj) {
+ var copy = {}
+ for (var key in obj) {
+ copy[key] = obj[key]
+ }
+ return copy
+}
+
+function normalizeAndroidData(android, chrome) {
+ android.released = normalizeAndroidVersions(android.released, chrome.released)
+ android.versions = normalizeAndroidVersions(android.versions, chrome.versions)
+ android.releaseDate = copyObject(android.releaseDate)
+ android.released.forEach(function (v) {
+ if (android.releaseDate[v] === undefined) {
+ android.releaseDate[v] = chrome.releaseDate[v]
+ }
+ })
+ return android
+}
+
+function checkName(name, context) {
+ var data = byName(name, context)
+ if (!data) throw new BrowserslistError('Unknown browser ' + name)
+ return data
+}
+
+function unknownQuery(query) {
+ return new BrowserslistError(
+ 'Unknown browser query `' +
+ query +
+ '`. ' +
+ 'Maybe you are using old Browserslist or made typo in query.'
+ )
+}
+
+// Adjusts last X versions queries for some mobile browsers,
+// where caniuse data jumps from a legacy version to the latest
+function filterJumps(list, name, nVersions, context) {
+ var jump = 1
+ switch (name) {
+ case 'android':
+ if (context.mobileToDesktop) return list
+ var released = browserslist.data.chrome.released
+ jump = released.length - released.indexOf(ANDROID_EVERGREEN_FIRST)
+ break
+ case 'op_mob':
+ var latest = browserslist.data.op_mob.released.slice(-1)[0]
+ jump = getMajor(latest) - OP_MOB_BLINK_FIRST + 1
+ break
+ default:
+ return list
+ }
+ if (nVersions <= jump) {
+ return list.slice(-1)
+ }
+ return list.slice(jump - 1 - nVersions)
+}
+
+function isSupported(flags, withPartial) {
+ return (
+ typeof flags === 'string' &&
+ (flags.indexOf('y') >= 0 || (withPartial && flags.indexOf('a') >= 0))
+ )
+}
+
+function resolve(queries, context) {
+ return parseQueries(queries).reduce(function (result, node, index) {
+ if (node.not && index === 0) {
+ throw new BrowserslistError(
+ 'Write any browsers query (for instance, `defaults`) ' +
+ 'before `' +
+ node.query +
+ '`'
+ )
+ }
+ var type = QUERIES[node.type]
+ var array = type.select.call(browserslist, context, node).map(function (j) {
+ var parts = j.split(' ')
+ if (parts[1] === '0') {
+ return parts[0] + ' ' + byName(parts[0], context).versions[0]
+ } else {
+ return j
+ }
+ })
+
+ if (node.compose === 'and') {
+ if (node.not) {
+ return result.filter(function (j) {
+ return array.indexOf(j) === -1
+ })
+ } else {
+ return result.filter(function (j) {
+ return array.indexOf(j) !== -1
+ })
+ }
+ } else {
+ if (node.not) {
+ var filter = {}
+ array.forEach(function (j) {
+ filter[j] = true
+ })
+ return result.filter(function (j) {
+ return !filter[j]
+ })
+ }
+ return result.concat(array)
+ }
+ }, [])
+}
+
+function prepareOpts(opts) {
+ if (typeof opts === 'undefined') opts = {}
+
+ if (typeof opts.path === 'undefined') {
+ opts.path = path.resolve ? path.resolve('.') : '.'
+ }
+
+ return opts
+}
+
+function prepareQueries(queries, opts) {
+ if (typeof queries === 'undefined' || queries === null) {
+ var config = browserslist.loadConfig(opts)
+ if (config) {
+ queries = config
+ } else {
+ queries = browserslist.defaults
+ }
+ }
+
+ return queries
+}
+
+function checkQueries(queries) {
+ if (!(typeof queries === 'string' || Array.isArray(queries))) {
+ throw new BrowserslistError(
+ 'Browser queries must be an array or string. Got ' + typeof queries + '.'
+ )
+ }
+}
+
+var cache = {}
+var parseCache = {}
+
+function browserslist(queries, opts) {
+ opts = prepareOpts(opts)
+ queries = prepareQueries(queries, opts)
+ checkQueries(queries)
+
+ var needsPath = parseQueries(queries).some(function (node) {
+ return QUERIES[node.type].needsPath
+ })
+ var context = {
+ ignoreUnknownVersions: opts.ignoreUnknownVersions,
+ dangerousExtend: opts.dangerousExtend,
+ mobileToDesktop: opts.mobileToDesktop,
+ env: opts.env
+ }
+ // Removing to avoid using context.path without marking query as needsPath
+ if (needsPath) {
+ context.path = opts.path
+ }
+
+ env.oldDataWarning(browserslist.data)
+ var stats = env.getStat(opts, browserslist.data)
+ if (stats) {
+ context.customUsage = {}
+ for (var browser in stats) {
+ fillUsage(context.customUsage, browser, stats[browser])
+ }
+ }
+
+ var cacheKey = JSON.stringify([queries, context])
+ if (cache[cacheKey]) return cache[cacheKey]
+
+ var result = uniq(resolve(queries, context)).sort(function (name1, name2) {
+ name1 = name1.split(' ')
+ name2 = name2.split(' ')
+ if (name1[0] === name2[0]) {
+ // assumptions on caniuse data
+ // 1) version ranges never overlaps
+ // 2) if version is not a range, it never contains `-`
+ var version1 = name1[1].split('-')[0]
+ var version2 = name2[1].split('-')[0]
+ return compareSemver(version2.split('.'), version1.split('.'))
+ } else {
+ return compare(name1[0], name2[0])
+ }
+ })
+ if (!env.env.BROWSERSLIST_DISABLE_CACHE) {
+ cache[cacheKey] = result
+ }
+ return result
+}
+
+function parseQueries(queries) {
+ var cacheKey = JSON.stringify(queries)
+ if (cacheKey in parseCache) return parseCache[cacheKey]
+ var result = parseWithoutCache(QUERIES, queries)
+ if (!env.env.BROWSERSLIST_DISABLE_CACHE) {
+ parseCache[cacheKey] = result
+ }
+ return result
+}
+
+function loadCustomUsage(context, config) {
+ var stats = env.loadStat(context, config, browserslist.data)
+ if (stats) {
+ context.customUsage = {}
+ for (var browser in stats) {
+ fillUsage(context.customUsage, browser, stats[browser])
+ }
+ }
+ if (!context.customUsage) {
+ throw new BrowserslistError('Custom usage statistics was not provided')
+ }
+ return context.customUsage
+}
+
+browserslist.parse = function (queries, opts) {
+ opts = prepareOpts(opts)
+ queries = prepareQueries(queries, opts)
+ checkQueries(queries)
+ return parseQueries(queries)
+}
+
+// Will be filled by Can I Use data below
+browserslist.cache = {}
+browserslist.data = {}
+browserslist.usage = {
+ global: {},
+ custom: null
+}
+
+// Default browsers query
+browserslist.defaults = ['> 0.5%', 'last 2 versions', 'Firefox ESR', 'not dead']
+
+// Browser names aliases
+browserslist.aliases = {
+ fx: 'firefox',
+ ff: 'firefox',
+ ios: 'ios_saf',
+ explorer: 'ie',
+ blackberry: 'bb',
+ explorermobile: 'ie_mob',
+ operamini: 'op_mini',
+ operamobile: 'op_mob',
+ chromeandroid: 'and_chr',
+ firefoxandroid: 'and_ff',
+ ucandroid: 'and_uc',
+ qqandroid: 'and_qq'
+}
+
+// Can I Use only provides a few versions for some browsers (e.g. and_chr).
+// Fallback to a similar browser for unknown versions
+// Note op_mob is not included as its chromium versions are not in sync with Opera desktop
+browserslist.desktopNames = {
+ and_chr: 'chrome',
+ and_ff: 'firefox',
+ ie_mob: 'ie',
+ android: 'chrome' // has extra processing logic
+}
+
+// Aliases to work with joined versions like `ios_saf 7.0-7.1`
+browserslist.versionAliases = {}
+
+browserslist.clearCaches = env.clearCaches
+browserslist.parseConfig = env.parseConfig
+browserslist.readConfig = env.readConfig
+browserslist.findConfigFile = env.findConfigFile
+browserslist.findConfig = env.findConfig
+browserslist.loadConfig = env.loadConfig
+
+browserslist.coverage = function (browsers, stats) {
+ var data
+ if (typeof stats === 'undefined') {
+ data = browserslist.usage.global
+ } else if (stats === 'my stats') {
+ var opts = {}
+ opts.path = path.resolve ? path.resolve('.') : '.'
+ var customStats = env.getStat(opts)
+ if (!customStats) {
+ throw new BrowserslistError('Custom usage statistics was not provided')
+ }
+ data = {}
+ for (var browser in customStats) {
+ fillUsage(data, browser, customStats[browser])
+ }
+ } else if (typeof stats === 'string') {
+ if (stats.length > 2) {
+ stats = stats.toLowerCase()
+ } else {
+ stats = stats.toUpperCase()
+ }
+ env.loadCountry(browserslist.usage, stats, browserslist.data)
+ data = browserslist.usage[stats]
+ } else {
+ if ('dataByBrowser' in stats) {
+ stats = stats.dataByBrowser
+ }
+ data = {}
+ for (var name in stats) {
+ for (var version in stats[name]) {
+ data[name + ' ' + version] = stats[name][version]
+ }
+ }
+ }
+
+ return browsers.reduce(function (all, i) {
+ var usage = data[i]
+ if (usage === undefined) {
+ usage = data[i.replace(/ \S+$/, ' 0')]
+ }
+ return all + (usage || 0)
+ }, 0)
+}
+
+function nodeQuery(context, node) {
+ var matched = browserslist.nodeVersions.filter(function (i) {
+ return isVersionsMatch(i, node.version)
+ })
+ if (matched.length === 0) {
+ if (context.ignoreUnknownVersions) {
+ return []
+ } else {
+ throw new BrowserslistError(
+ 'Unknown version ' + node.version + ' of Node.js'
+ )
+ }
+ }
+ return ['node ' + matched[matched.length - 1]]
+}
+
+function sinceQuery(context, node) {
+ var year = parseInt(node.year)
+ var month = parseInt(node.month || '01') - 1
+ var day = parseInt(node.day || '01')
+ return filterByYear(Date.UTC(year, month, day, 0, 0, 0), context)
+}
+
+function coverQuery(context, node) {
+ var coverage = parseFloat(node.coverage)
+ var usage = browserslist.usage.global
+ if (node.place) {
+ if (node.place.match(/^my\s+stats$/i)) {
+ if (!context.customUsage) {
+ throw new BrowserslistError('Custom usage statistics was not provided')
+ }
+ usage = context.customUsage
+ } else {
+ var place
+ if (node.place.length === 2) {
+ place = node.place.toUpperCase()
+ } else {
+ place = node.place.toLowerCase()
+ }
+ env.loadCountry(browserslist.usage, place, browserslist.data)
+ usage = browserslist.usage[place]
+ }
+ } else if (node.config) {
+ usage = loadCustomUsage(context, node.config)
+ }
+ var versions = Object.keys(usage).sort(function (a, b) {
+ return usage[b] - usage[a]
+ })
+ var covered = 0
+ var result = []
+ var version
+ for (var i = 0; i < versions.length; i++) {
+ version = versions[i]
+ if (usage[version] === 0) break
+ covered += usage[version]
+ result.push(version)
+ if (covered >= coverage) break
+ }
+ return result
+}
+
+var QUERIES = {
+ last_major_versions: {
+ matches: ['versions'],
+ regexp: /^last\s+(\d+)\s+major\s+versions?$/i,
+ select: function (context, node) {
+ return Object.keys(agents).reduce(function (selected, name) {
+ var data = byName(name, context)
+ if (!data) return selected
+ var list = getMajorVersions(data.released, node.versions)
+ list = list.map(nameMapper(data.name))
+ list = filterJumps(list, data.name, node.versions, context)
+ return selected.concat(list)
+ }, [])
+ }
+ },
+ last_versions: {
+ matches: ['versions'],
+ regexp: /^last\s+(\d+)\s+versions?$/i,
+ select: function (context, node) {
+ return Object.keys(agents).reduce(function (selected, name) {
+ var data = byName(name, context)
+ if (!data) return selected
+ var list = data.released.slice(-node.versions)
+ list = list.map(nameMapper(data.name))
+ list = filterJumps(list, data.name, node.versions, context)
+ return selected.concat(list)
+ }, [])
+ }
+ },
+ last_electron_major_versions: {
+ matches: ['versions'],
+ regexp: /^last\s+(\d+)\s+electron\s+major\s+versions?$/i,
+ select: function (context, node) {
+ var validVersions = getMajorVersions(Object.keys(e2c), node.versions)
+ return validVersions.map(function (i) {
+ return 'chrome ' + e2c[i]
+ })
+ }
+ },
+ last_node_major_versions: {
+ matches: ['versions'],
+ regexp: /^last\s+(\d+)\s+node\s+major\s+versions?$/i,
+ select: function (context, node) {
+ return getMajorVersions(browserslist.nodeVersions, node.versions).map(
+ function (version) {
+ return 'node ' + version
+ }
+ )
+ }
+ },
+ last_browser_major_versions: {
+ matches: ['versions', 'browser'],
+ regexp: /^last\s+(\d+)\s+(\w+)\s+major\s+versions?$/i,
+ select: function (context, node) {
+ var data = checkName(node.browser, context)
+ var validVersions = getMajorVersions(data.released, node.versions)
+ var list = validVersions.map(nameMapper(data.name))
+ list = filterJumps(list, data.name, node.versions, context)
+ return list
+ }
+ },
+ last_electron_versions: {
+ matches: ['versions'],
+ regexp: /^last\s+(\d+)\s+electron\s+versions?$/i,
+ select: function (context, node) {
+ return Object.keys(e2c)
+ .slice(-node.versions)
+ .map(function (i) {
+ return 'chrome ' + e2c[i]
+ })
+ }
+ },
+ last_node_versions: {
+ matches: ['versions'],
+ regexp: /^last\s+(\d+)\s+node\s+versions?$/i,
+ select: function (context, node) {
+ return browserslist.nodeVersions
+ .slice(-node.versions)
+ .map(function (version) {
+ return 'node ' + version
+ })
+ }
+ },
+ last_browser_versions: {
+ matches: ['versions', 'browser'],
+ regexp: /^last\s+(\d+)\s+(\w+)\s+versions?$/i,
+ select: function (context, node) {
+ var data = checkName(node.browser, context)
+ var list = data.released.slice(-node.versions).map(nameMapper(data.name))
+ list = filterJumps(list, data.name, node.versions, context)
+ return list
+ }
+ },
+ unreleased_versions: {
+ matches: [],
+ regexp: /^unreleased\s+versions$/i,
+ select: function (context) {
+ return Object.keys(agents).reduce(function (selected, name) {
+ var data = byName(name, context)
+ if (!data) return selected
+ var list = data.versions.filter(function (v) {
+ return data.released.indexOf(v) === -1
+ })
+ list = list.map(nameMapper(data.name))
+ return selected.concat(list)
+ }, [])
+ }
+ },
+ unreleased_electron_versions: {
+ matches: [],
+ regexp: /^unreleased\s+electron\s+versions?$/i,
+ select: function () {
+ return []
+ }
+ },
+ unreleased_browser_versions: {
+ matches: ['browser'],
+ regexp: /^unreleased\s+(\w+)\s+versions?$/i,
+ select: function (context, node) {
+ var data = checkName(node.browser, context)
+ return data.versions
+ .filter(function (v) {
+ return data.released.indexOf(v) === -1
+ })
+ .map(nameMapper(data.name))
+ }
+ },
+ last_years: {
+ matches: ['years'],
+ regexp: /^last\s+(\d*.?\d+)\s+years?$/i,
+ select: function (context, node) {
+ return filterByYear(Date.now() - YEAR * node.years, context)
+ }
+ },
+ since_y: {
+ matches: ['year'],
+ regexp: /^since (\d+)$/i,
+ select: sinceQuery
+ },
+ since_y_m: {
+ matches: ['year', 'month'],
+ regexp: /^since (\d+)-(\d+)$/i,
+ select: sinceQuery
+ },
+ since_y_m_d: {
+ matches: ['year', 'month', 'day'],
+ regexp: /^since (\d+)-(\d+)-(\d+)$/i,
+ select: sinceQuery
+ },
+ popularity: {
+ matches: ['sign', 'popularity'],
+ regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%$/,
+ select: function (context, node) {
+ var popularity = parseFloat(node.popularity)
+ var usage = browserslist.usage.global
+ return Object.keys(usage).reduce(function (result, version) {
+ if (node.sign === '>') {
+ if (usage[version] > popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<') {
+ if (usage[version] < popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<=') {
+ if (usage[version] <= popularity) {
+ result.push(version)
+ }
+ } else if (usage[version] >= popularity) {
+ result.push(version)
+ }
+ return result
+ }, [])
+ }
+ },
+ popularity_in_my_stats: {
+ matches: ['sign', 'popularity'],
+ regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+my\s+stats$/,
+ select: function (context, node) {
+ var popularity = parseFloat(node.popularity)
+ if (!context.customUsage) {
+ throw new BrowserslistError('Custom usage statistics was not provided')
+ }
+ var usage = context.customUsage
+ return Object.keys(usage).reduce(function (result, version) {
+ var percentage = usage[version]
+ if (percentage == null) {
+ return result
+ }
+
+ if (node.sign === '>') {
+ if (percentage > popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<') {
+ if (percentage < popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<=') {
+ if (percentage <= popularity) {
+ result.push(version)
+ }
+ } else if (percentage >= popularity) {
+ result.push(version)
+ }
+ return result
+ }, [])
+ }
+ },
+ popularity_in_config_stats: {
+ matches: ['sign', 'popularity', 'config'],
+ regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/,
+ select: function (context, node) {
+ var popularity = parseFloat(node.popularity)
+ var usage = loadCustomUsage(context, node.config)
+ return Object.keys(usage).reduce(function (result, version) {
+ var percentage = usage[version]
+ if (percentage == null) {
+ return result
+ }
+
+ if (node.sign === '>') {
+ if (percentage > popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<') {
+ if (percentage < popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<=') {
+ if (percentage <= popularity) {
+ result.push(version)
+ }
+ } else if (percentage >= popularity) {
+ result.push(version)
+ }
+ return result
+ }, [])
+ }
+ },
+ popularity_in_place: {
+ matches: ['sign', 'popularity', 'place'],
+ regexp: /^(>=?|<=?)\s*(\d+|\d+\.\d+|\.\d+)%\s+in\s+((alt-)?\w\w)$/,
+ select: function (context, node) {
+ var popularity = parseFloat(node.popularity)
+ var place = node.place
+ if (place.length === 2) {
+ place = place.toUpperCase()
+ } else {
+ place = place.toLowerCase()
+ }
+ env.loadCountry(browserslist.usage, place, browserslist.data)
+ var usage = browserslist.usage[place]
+ return Object.keys(usage).reduce(function (result, version) {
+ var percentage = usage[version]
+ if (percentage == null) {
+ return result
+ }
+
+ if (node.sign === '>') {
+ if (percentage > popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<') {
+ if (percentage < popularity) {
+ result.push(version)
+ }
+ } else if (node.sign === '<=') {
+ if (percentage <= popularity) {
+ result.push(version)
+ }
+ } else if (percentage >= popularity) {
+ result.push(version)
+ }
+ return result
+ }, [])
+ }
+ },
+ cover: {
+ matches: ['coverage'],
+ regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%$/i,
+ select: coverQuery
+ },
+ cover_in: {
+ matches: ['coverage', 'place'],
+ regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(my\s+stats|(alt-)?\w\w)$/i,
+ select: coverQuery
+ },
+ cover_config: {
+ matches: ['coverage', 'config'],
+ regexp: /^cover\s+(\d+|\d+\.\d+|\.\d+)%\s+in\s+(\S+)\s+stats$/i,
+ select: coverQuery
+ },
+ supports: {
+ matches: ['supportType', 'feature'],
+ regexp: /^(?:(fully|partially)\s+)?supports\s+([\w-]+)$/,
+ select: function (context, node) {
+ env.loadFeature(browserslist.cache, node.feature)
+ var withPartial = node.supportType !== 'fully'
+ var features = browserslist.cache[node.feature]
+ var result = []
+ for (var name in features) {
+ var data = byName(name, context)
+ // Only check desktop when latest released mobile has support
+ var iMax = data.released.length - 1
+ while (iMax >= 0) {
+ if (data.released[iMax] in features[name]) break
+ iMax--
+ }
+ var checkDesktop =
+ context.mobileToDesktop &&
+ name in browserslist.desktopNames &&
+ isSupported(features[name][data.released[iMax]], withPartial)
+ data.versions.forEach(function (version) {
+ var flags = features[name][version]
+ if (flags === undefined && checkDesktop) {
+ flags = features[browserslist.desktopNames[name]][version]
+ }
+ if (isSupported(flags, withPartial)) {
+ result.push(name + ' ' + version)
+ }
+ })
+ }
+ return result
+ }
+ },
+ electron_range: {
+ matches: ['from', 'to'],
+ regexp: /^electron\s+([\d.]+)\s*-\s*([\d.]+)$/i,
+ select: function (context, node) {
+ var fromToUse = normalizeElectron(node.from)
+ var toToUse = normalizeElectron(node.to)
+ var from = parseFloat(node.from)
+ var to = parseFloat(node.to)
+ if (!e2c[fromToUse]) {
+ throw new BrowserslistError('Unknown version ' + from + ' of electron')
+ }
+ if (!e2c[toToUse]) {
+ throw new BrowserslistError('Unknown version ' + to + ' of electron')
+ }
+ return Object.keys(e2c)
+ .filter(function (i) {
+ var parsed = parseFloat(i)
+ return parsed >= from && parsed <= to
+ })
+ .map(function (i) {
+ return 'chrome ' + e2c[i]
+ })
+ }
+ },
+ node_range: {
+ matches: ['from', 'to'],
+ regexp: /^node\s+([\d.]+)\s*-\s*([\d.]+)$/i,
+ select: function (context, node) {
+ return browserslist.nodeVersions
+ .filter(semverFilterLoose('>=', node.from))
+ .filter(semverFilterLoose('<=', node.to))
+ .map(function (v) {
+ return 'node ' + v
+ })
+ }
+ },
+ browser_range: {
+ matches: ['browser', 'from', 'to'],
+ regexp: /^(\w+)\s+([\d.]+)\s*-\s*([\d.]+)$/i,
+ select: function (context, node) {
+ var data = checkName(node.browser, context)
+ var from = parseFloat(normalizeVersion(data, node.from) || node.from)
+ var to = parseFloat(normalizeVersion(data, node.to) || node.to)
+ function filter(v) {
+ var parsed = parseFloat(v)
+ return parsed >= from && parsed <= to
+ }
+ return data.released.filter(filter).map(nameMapper(data.name))
+ }
+ },
+ electron_ray: {
+ matches: ['sign', 'version'],
+ regexp: /^electron\s*(>=?|<=?)\s*([\d.]+)$/i,
+ select: function (context, node) {
+ var versionToUse = normalizeElectron(node.version)
+ return Object.keys(e2c)
+ .filter(generateFilter(node.sign, versionToUse))
+ .map(function (i) {
+ return 'chrome ' + e2c[i]
+ })
+ }
+ },
+ node_ray: {
+ matches: ['sign', 'version'],
+ regexp: /^node\s*(>=?|<=?)\s*([\d.]+)$/i,
+ select: function (context, node) {
+ return browserslist.nodeVersions
+ .filter(generateSemverFilter(node.sign, node.version))
+ .map(function (v) {
+ return 'node ' + v
+ })
+ }
+ },
+ browser_ray: {
+ matches: ['browser', 'sign', 'version'],
+ regexp: /^(\w+)\s*(>=?|<=?)\s*([\d.]+)$/,
+ select: function (context, node) {
+ var version = node.version
+ var data = checkName(node.browser, context)
+ var alias = browserslist.versionAliases[data.name][version]
+ if (alias) version = alias
+ return data.released
+ .filter(generateFilter(node.sign, version))
+ .map(function (v) {
+ return data.name + ' ' + v
+ })
+ }
+ },
+ firefox_esr: {
+ matches: [],
+ regexp: /^(firefox|ff|fx)\s+esr$/i,
+ select: function () {
+ return ['firefox 128', 'firefox 140']
+ }
+ },
+ opera_mini_all: {
+ matches: [],
+ regexp: /(operamini|op_mini)\s+all/i,
+ select: function () {
+ return ['op_mini all']
+ }
+ },
+ electron_version: {
+ matches: ['version'],
+ regexp: /^electron\s+([\d.]+)$/i,
+ select: function (context, node) {
+ var versionToUse = normalizeElectron(node.version)
+ var chrome = e2c[versionToUse]
+ if (!chrome) {
+ throw new BrowserslistError(
+ 'Unknown version ' + node.version + ' of electron'
+ )
+ }
+ return ['chrome ' + chrome]
+ }
+ },
+ node_major_version: {
+ matches: ['version'],
+ regexp: /^node\s+(\d+)$/i,
+ select: nodeQuery
+ },
+ node_minor_version: {
+ matches: ['version'],
+ regexp: /^node\s+(\d+\.\d+)$/i,
+ select: nodeQuery
+ },
+ node_patch_version: {
+ matches: ['version'],
+ regexp: /^node\s+(\d+\.\d+\.\d+)$/i,
+ select: nodeQuery
+ },
+ current_node: {
+ matches: [],
+ regexp: /^current\s+node$/i,
+ select: function (context) {
+ return [env.currentNode(resolve, context)]
+ }
+ },
+ maintained_node: {
+ matches: [],
+ regexp: /^maintained\s+node\s+versions$/i,
+ select: function (context) {
+ var now = Date.now()
+ var queries = Object.keys(jsEOL)
+ .filter(function (key) {
+ return (
+ now < Date.parse(jsEOL[key].end) &&
+ now > Date.parse(jsEOL[key].start) &&
+ isEolReleased(key)
+ )
+ })
+ .map(function (key) {
+ return 'node ' + key.slice(1)
+ })
+ return resolve(queries, context)
+ }
+ },
+ phantomjs_1_9: {
+ matches: [],
+ regexp: /^phantomjs\s+1.9$/i,
+ select: function () {
+ return ['safari 5']
+ }
+ },
+ phantomjs_2_1: {
+ matches: [],
+ regexp: /^phantomjs\s+2.1$/i,
+ select: function () {
+ return ['safari 6']
+ }
+ },
+ browser_version: {
+ matches: ['browser', 'version'],
+ regexp: /^(\w+)\s+(tp|[\d.]+)$/i,
+ select: function (context, node) {
+ var version = node.version
+ if (/^tp$/i.test(version)) version = 'TP'
+ var data = checkName(node.browser, context)
+ var alias = normalizeVersion(data, version)
+ if (alias) {
+ version = alias
+ } else {
+ if (version.indexOf('.') === -1) {
+ alias = version + '.0'
+ } else {
+ alias = version.replace(/\.0$/, '')
+ }
+ alias = normalizeVersion(data, alias)
+ if (alias) {
+ version = alias
+ } else if (context.ignoreUnknownVersions) {
+ return []
+ } else {
+ throw new BrowserslistError(
+ 'Unknown version ' + version + ' of ' + node.browser
+ )
+ }
+ }
+ return [data.name + ' ' + version]
+ }
+ },
+ browserslist_config: {
+ matches: [],
+ regexp: /^browserslist config$/i,
+ needsPath: true,
+ select: function (context) {
+ return browserslist(undefined, context)
+ }
+ },
+ extends: {
+ matches: ['config'],
+ regexp: /^extends (.+)$/i,
+ needsPath: true,
+ select: function (context, node) {
+ return resolve(env.loadQueries(context, node.config), context)
+ }
+ },
+ defaults: {
+ matches: [],
+ regexp: /^defaults$/i,
+ select: function (context) {
+ return resolve(browserslist.defaults, context)
+ }
+ },
+ dead: {
+ matches: [],
+ regexp: /^dead$/i,
+ select: function (context) {
+ var dead = [
+ 'Baidu >= 0',
+ 'ie <= 11',
+ 'ie_mob <= 11',
+ 'bb <= 10',
+ 'op_mob <= 12.1',
+ 'samsung 4'
+ ]
+ return resolve(dead, context)
+ }
+ },
+ unknown: {
+ matches: [],
+ regexp: /^(\w+)$/i,
+ select: function (context, node) {
+ if (byName(node.query, context)) {
+ throw new BrowserslistError(
+ 'Specify versions in Browserslist query for browser ' + node.query
+ )
+ } else {
+ throw unknownQuery(node.query)
+ }
+ }
+ }
+}
+
+// Get and convert Can I Use data
+
+;(function () {
+ for (var name in agents) {
+ var browser = agents[name]
+ browserslist.data[name] = {
+ name: name,
+ versions: normalize(agents[name].versions),
+ released: normalize(agents[name].versions.slice(0, -3)),
+ releaseDate: agents[name].release_date
+ }
+ fillUsage(browserslist.usage.global, name, browser.usage_global)
+
+ browserslist.versionAliases[name] = {}
+ for (var i = 0; i < browser.versions.length; i++) {
+ var full = browser.versions[i]
+ if (!full) continue
+
+ if (full.indexOf('-') !== -1) {
+ var interval = full.split('-')
+ for (var j = 0; j < interval.length; j++) {
+ browserslist.versionAliases[name][interval[j]] = full
+ }
+ }
+ }
+ }
+
+ browserslist.nodeVersions = jsReleases.map(function (release) {
+ return release.version
+ })
+})()
+
+module.exports = browserslist
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/node.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/node.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e19444b01192916d198771d1be3ad26513c8760
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/node.js
@@ -0,0 +1,469 @@
+var feature = require('caniuse-lite/dist/unpacker/feature').default
+var region = require('caniuse-lite/dist/unpacker/region').default
+var fs = require('fs')
+var path = require('path')
+
+var BrowserslistError = require('./error')
+
+var IS_SECTION = /^\s*\[(.+)]\s*$/
+var CONFIG_PATTERN = /^browserslist-config-/
+var SCOPED_CONFIG__PATTERN = /@[^/]+(?:\/[^/]+)?\/browserslist-config(?:-|$|\/)/
+var FORMAT =
+ 'Browserslist config should be a string or an array ' +
+ 'of strings with browser queries'
+
+var dataTimeChecked = false
+var statCache = {}
+var configPathCache = {}
+var parseConfigCache = {}
+
+function checkExtend(name) {
+ var use = ' Use `dangerousExtend` option to disable.'
+ if (!CONFIG_PATTERN.test(name) && !SCOPED_CONFIG__PATTERN.test(name)) {
+ throw new BrowserslistError(
+ 'Browserslist config needs `browserslist-config-` prefix. ' + use
+ )
+ }
+ if (name.replace(/^@[^/]+\//, '').indexOf('.') !== -1) {
+ throw new BrowserslistError(
+ '`.` not allowed in Browserslist config name. ' + use
+ )
+ }
+ if (name.indexOf('node_modules') !== -1) {
+ throw new BrowserslistError(
+ '`node_modules` not allowed in Browserslist config.' + use
+ )
+ }
+}
+
+function isFile(file) {
+ return fs.existsSync(file) && fs.statSync(file).isFile()
+}
+function isDirectory(dir) {
+ return fs.existsSync(dir) && fs.statSync(dir).isDirectory()
+}
+
+function eachParent(file, callback, cache) {
+ var loc = path.resolve(file)
+ var pathsForCacheResult = []
+ var result
+ do {
+ if (!pathInRoot(loc)) {
+ break
+ }
+ if (cache && loc in cache) {
+ result = cache[loc]
+ break
+ }
+ pathsForCacheResult.push(loc)
+
+ if (!isDirectory(loc)) {
+ continue
+ }
+
+ var locResult = callback(loc)
+ if (typeof locResult !== 'undefined') {
+ result = locResult
+ break
+ }
+ } while (loc !== (loc = path.dirname(loc)))
+
+ if (cache && !process.env.BROWSERSLIST_DISABLE_CACHE) {
+ pathsForCacheResult.forEach(function (cachePath) {
+ cache[cachePath] = result
+ })
+ }
+ return result
+}
+
+function pathInRoot(p) {
+ if (!process.env.BROWSERSLIST_ROOT_PATH) return true
+ var rootPath = path.resolve(process.env.BROWSERSLIST_ROOT_PATH)
+ if (path.relative(rootPath, p).substring(0, 2) === '..') {
+ return false
+ }
+ return true
+}
+
+function check(section) {
+ if (Array.isArray(section)) {
+ for (var i = 0; i < section.length; i++) {
+ if (typeof section[i] !== 'string') {
+ throw new BrowserslistError(FORMAT)
+ }
+ }
+ } else if (typeof section !== 'string') {
+ throw new BrowserslistError(FORMAT)
+ }
+}
+
+function pickEnv(config, opts) {
+ if (typeof config !== 'object') return config
+
+ var name
+ if (typeof opts.env === 'string') {
+ name = opts.env
+ } else if (process.env.BROWSERSLIST_ENV) {
+ name = process.env.BROWSERSLIST_ENV
+ } else if (process.env.NODE_ENV) {
+ name = process.env.NODE_ENV
+ } else {
+ name = 'production'
+ }
+
+ if (opts.throwOnMissing) {
+ if (name && name !== 'defaults' && !config[name]) {
+ throw new BrowserslistError(
+ 'Missing config for Browserslist environment `' + name + '`'
+ )
+ }
+ }
+
+ return config[name] || config.defaults
+}
+
+function parsePackage(file) {
+ var text = fs
+ .readFileSync(file)
+ .toString()
+ .replace(/^\uFEFF/m, '')
+ var list
+ if (text.indexOf('"browserslist"') >= 0) {
+ list = JSON.parse(text).browserslist
+ } else if (text.indexOf('"browserlist"') >= 0) {
+ var config = JSON.parse(text)
+ if (config.browserlist && !config.browserslist) {
+ throw new BrowserslistError(
+ '`browserlist` key instead of `browserslist` in ' + file
+ )
+ }
+ }
+ if (Array.isArray(list) || typeof list === 'string') {
+ list = { defaults: list }
+ }
+ for (var i in list) {
+ check(list[i])
+ }
+
+ return list
+}
+
+function parsePackageOrReadConfig(file) {
+ if (file in parseConfigCache) {
+ return parseConfigCache[file]
+ }
+
+ var isPackage = path.basename(file) === 'package.json'
+ var result = isPackage ? parsePackage(file) : module.exports.readConfig(file)
+
+ if (!process.env.BROWSERSLIST_DISABLE_CACHE) {
+ parseConfigCache[file] = result
+ }
+ return result
+}
+
+function latestReleaseTime(agents) {
+ var latest = 0
+ for (var name in agents) {
+ var dates = agents[name].releaseDate || {}
+ for (var key in dates) {
+ if (latest < dates[key]) {
+ latest = dates[key]
+ }
+ }
+ }
+ return latest * 1000
+}
+
+function getMonthsPassed(date) {
+ var now = new Date()
+ var past = new Date(date)
+
+ var years = now.getFullYear() - past.getFullYear()
+ var months = now.getMonth() - past.getMonth()
+
+ return years * 12 + months
+}
+
+function normalizeStats(data, stats) {
+ if (!data) {
+ data = {}
+ }
+ if (stats && 'dataByBrowser' in stats) {
+ stats = stats.dataByBrowser
+ }
+
+ if (typeof stats !== 'object') return undefined
+
+ var normalized = {}
+ for (var i in stats) {
+ var versions = Object.keys(stats[i])
+ if (versions.length === 1 && data[i] && data[i].versions.length === 1) {
+ var normal = data[i].versions[0]
+ normalized[i] = {}
+ normalized[i][normal] = stats[i][versions[0]]
+ } else {
+ normalized[i] = stats[i]
+ }
+ }
+
+ return normalized
+}
+
+function normalizeUsageData(usageData, data) {
+ for (var browser in usageData) {
+ var browserUsage = usageData[browser]
+ // https://github.com/browserslist/browserslist/issues/431#issuecomment-565230615
+ // caniuse-db returns { 0: "percentage" } for `and_*` regional stats
+ if ('0' in browserUsage) {
+ var versions = data[browser].versions
+ browserUsage[versions[versions.length - 1]] = browserUsage[0]
+ delete browserUsage[0]
+ }
+ }
+}
+
+module.exports = {
+ loadQueries: function loadQueries(ctx, name) {
+ if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
+ checkExtend(name)
+ }
+ var queries = require(require.resolve(name, { paths: ['.', ctx.path] }))
+ if (typeof queries === 'object' && queries !== null && queries.__esModule) {
+ queries = queries.default
+ }
+ if (queries) {
+ if (Array.isArray(queries)) {
+ return queries
+ } else if (typeof queries === 'object') {
+ if (!queries.defaults) queries.defaults = []
+ return pickEnv(queries, ctx, name)
+ }
+ }
+ throw new BrowserslistError(
+ '`' +
+ name +
+ '` config exports not an array of queries' +
+ ' or an object of envs'
+ )
+ },
+
+ loadStat: function loadStat(ctx, name, data) {
+ if (!ctx.dangerousExtend && !process.env.BROWSERSLIST_DANGEROUS_EXTEND) {
+ checkExtend(name)
+ }
+ var stats = require(require.resolve(
+ path.join(name, 'browserslist-stats.json'),
+ { paths: ['.'] }
+ ))
+ return normalizeStats(data, stats)
+ },
+
+ getStat: function getStat(opts, data) {
+ var stats
+ if (opts.stats) {
+ stats = opts.stats
+ } else if (process.env.BROWSERSLIST_STATS) {
+ stats = process.env.BROWSERSLIST_STATS
+ } else if (opts.path && path.resolve && fs.existsSync) {
+ stats = eachParent(
+ opts.path,
+ function (dir) {
+ var file = path.join(dir, 'browserslist-stats.json')
+ return isFile(file) ? file : undefined
+ },
+ statCache
+ )
+ }
+ if (typeof stats === 'string') {
+ try {
+ stats = JSON.parse(fs.readFileSync(stats))
+ } catch (e) {
+ throw new BrowserslistError("Can't read " + stats)
+ }
+ }
+ return normalizeStats(data, stats)
+ },
+
+ loadConfig: function loadConfig(opts) {
+ if (process.env.BROWSERSLIST) {
+ return process.env.BROWSERSLIST
+ } else if (opts.config || process.env.BROWSERSLIST_CONFIG) {
+ var file = opts.config || process.env.BROWSERSLIST_CONFIG
+ return pickEnv(parsePackageOrReadConfig(file), opts)
+ } else if (opts.path) {
+ return pickEnv(module.exports.findConfig(opts.path), opts)
+ } else {
+ return undefined
+ }
+ },
+
+ loadCountry: function loadCountry(usage, country, data) {
+ var code = country.replace(/[^\w-]/g, '')
+ if (!usage[code]) {
+ var compressed
+ try {
+ compressed = require('caniuse-lite/data/regions/' + code + '.js')
+ } catch (e) {
+ throw new BrowserslistError('Unknown region name `' + code + '`.')
+ }
+ var usageData = region(compressed)
+ normalizeUsageData(usageData, data)
+ usage[country] = {}
+ for (var i in usageData) {
+ for (var j in usageData[i]) {
+ usage[country][i + ' ' + j] = usageData[i][j]
+ }
+ }
+ }
+ },
+
+ loadFeature: function loadFeature(features, name) {
+ name = name.replace(/[^\w-]/g, '')
+ if (features[name]) return
+ var compressed
+ try {
+ compressed = require('caniuse-lite/data/features/' + name + '.js')
+ } catch (e) {
+ throw new BrowserslistError('Unknown feature name `' + name + '`.')
+ }
+ var stats = feature(compressed).stats
+ features[name] = {}
+ for (var i in stats) {
+ features[name][i] = {}
+ for (var j in stats[i]) {
+ features[name][i][j] = stats[i][j]
+ }
+ }
+ },
+
+ parseConfig: function parseConfig(string) {
+ var result = { defaults: [] }
+ var sections = ['defaults']
+
+ string
+ .toString()
+ .replace(/#[^\n]*/g, '')
+ .split(/\n|,/)
+ .map(function (line) {
+ return line.trim()
+ })
+ .filter(function (line) {
+ return line !== ''
+ })
+ .forEach(function (line) {
+ if (IS_SECTION.test(line)) {
+ sections = line.match(IS_SECTION)[1].trim().split(' ')
+ sections.forEach(function (section) {
+ if (result[section]) {
+ throw new BrowserslistError(
+ 'Duplicate section ' + section + ' in Browserslist config'
+ )
+ }
+ result[section] = []
+ })
+ } else {
+ sections.forEach(function (section) {
+ result[section].push(line)
+ })
+ }
+ })
+
+ return result
+ },
+
+ readConfig: function readConfig(file) {
+ if (!isFile(file)) {
+ throw new BrowserslistError("Can't read " + file + ' config')
+ }
+
+ return module.exports.parseConfig(fs.readFileSync(file))
+ },
+
+ findConfigFile: function findConfigFile(from) {
+ return eachParent(
+ from,
+ function (dir) {
+ var config = path.join(dir, 'browserslist')
+ var pkg = path.join(dir, 'package.json')
+ var rc = path.join(dir, '.browserslistrc')
+
+ var pkgBrowserslist
+ if (isFile(pkg)) {
+ try {
+ pkgBrowserslist = parsePackage(pkg)
+ } catch (e) {
+ if (e.name === 'BrowserslistError') throw e
+ console.warn(
+ '[Browserslist] Could not parse ' + pkg + '. Ignoring it.'
+ )
+ }
+ }
+
+ if (isFile(config) && pkgBrowserslist) {
+ throw new BrowserslistError(
+ dir + ' contains both browserslist and package.json with browsers'
+ )
+ } else if (isFile(rc) && pkgBrowserslist) {
+ throw new BrowserslistError(
+ dir +
+ ' contains both .browserslistrc and package.json with browsers'
+ )
+ } else if (isFile(config) && isFile(rc)) {
+ throw new BrowserslistError(
+ dir + ' contains both .browserslistrc and browserslist'
+ )
+ } else if (isFile(config)) {
+ return config
+ } else if (isFile(rc)) {
+ return rc
+ } else if (pkgBrowserslist) {
+ return pkg
+ }
+ },
+ configPathCache
+ )
+ },
+
+ findConfig: function findConfig(from) {
+ var configFile = this.findConfigFile(from)
+
+ return configFile ? parsePackageOrReadConfig(configFile) : undefined
+ },
+
+ clearCaches: function clearCaches() {
+ dataTimeChecked = false
+ statCache = {}
+ configPathCache = {}
+ parseConfigCache = {}
+
+ this.cache = {}
+ },
+
+ oldDataWarning: function oldDataWarning(agentsObj) {
+ if (dataTimeChecked) return
+ dataTimeChecked = true
+ if (process.env.BROWSERSLIST_IGNORE_OLD_DATA) return
+
+ var latest = latestReleaseTime(agentsObj)
+ var monthsPassed = getMonthsPassed(latest)
+
+ if (latest !== 0 && monthsPassed >= 6) {
+ var months = monthsPassed + ' ' + (monthsPassed > 1 ? 'months' : 'month')
+ console.warn(
+ 'Browserslist: browsers data (caniuse-lite) is ' +
+ months +
+ ' old. Please run:\n' +
+ ' npx update-browserslist-db@latest\n' +
+ ' Why you should do it regularly: ' +
+ 'https://github.com/browserslist/update-db#readme'
+ )
+ }
+ },
+
+ currentNode: function currentNode() {
+ return 'node ' + process.versions.node
+ },
+
+ env: process.env
+}
diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/package.json b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..081010ab71d5724774b0bcade6999ec649a09585
--- /dev/null
+++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/browserslist/package.json
@@ -0,0 +1,44 @@
+{
+ "name": "browserslist",
+ "version": "4.25.1",
+ "description": "Share target browsers between different front-end tools, like Autoprefixer, Stylelint and babel-env-preset",
+ "keywords": [
+ "caniuse",
+ "browsers",
+ "target"
+ ],
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/browserslist"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/browserslist"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "author": "Andrey Sitnik
+
+
+
+ 
+
+
+
+
+
+> Terminal string styling done right
+
+[](https://travis-ci.org/chalk/chalk) [](https://coveralls.io/github/chalk/chalk?branch=master) [](https://www.npmjs.com/package/chalk?activeTab=dependents) [](https://www.npmjs.com/package/chalk) [](https://www.youtube.com/watch?v=9auOCbH5Ns4) [](https://github.com/xojs/xo)  [](https://repl.it/github/chalk/chalk)
+
+
+
++ +--- + +
+
+
+ +
+
+
+
+ +
+
+
+
+ +
+ +
+
+---
+
++
+ + Sindre Sorhus' open source work is supported by the community on GitHub Sponsors and Dev + +
+ Special thanks to: ++
+ +
+
+ +
+ +
+
+ +
+ +
+ 
+
+ All your environment variables, in one place
+
+
+ Stop struggling with scattered API keys, hacking together home-brewed tools,
+
+ and avoiding access controls. Keep your team and servers in sync with Doppler. +
+
+ + and avoiding access controls. Keep your team and servers in sync with Doppler. +
+ +
+ 
+
+
+
+
+ + +## Highlights + +- Expressive API +- Highly performant +- Ability to nest styles +- [256/Truecolor color support](#256-and-truecolor-color-support) +- Auto-detects color support +- Doesn't extend `String.prototype` +- Clean and focused +- Actively maintained +- [Used by ~50,000 packages](https://www.npmjs.com/browse/depended/chalk) as of January 1, 2020 + +## Install + +```console +$ npm install chalk +``` + +## Usage + +```js +const chalk = require('chalk'); + +console.log(chalk.blue('Hello world!')); +``` + +Chalk comes with an easy to use composable API where you just chain and nest the styles you want. + +```js +const chalk = require('chalk'); +const log = console.log; + +// Combine styled and normal strings +log(chalk.blue('Hello') + ' World' + chalk.red('!')); + +// Compose multiple styles using the chainable API +log(chalk.blue.bgRed.bold('Hello world!')); + +// Pass in multiple arguments +log(chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz')); + +// Nest styles +log(chalk.red('Hello', chalk.underline.bgBlue('world') + '!')); + +// Nest styles of the same type even (color, underline, background) +log(chalk.green( + 'I am a green line ' + + chalk.blue.underline.bold('with a blue substring') + + ' that becomes green again!' +)); + +// ES2015 template literal +log(` +CPU: ${chalk.red('90%')} +RAM: ${chalk.green('40%')} +DISK: ${chalk.yellow('70%')} +`); + +// ES2015 tagged template literal +log(chalk` +CPU: {red ${cpu.totalPercent}%} +RAM: {green ${ram.used / ram.total * 100}%} +DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%} +`); + +// Use RGB colors in terminal emulators that support it. +log(chalk.keyword('orange')('Yay for orange colored text!')); +log(chalk.rgb(123, 45, 67).underline('Underlined reddish color')); +log(chalk.hex('#DEADED').bold('Bold gray!')); +``` + +Easily define your own themes: + +```js +const chalk = require('chalk'); + +const error = chalk.bold.red; +const warning = chalk.keyword('orange'); + +console.log(error('Error!')); +console.log(warning('Warning!')); +``` + +Take advantage of console.log [string substitution](https://nodejs.org/docs/latest/api/console.html#console_console_log_data_args): + +```js +const name = 'Sindre'; +console.log(chalk.green('Hello %s'), name); +//=> 'Hello Sindre' +``` + +## API + +### chalk.`