+Default: `false` *(Matches any ANSI escape codes in a string)* + +Match only the first ANSI escape. + + +## FAQ + +### Why do you test for codes not in the ECMA 48 standard? + +Some of the codes we run as a test are codes that we acquired finding various lists of non-standard or manufacturer specific codes. We test for both standard and non-standard codes, as most of them follow the same or similar format and can be safely matched in strings without the risk of removing actual string content. There are a few non-standard control codes that do not follow the traditional format (i.e. they end in numbers) thus forcing us to exclude them from the test because we cannot reliably match them. + +On the historical side, those ECMA standards were established in the early 90's whereas the VT100, for example, was designed in the mid/late 70's. At that point in time, control codes were still pretty ungoverned and engineers used them for a multitude of things, namely to activate hardware ports that may have been proprietary. Somewhere else you see a similar 'anarchy' of codes is in the x86 architecture for processors; there are a ton of "interrupts" that can mean different things on certain brands of processors, most of which have been phased out. + + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + + +--- + +
+
+ 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/node_modules/argparse/CHANGELOG.md b/node_modules/argparse/CHANGELOG.md
new file mode 100644
index 0000000..dc39ed6
--- /dev/null
+++ b/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/node_modules/argparse/LICENSE b/node_modules/argparse/LICENSE
new file mode 100644
index 0000000..66a3ac8
--- /dev/null
+++ b/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/node_modules/argparse/README.md b/node_modules/argparse/README.md
new file mode 100644
index 0000000..550b5c9
--- /dev/null
+++ b/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/node_modules/argparse/argparse.js b/node_modules/argparse/argparse.js
new file mode 100644
index 0000000..2b8c8c6
--- /dev/null
+++ b/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/node_modules/argparse/lib/sub.js b/node_modules/argparse/lib/sub.js
new file mode 100644
index 0000000..e3eb321
--- /dev/null
+++ b/node_modules/argparse/lib/sub.js
@@ -0,0 +1,67 @@
+// Limited implementation of python % string operator, supports only %s and %r for now
+// (other formats are not used here, but may appear in custom templates)
+
+'use strict'
+
+const { inspect } = require('util')
+
+
+module.exports = function sub(pattern, ...values) {
+ let regex = /%(?:(%)|(-)?(\*)?(?:\((\w+)\))?([A-Za-z]))/g
+
+ let result = pattern.replace(regex, function (_, is_literal, is_left_align, is_padded, name, format) {
+ if (is_literal) return '%'
+
+ let padded_count = 0
+ if (is_padded) {
+ if (values.length === 0) throw new TypeError('not enough arguments for format string')
+ padded_count = values.shift()
+ if (!Number.isInteger(padded_count)) throw new TypeError('* wants int')
+ }
+
+ let str
+ if (name !== undefined) {
+ let dict = values[0]
+ if (typeof dict !== 'object' || dict === null) throw new TypeError('format requires a mapping')
+ if (!(name in dict)) throw new TypeError(`no such key: '${name}'`)
+ str = dict[name]
+ } else {
+ if (values.length === 0) throw new TypeError('not enough arguments for format string')
+ str = values.shift()
+ }
+
+ switch (format) {
+ case 's':
+ str = String(str)
+ break
+ case 'r':
+ str = inspect(str)
+ break
+ case 'd':
+ case 'i':
+ if (typeof str !== 'number') {
+ throw new TypeError(`%${format} format: a number is required, not ${typeof str}`)
+ }
+ str = String(str.toFixed(0))
+ break
+ default:
+ throw new TypeError(`unsupported format character '${format}'`)
+ }
+
+ if (padded_count > 0) {
+ return is_left_align ? str.padEnd(padded_count) : str.padStart(padded_count)
+ } else {
+ return str
+ }
+ })
+
+ if (values.length) {
+ if (values.length === 1 && typeof values[0] === 'object' && values[0] !== null) {
+ // mapping
+ } else {
+ throw new TypeError('not all arguments converted during string formatting')
+ }
+ }
+
+ return result
+}
diff --git a/node_modules/argparse/lib/textwrap.js b/node_modules/argparse/lib/textwrap.js
new file mode 100644
index 0000000..23d51cd
--- /dev/null
+++ b/node_modules/argparse/lib/textwrap.js
@@ -0,0 +1,440 @@
+// Partial port of python's argparse module, version 3.9.0 (only wrap and fill functions):
+// https://github.com/python/cpython/blob/v3.9.0b4/Lib/textwrap.py
+
+'use strict'
+
+/*
+ * Text wrapping and filling.
+ */
+
+// Copyright (C) 1999-2001 Gregory P. Ward.
+// Copyright (C) 2002, 2003 Python Software Foundation.
+// Copyright (C) 2020 argparse.js authors
+// Originally written by Greg Ward + + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
+
+## Layout DSL
+
+cliui exposes a simple layout DSL:
+
+If you create a single `ui.div`, passing a string rather than an
+object:
+
+* `\n`: characters will be interpreted as new rows.
+* `\t`: characters will be interpreted as new columns.
+* `\s`: characters will be interpreted as padding.
+
+**as an example...**
+
+```js
+var ui = require('./')({
+ width: 60
+})
+
+ui.div(
+ 'Usage: node ./bin/foo.js\n' +
+ ' +> Example: `unicornRainbow` → `unicorn_rainbow` + +## Install + +``` +$ npm install decamelize +``` + +## Usage + +```js +const decamelize = require('decamelize'); + +decamelize('unicornRainbow'); +//=> 'unicorn_rainbow' + +decamelize('unicornRainbow', '-'); +//=> 'unicorn-rainbow' +``` + +## API + +### decamelize(input, separator?) + +#### input + +Type: `string` + +#### separator + +Type: `string`\ +Default: `'_'` + +## Related + +See [`camelcase`](https://github.com/sindresorhus/camelcase) for the inverse. + +--- + +
+
+ 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/node_modules/diff/CONTRIBUTING.md b/node_modules/diff/CONTRIBUTING.md
new file mode 100644
index 0000000..c8c4fe6
--- /dev/null
+++ b/node_modules/diff/CONTRIBUTING.md
@@ -0,0 +1,39 @@
+# How to Contribute
+
+## Pull Requests
+
+We also accept [pull requests][pull-request]!
+
+Generally we like to see pull requests that
+
+- Maintain the existing code style
+- Are focused on a single change (i.e. avoid large refactoring or style adjustments in untouched code if not the primary goal of the pull request)
+- Have [good commit messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)
+- Have tests
+- Don't decrease the current code coverage (see coverage/lcov-report/index.html)
+
+## Building
+
+```
+npm install
+npm test
+```
+
+The `npm test -- dev` implements watching for tests within Node and `karma start` may be used for manual testing in browsers.
+
+If you notice any problems, please report them to the GitHub issue tracker at
+[http://github.com/kpdecker/jsdiff/issues](http://github.com/kpdecker/jsdiff/issues).
+
+## Releasing
+
+JsDiff utilizes the [release yeoman generator][generator-release] to perform most release tasks.
+
+A full release may be completed with the following:
+
+```
+yo release
+npm publish
+```
+
+[generator-release]: https://github.com/walmartlabs/generator-release
+[pull-request]: https://github.com/kpdecker/jsdiff/pull/new/master
diff --git a/node_modules/diff/LICENSE b/node_modules/diff/LICENSE
new file mode 100644
index 0000000..4e7146e
--- /dev/null
+++ b/node_modules/diff/LICENSE
@@ -0,0 +1,31 @@
+Software License Agreement (BSD License)
+
+Copyright (c) 2009-2015, Kevin Decker + + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
+
+Basic example in a web page
+
+```html
+
+
+
+```
+
+Open the above .html file in a browser and you should see
+
+
+
+**[Full online demo](http://kpdecker.github.com/jsdiff)**
+
+## Compatibility
+
+[](https://saucelabs.com/u/jsdiff)
+
+jsdiff supports all ES3 environments with some known issues on IE8 and below. Under these browsers some diff algorithms such as word diff and others may fail due to lack of support for capturing groups in the `split` operation.
+
+## License
+
+See [LICENSE](https://github.com/kpdecker/jsdiff/blob/master/LICENSE).
diff --git a/node_modules/diff/dist/diff.js b/node_modules/diff/dist/diff.js
new file mode 100644
index 0000000..bba9195
--- /dev/null
+++ b/node_modules/diff/dist/diff.js
@@ -0,0 +1,1582 @@
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (global = global || self, factory(global.Diff = {}));
+}(this, (function (exports) { 'use strict';
+
+ function Diff() {}
+ Diff.prototype = {
+ diff: function diff(oldString, newString) {
+ var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+ var callback = options.callback;
+
+ if (typeof options === 'function') {
+ callback = options;
+ options = {};
+ }
+
+ this.options = options;
+ var self = this;
+
+ function done(value) {
+ if (callback) {
+ setTimeout(function () {
+ callback(undefined, value);
+ }, 0);
+ return true;
+ } else {
+ return value;
+ }
+ } // Allow subclasses to massage the input prior to running
+
+
+ oldString = this.castInput(oldString);
+ newString = this.castInput(newString);
+ oldString = this.removeEmpty(this.tokenize(oldString));
+ newString = this.removeEmpty(this.tokenize(newString));
+ var newLen = newString.length,
+ oldLen = oldString.length;
+ var editLength = 1;
+ var maxEditLength = newLen + oldLen;
+ var bestPath = [{
+ newPos: -1,
+ components: []
+ }]; // Seed editLength = 0, i.e. the content starts with the same values
+
+ var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
+
+ if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {
+ // Identity per the equality and tokenizer
+ return done([{
+ value: this.join(newString),
+ count: newString.length
+ }]);
+ } // Main worker method. checks all permutations of a given edit length for acceptance.
+
+
+ function execEditLength() {
+ for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {
+ var basePath = void 0;
+
+ var addPath = bestPath[diagonalPath - 1],
+ removePath = bestPath[diagonalPath + 1],
+ _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
+
+ if (addPath) {
+ // No one else is going to attempt to use this value, clear it
+ bestPath[diagonalPath - 1] = undefined;
+ }
+
+ var canAdd = addPath && addPath.newPos + 1 < newLen,
+ canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen;
+
+ if (!canAdd && !canRemove) {
+ // If this path is a terminal then prune
+ bestPath[diagonalPath] = undefined;
+ continue;
+ } // Select the diagonal that we want to branch from. We select the prior
+ // path whose position in the new string is the farthest from the origin
+ // and does not pass the bounds of the diff graph
+
+
+ if (!canAdd || canRemove && addPath.newPos < removePath.newPos) {
+ basePath = clonePath(removePath);
+ self.pushComponent(basePath.components, undefined, true);
+ } else {
+ basePath = addPath; // No need to clone, we've pulled it from the list
+
+ basePath.newPos++;
+ self.pushComponent(basePath.components, true, undefined);
+ }
+
+ _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); // If we have hit the end of both strings, then we are done
+
+ if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) {
+ return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));
+ } else {
+ // Otherwise track this path as a potential candidate and continue.
+ bestPath[diagonalPath] = basePath;
+ }
+ }
+
+ editLength++;
+ } // Performs the length of edit iteration. Is a bit fugly as this has to support the
+ // sync and async mode which is never fun. Loops over execEditLength until a value
+ // is produced.
+
+
+ if (callback) {
+ (function exec() {
+ setTimeout(function () {
+ // This should not happen, but we want to be safe.
+
+ /* istanbul ignore next */
+ if (editLength > maxEditLength) {
+ return callback();
+ }
+
+ if (!execEditLength()) {
+ exec();
+ }
+ }, 0);
+ })();
+ } else {
+ while (editLength <= maxEditLength) {
+ var ret = execEditLength();
+
+ if (ret) {
+ return ret;
+ }
+ }
+ }
+ },
+ pushComponent: function pushComponent(components, added, removed) {
+ var last = components[components.length - 1];
+
+ if (last && last.added === added && last.removed === removed) {
+ // We need to clone here as the component clone operation is just
+ // as shallow array clone
+ components[components.length - 1] = {
+ count: last.count + 1,
+ added: added,
+ removed: removed
+ };
+ } else {
+ components.push({
+ count: 1,
+ added: added,
+ removed: removed
+ });
+ }
+ },
+ extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) {
+ var newLen = newString.length,
+ oldLen = oldString.length,
+ newPos = basePath.newPos,
+ oldPos = newPos - diagonalPath,
+ commonCount = 0;
+
+ while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {
+ newPos++;
+ oldPos++;
+ commonCount++;
+ }
+
+ if (commonCount) {
+ basePath.components.push({
+ count: commonCount
+ });
+ }
+
+ basePath.newPos = newPos;
+ return oldPos;
+ },
+ equals: function equals(left, right) {
+ if (this.options.comparator) {
+ return this.options.comparator(left, right);
+ } else {
+ return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+ }
+ },
+ removeEmpty: function removeEmpty(array) {
+ var ret = [];
+
+ for (var i = 0; i < array.length; i++) {
+ if (array[i]) {
+ ret.push(array[i]);
+ }
+ }
+
+ return ret;
+ },
+ castInput: function castInput(value) {
+ return value;
+ },
+ tokenize: function tokenize(value) {
+ return value.split('');
+ },
+ join: function join(chars) {
+ return chars.join('');
+ }
+ };
+
+ function buildValues(diff, components, newString, oldString, useLongestToken) {
+ var componentPos = 0,
+ componentLen = components.length,
+ newPos = 0,
+ oldPos = 0;
+
+ for (; componentPos < componentLen; componentPos++) {
+ var component = components[componentPos];
+
+ if (!component.removed) {
+ if (!component.added && useLongestToken) {
+ var value = newString.slice(newPos, newPos + component.count);
+ value = value.map(function (value, i) {
+ var oldValue = oldString[oldPos + i];
+ return oldValue.length > value.length ? oldValue : value;
+ });
+ component.value = diff.join(value);
+ } else {
+ component.value = diff.join(newString.slice(newPos, newPos + component.count));
+ }
+
+ newPos += component.count; // Common case
+
+ if (!component.added) {
+ oldPos += component.count;
+ }
+ } else {
+ component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));
+ oldPos += component.count; // Reverse add and remove so removes are output first to match common convention
+ // The diffing algorithm is tied to add then remove output and this is the simplest
+ // route to get the desired output with minimal overhead.
+
+ if (componentPos && components[componentPos - 1].added) {
+ var tmp = components[componentPos - 1];
+ components[componentPos - 1] = components[componentPos];
+ components[componentPos] = tmp;
+ }
+ }
+ } // Special case handle for when one terminal is ignored (i.e. whitespace).
+ // For this case we merge the terminal into the prior string and drop the change.
+ // This is only available for string mode.
+
+
+ var lastComponent = components[componentLen - 1];
+
+ if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) {
+ components[componentLen - 2].value += lastComponent.value;
+ components.pop();
+ }
+
+ return components;
+ }
+
+ function clonePath(path) {
+ return {
+ newPos: path.newPos,
+ components: path.components.slice(0)
+ };
+ }
+
+ var characterDiff = new Diff();
+ function diffChars(oldStr, newStr, options) {
+ return characterDiff.diff(oldStr, newStr, options);
+ }
+
+ function generateOptions(options, defaults) {
+ if (typeof options === 'function') {
+ defaults.callback = options;
+ } else if (options) {
+ for (var name in options) {
+ /* istanbul ignore else */
+ if (options.hasOwnProperty(name)) {
+ defaults[name] = options[name];
+ }
+ }
+ }
+
+ return defaults;
+ }
+
+ //
+ // Ranges and exceptions:
+ // Latin-1 Supplement, 0080–00FF
+ // - U+00D7 × Multiplication sign
+ // - U+00F7 ÷ Division sign
+ // Latin Extended-A, 0100–017F
+ // Latin Extended-B, 0180–024F
+ // IPA Extensions, 0250–02AF
+ // Spacing Modifier Letters, 02B0–02FF
+ // - U+02C7 ˇ ˇ Caron
+ // - U+02D8 ˘ ˘ Breve
+ // - U+02D9 ˙ ˙ Dot Above
+ // - U+02DA ˚ ˚ Ring Above
+ // - U+02DB ˛ ˛ Ogonek
+ // - U+02DC ˜ ˜ Small Tilde
+ // - U+02DD ˝ ˝ Double Acute Accent
+ // Latin Extended Additional, 1E00–1EFF
+
+ var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/;
+ var reWhitespace = /\S/;
+ var wordDiff = new Diff();
+
+ wordDiff.equals = function (left, right) {
+ if (this.options.ignoreCase) {
+ left = left.toLowerCase();
+ right = right.toLowerCase();
+ }
+
+ return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right);
+ };
+
+ wordDiff.tokenize = function (value) {
+ // All whitespace symbols except newline group into one token, each newline - in separate token
+ var tokens = value.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/); // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set.
+
+ for (var i = 0; i < tokens.length - 1; i++) {
+ // If we have an empty string in the next field and we have only word chars before and after, merge
+ if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) {
+ tokens[i] += tokens[i + 2];
+ tokens.splice(i + 1, 2);
+ i--;
+ }
+ }
+
+ return tokens;
+ };
+
+ function diffWords(oldStr, newStr, options) {
+ options = generateOptions(options, {
+ ignoreWhitespace: true
+ });
+ return wordDiff.diff(oldStr, newStr, options);
+ }
+ function diffWordsWithSpace(oldStr, newStr, options) {
+ return wordDiff.diff(oldStr, newStr, options);
+ }
+
+ var lineDiff = new Diff();
+
+ lineDiff.tokenize = function (value) {
+ var retLines = [],
+ linesAndNewlines = value.split(/(\n|\r\n)/); // Ignore the final empty token that occurs if the string ends with a new line
+
+ if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+ linesAndNewlines.pop();
+ } // Merge the content and line separators into single tokens
+
+
+ for (var i = 0; i < linesAndNewlines.length; i++) {
+ var line = linesAndNewlines[i];
+
+ if (i % 2 && !this.options.newlineIsToken) {
+ retLines[retLines.length - 1] += line;
+ } else {
+ if (this.options.ignoreWhitespace) {
+ line = line.trim();
+ }
+
+ retLines.push(line);
+ }
+ }
+
+ return retLines;
+ };
+
+ function diffLines(oldStr, newStr, callback) {
+ return lineDiff.diff(oldStr, newStr, callback);
+ }
+ function diffTrimmedLines(oldStr, newStr, callback) {
+ var options = generateOptions(callback, {
+ ignoreWhitespace: true
+ });
+ return lineDiff.diff(oldStr, newStr, options);
+ }
+
+ var sentenceDiff = new Diff();
+
+ sentenceDiff.tokenize = function (value) {
+ return value.split(/(\S.+?[.!?])(?=\s+|$)/);
+ };
+
+ function diffSentences(oldStr, newStr, callback) {
+ return sentenceDiff.diff(oldStr, newStr, callback);
+ }
+
+ var cssDiff = new Diff();
+
+ cssDiff.tokenize = function (value) {
+ return value.split(/([{}:;,]|\s+)/);
+ };
+
+ function diffCss(oldStr, newStr, callback) {
+ return cssDiff.diff(oldStr, newStr, callback);
+ }
+
+ function _typeof(obj) {
+ "@babel/helpers - typeof";
+
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+ _typeof = function (obj) {
+ return typeof obj;
+ };
+ } else {
+ _typeof = function (obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+ };
+ }
+
+ return _typeof(obj);
+ }
+
+ function _toConsumableArray(arr) {
+ return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+ }
+
+ function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+ }
+
+ function _iterableToArray(iter) {
+ if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+ }
+
+ function _unsupportedIterableToArray(o, minLen) {
+ if (!o) return;
+ if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+ var n = Object.prototype.toString.call(o).slice(8, -1);
+ if (n === "Object" && o.constructor) n = o.constructor.name;
+ if (n === "Map" || n === "Set") return Array.from(o);
+ if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+ }
+
+ function _arrayLikeToArray(arr, len) {
+ if (len == null || len > arr.length) len = arr.length;
+
+ for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+ return arr2;
+ }
+
+ function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+ }
+
+ var objectPrototypeToString = Object.prototype.toString;
+ var jsonDiff = new Diff(); // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
+ // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
+
+ jsonDiff.useLongestToken = true;
+ jsonDiff.tokenize = lineDiff.tokenize;
+
+ jsonDiff.castInput = function (value) {
+ var _this$options = this.options,
+ undefinedReplacement = _this$options.undefinedReplacement,
+ _this$options$stringi = _this$options.stringifyReplacer,
+ stringifyReplacer = _this$options$stringi === void 0 ? function (k, v) {
+ return typeof v === 'undefined' ? undefinedReplacement : v;
+ } : _this$options$stringi;
+ return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, ' ');
+ };
+
+ jsonDiff.equals = function (left, right) {
+ return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'));
+ };
+
+ function diffJson(oldObj, newObj, options) {
+ return jsonDiff.diff(oldObj, newObj, options);
+ } // This function handles the presence of circular references by bailing out when encountering an
+ // object that is already on the "stack" of items being processed. Accepts an optional replacer
+
+ function canonicalize(obj, stack, replacementStack, replacer, key) {
+ stack = stack || [];
+ replacementStack = replacementStack || [];
+
+ if (replacer) {
+ obj = replacer(key, obj);
+ }
+
+ var i;
+
+ for (i = 0; i < stack.length; i += 1) {
+ if (stack[i] === obj) {
+ return replacementStack[i];
+ }
+ }
+
+ var canonicalizedObj;
+
+ if ('[object Array]' === objectPrototypeToString.call(obj)) {
+ stack.push(obj);
+ canonicalizedObj = new Array(obj.length);
+ replacementStack.push(canonicalizedObj);
+
+ for (i = 0; i < obj.length; i += 1) {
+ canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key);
+ }
+
+ stack.pop();
+ replacementStack.pop();
+ return canonicalizedObj;
+ }
+
+ if (obj && obj.toJSON) {
+ obj = obj.toJSON();
+ }
+
+ if (_typeof(obj) === 'object' && obj !== null) {
+ stack.push(obj);
+ canonicalizedObj = {};
+ replacementStack.push(canonicalizedObj);
+
+ var sortedKeys = [],
+ _key;
+
+ for (_key in obj) {
+ /* istanbul ignore else */
+ if (obj.hasOwnProperty(_key)) {
+ sortedKeys.push(_key);
+ }
+ }
+
+ sortedKeys.sort();
+
+ for (i = 0; i < sortedKeys.length; i += 1) {
+ _key = sortedKeys[i];
+ canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key);
+ }
+
+ stack.pop();
+ replacementStack.pop();
+ } else {
+ canonicalizedObj = obj;
+ }
+
+ return canonicalizedObj;
+ }
+
+ var arrayDiff = new Diff();
+
+ arrayDiff.tokenize = function (value) {
+ return value.slice();
+ };
+
+ arrayDiff.join = arrayDiff.removeEmpty = function (value) {
+ return value;
+ };
+
+ function diffArrays(oldArr, newArr, callback) {
+ return arrayDiff.diff(oldArr, newArr, callback);
+ }
+
+ function parsePatch(uniDiff) {
+ var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+ var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/),
+ delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [],
+ list = [],
+ i = 0;
+
+ function parseIndex() {
+ var index = {};
+ list.push(index); // Parse diff metadata
+
+ while (i < diffstr.length) {
+ var line = diffstr[i]; // File header found, end parsing diff metadata
+
+ if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) {
+ break;
+ } // Diff index
+
+
+ var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line);
+
+ if (header) {
+ index.index = header[1];
+ }
+
+ i++;
+ } // Parse file headers if they are defined. Unified diff requires them, but
+ // there's no technical issues to have an isolated hunk without file header
+
+
+ parseFileHeader(index);
+ parseFileHeader(index); // Parse hunks
+
+ index.hunks = [];
+
+ while (i < diffstr.length) {
+ var _line = diffstr[i];
+
+ if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) {
+ break;
+ } else if (/^@@/.test(_line)) {
+ index.hunks.push(parseHunk());
+ } else if (_line && options.strict) {
+ // Ignore unexpected content unless in strict mode
+ throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line));
+ } else {
+ i++;
+ }
+ }
+ } // Parses the --- and +++ headers, if none are found, no lines
+ // are consumed.
+
+
+ function parseFileHeader(index) {
+ var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]);
+
+ if (fileHeader) {
+ var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';
+ var data = fileHeader[2].split('\t', 2);
+ var fileName = data[0].replace(/\\\\/g, '\\');
+
+ if (/^".*"$/.test(fileName)) {
+ fileName = fileName.substr(1, fileName.length - 2);
+ }
+
+ index[keyPrefix + 'FileName'] = fileName;
+ index[keyPrefix + 'Header'] = (data[1] || '').trim();
+ i++;
+ }
+ } // Parses a hunk
+ // This assumes that we are at the start of a hunk.
+
+
+ function parseHunk() {
+ var chunkHeaderIndex = i,
+ chunkHeaderLine = diffstr[i++],
+ chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+ var hunk = {
+ oldStart: +chunkHeader[1],
+ oldLines: typeof chunkHeader[2] === 'undefined' ? 1 : +chunkHeader[2],
+ newStart: +chunkHeader[3],
+ newLines: typeof chunkHeader[4] === 'undefined' ? 1 : +chunkHeader[4],
+ lines: [],
+ linedelimiters: []
+ }; // Unified Diff Format quirk: If the chunk size is 0,
+ // the first number is one lower than one would expect.
+ // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
+
+ if (hunk.oldLines === 0) {
+ hunk.oldStart += 1;
+ }
+
+ if (hunk.newLines === 0) {
+ hunk.newStart += 1;
+ }
+
+ var addCount = 0,
+ removeCount = 0;
+
+ for (; i < diffstr.length; i++) {
+ // Lines starting with '---' could be mistaken for the "remove line" operation
+ // But they could be the header for the next file. Therefore prune such cases out.
+ if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) {
+ break;
+ }
+
+ var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0];
+
+ if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') {
+ hunk.lines.push(diffstr[i]);
+ hunk.linedelimiters.push(delimiters[i] || '\n');
+
+ if (operation === '+') {
+ addCount++;
+ } else if (operation === '-') {
+ removeCount++;
+ } else if (operation === ' ') {
+ addCount++;
+ removeCount++;
+ }
+ } else {
+ break;
+ }
+ } // Handle the empty block count case
+
+
+ if (!addCount && hunk.newLines === 1) {
+ hunk.newLines = 0;
+ }
+
+ if (!removeCount && hunk.oldLines === 1) {
+ hunk.oldLines = 0;
+ } // Perform optional sanity checking
+
+
+ if (options.strict) {
+ if (addCount !== hunk.newLines) {
+ throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+ }
+
+ if (removeCount !== hunk.oldLines) {
+ throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+ }
+ }
+
+ return hunk;
+ }
+
+ while (i < diffstr.length) {
+ parseIndex();
+ }
+
+ return list;
+ }
+
+ // Iterator that traverses in the range of [min, max], stepping
+ // by distance from a given start position. I.e. for [0, 4], with
+ // start of 2, this will iterate 2, 3, 1, 4, 0.
+ function distanceIterator (start, minLine, maxLine) {
+ var wantForward = true,
+ backwardExhausted = false,
+ forwardExhausted = false,
+ localOffset = 1;
+ return function iterator() {
+ if (wantForward && !forwardExhausted) {
+ if (backwardExhausted) {
+ localOffset++;
+ } else {
+ wantForward = false;
+ } // Check if trying to fit beyond text length, and if not, check it fits
+ // after offset location (or desired location on first iteration)
+
+
+ if (start + localOffset <= maxLine) {
+ return localOffset;
+ }
+
+ forwardExhausted = true;
+ }
+
+ if (!backwardExhausted) {
+ if (!forwardExhausted) {
+ wantForward = true;
+ } // Check if trying to fit before text beginning, and if not, check it fits
+ // before offset location
+
+
+ if (minLine <= start - localOffset) {
+ return -localOffset++;
+ }
+
+ backwardExhausted = true;
+ return iterator();
+ } // We tried to fit hunk before text beginning and beyond text length, then
+ // hunk can't fit on the text. Return undefined
+
+ };
+ }
+
+ function applyPatch(source, uniDiff) {
+ var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+ if (typeof uniDiff === 'string') {
+ uniDiff = parsePatch(uniDiff);
+ }
+
+ if (Array.isArray(uniDiff)) {
+ if (uniDiff.length > 1) {
+ throw new Error('applyPatch only works with a single input.');
+ }
+
+ uniDiff = uniDiff[0];
+ } // Apply the diff to the input
+
+
+ var lines = source.split(/\r\n|[\n\v\f\r\x85]/),
+ delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [],
+ hunks = uniDiff.hunks,
+ compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) {
+ return line === patchContent;
+ },
+ errorCount = 0,
+ fuzzFactor = options.fuzzFactor || 0,
+ minLine = 0,
+ offset = 0,
+ removeEOFNL,
+ addEOFNL;
+ /**
+ * Checks if the hunk exactly fits on the provided location
+ */
+
+
+ function hunkFits(hunk, toPos) {
+ for (var j = 0; j < hunk.lines.length; j++) {
+ var line = hunk.lines[j],
+ operation = line.length > 0 ? line[0] : ' ',
+ content = line.length > 0 ? line.substr(1) : line;
+
+ if (operation === ' ' || operation === '-') {
+ // Context sanity check
+ if (!compareLine(toPos + 1, lines[toPos], operation, content)) {
+ errorCount++;
+
+ if (errorCount > fuzzFactor) {
+ return false;
+ }
+ }
+
+ toPos++;
+ }
+ }
+
+ return true;
+ } // Search best fit offsets for each hunk based on the previous ones
+
+
+ for (var i = 0; i < hunks.length; i++) {
+ var hunk = hunks[i],
+ maxLine = lines.length - hunk.oldLines,
+ localOffset = 0,
+ toPos = offset + hunk.oldStart - 1;
+ var iterator = distanceIterator(toPos, minLine, maxLine);
+
+ for (; localOffset !== undefined; localOffset = iterator()) {
+ if (hunkFits(hunk, toPos + localOffset)) {
+ hunk.offset = offset += localOffset;
+ break;
+ }
+ }
+
+ if (localOffset === undefined) {
+ return false;
+ } // Set lower text limit to end of the current hunk, so next ones don't try
+ // to fit over already patched text
+
+
+ minLine = hunk.offset + hunk.oldStart + hunk.oldLines;
+ } // Apply patch hunks
+
+
+ var diffOffset = 0;
+
+ for (var _i = 0; _i < hunks.length; _i++) {
+ var _hunk = hunks[_i],
+ _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1;
+
+ diffOffset += _hunk.newLines - _hunk.oldLines;
+
+ for (var j = 0; j < _hunk.lines.length; j++) {
+ var line = _hunk.lines[j],
+ operation = line.length > 0 ? line[0] : ' ',
+ content = line.length > 0 ? line.substr(1) : line,
+ delimiter = _hunk.linedelimiters[j];
+
+ if (operation === ' ') {
+ _toPos++;
+ } else if (operation === '-') {
+ lines.splice(_toPos, 1);
+ delimiters.splice(_toPos, 1);
+ /* istanbul ignore else */
+ } else if (operation === '+') {
+ lines.splice(_toPos, 0, content);
+ delimiters.splice(_toPos, 0, delimiter);
+ _toPos++;
+ } else if (operation === '\\') {
+ var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null;
+
+ if (previousOperation === '+') {
+ removeEOFNL = true;
+ } else if (previousOperation === '-') {
+ addEOFNL = true;
+ }
+ }
+ }
+ } // Handle EOFNL insertion/removal
+
+
+ if (removeEOFNL) {
+ while (!lines[lines.length - 1]) {
+ lines.pop();
+ delimiters.pop();
+ }
+ } else if (addEOFNL) {
+ lines.push('');
+ delimiters.push('\n');
+ }
+
+ for (var _k = 0; _k < lines.length - 1; _k++) {
+ lines[_k] = lines[_k] + delimiters[_k];
+ }
+
+ return lines.join('');
+ } // Wrapper that supports multiple file patches via callbacks.
+
+ function applyPatches(uniDiff, options) {
+ if (typeof uniDiff === 'string') {
+ uniDiff = parsePatch(uniDiff);
+ }
+
+ var currentIndex = 0;
+
+ function processIndex() {
+ var index = uniDiff[currentIndex++];
+
+ if (!index) {
+ return options.complete();
+ }
+
+ options.loadFile(index, function (err, data) {
+ if (err) {
+ return options.complete(err);
+ }
+
+ var updatedContent = applyPatch(data, index, options);
+ options.patched(index, updatedContent, function (err) {
+ if (err) {
+ return options.complete(err);
+ }
+
+ processIndex();
+ });
+ });
+ }
+
+ processIndex();
+ }
+
+ function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+ if (!options) {
+ options = {};
+ }
+
+ if (typeof options.context === 'undefined') {
+ options.context = 4;
+ }
+
+ var diff = diffLines(oldStr, newStr, options);
+ diff.push({
+ value: '',
+ lines: []
+ }); // Append an empty value to make cleanup easier
+
+ function contextLines(lines) {
+ return lines.map(function (entry) {
+ return ' ' + entry;
+ });
+ }
+
+ var hunks = [];
+ var oldRangeStart = 0,
+ newRangeStart = 0,
+ curRange = [],
+ oldLine = 1,
+ newLine = 1;
+
+ var _loop = function _loop(i) {
+ var current = diff[i],
+ lines = current.lines || current.value.replace(/\n$/, '').split('\n');
+ current.lines = lines;
+
+ if (current.added || current.removed) {
+ var _curRange;
+
+ // If we have previous context, start with that
+ if (!oldRangeStart) {
+ var prev = diff[i - 1];
+ oldRangeStart = oldLine;
+ newRangeStart = newLine;
+
+ if (prev) {
+ curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];
+ oldRangeStart -= curRange.length;
+ newRangeStart -= curRange.length;
+ }
+ } // Output our changes
+
+
+ (_curRange = curRange).push.apply(_curRange, _toConsumableArray(lines.map(function (entry) {
+ return (current.added ? '+' : '-') + entry;
+ }))); // Track the updated file position
+
+
+ if (current.added) {
+ newLine += lines.length;
+ } else {
+ oldLine += lines.length;
+ }
+ } else {
+ // Identical context lines. Track line changes
+ if (oldRangeStart) {
+ // Close out any changes that have been output (or join overlapping)
+ if (lines.length <= options.context * 2 && i < diff.length - 2) {
+ var _curRange2;
+
+ // Overlapping
+ (_curRange2 = curRange).push.apply(_curRange2, _toConsumableArray(contextLines(lines)));
+ } else {
+ var _curRange3;
+
+ // end the range and output
+ var contextSize = Math.min(lines.length, options.context);
+
+ (_curRange3 = curRange).push.apply(_curRange3, _toConsumableArray(contextLines(lines.slice(0, contextSize))));
+
+ var hunk = {
+ oldStart: oldRangeStart,
+ oldLines: oldLine - oldRangeStart + contextSize,
+ newStart: newRangeStart,
+ newLines: newLine - newRangeStart + contextSize,
+ lines: curRange
+ };
+
+ if (i >= diff.length - 2 && lines.length <= options.context) {
+ // EOF is inside this hunk
+ var oldEOFNewline = /\n$/.test(oldStr);
+ var newEOFNewline = /\n$/.test(newStr);
+ var noNlBeforeAdds = lines.length == 0 && curRange.length > hunk.oldLines;
+
+ if (!oldEOFNewline && noNlBeforeAdds && oldStr.length > 0) {
+ // special case: old has no eol and no trailing context; no-nl can end up before adds
+ // however, if the old file is empty, do not output the no-nl line
+ curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file');
+ }
+
+ if (!oldEOFNewline && !noNlBeforeAdds || !newEOFNewline) {
+ curRange.push('\\ No newline at end of file');
+ }
+ }
+
+ hunks.push(hunk);
+ oldRangeStart = 0;
+ newRangeStart = 0;
+ curRange = [];
+ }
+ }
+
+ oldLine += lines.length;
+ newLine += lines.length;
+ }
+ };
+
+ for (var i = 0; i < diff.length; i++) {
+ _loop(i);
+ }
+
+ return {
+ oldFileName: oldFileName,
+ newFileName: newFileName,
+ oldHeader: oldHeader,
+ newHeader: newHeader,
+ hunks: hunks
+ };
+ }
+ function formatPatch(diff) {
+ var ret = [];
+
+ if (diff.oldFileName == diff.newFileName) {
+ ret.push('Index: ' + diff.oldFileName);
+ }
+
+ ret.push('===================================================================');
+ ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader));
+ ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader));
+
+ for (var i = 0; i < diff.hunks.length; i++) {
+ var hunk = diff.hunks[i]; // Unified Diff Format quirk: If the chunk size is 0,
+ // the first number is one lower than one would expect.
+ // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
+
+ if (hunk.oldLines === 0) {
+ hunk.oldStart -= 1;
+ }
+
+ if (hunk.newLines === 0) {
+ hunk.newStart -= 1;
+ }
+
+ ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@');
+ ret.push.apply(ret, hunk.lines);
+ }
+
+ return ret.join('\n') + '\n';
+ }
+ function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+ return formatPatch(structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options));
+ }
+ function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
+ return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
+ }
+
+ function arrayEqual(a, b) {
+ if (a.length !== b.length) {
+ return false;
+ }
+
+ return arrayStartsWith(a, b);
+ }
+ function arrayStartsWith(array, start) {
+ if (start.length > array.length) {
+ return false;
+ }
+
+ for (var i = 0; i < start.length; i++) {
+ if (start[i] !== array[i]) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function calcLineCount(hunk) {
+ var _calcOldNewLineCount = calcOldNewLineCount(hunk.lines),
+ oldLines = _calcOldNewLineCount.oldLines,
+ newLines = _calcOldNewLineCount.newLines;
+
+ if (oldLines !== undefined) {
+ hunk.oldLines = oldLines;
+ } else {
+ delete hunk.oldLines;
+ }
+
+ if (newLines !== undefined) {
+ hunk.newLines = newLines;
+ } else {
+ delete hunk.newLines;
+ }
+ }
+ function merge(mine, theirs, base) {
+ mine = loadPatch(mine, base);
+ theirs = loadPatch(theirs, base);
+ var ret = {}; // For index we just let it pass through as it doesn't have any necessary meaning.
+ // Leaving sanity checks on this to the API consumer that may know more about the
+ // meaning in their own context.
+
+ if (mine.index || theirs.index) {
+ ret.index = mine.index || theirs.index;
+ }
+
+ if (mine.newFileName || theirs.newFileName) {
+ if (!fileNameChanged(mine)) {
+ // No header or no change in ours, use theirs (and ours if theirs does not exist)
+ ret.oldFileName = theirs.oldFileName || mine.oldFileName;
+ ret.newFileName = theirs.newFileName || mine.newFileName;
+ ret.oldHeader = theirs.oldHeader || mine.oldHeader;
+ ret.newHeader = theirs.newHeader || mine.newHeader;
+ } else if (!fileNameChanged(theirs)) {
+ // No header or no change in theirs, use ours
+ ret.oldFileName = mine.oldFileName;
+ ret.newFileName = mine.newFileName;
+ ret.oldHeader = mine.oldHeader;
+ ret.newHeader = mine.newHeader;
+ } else {
+ // Both changed... figure it out
+ ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);
+ ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);
+ ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);
+ ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);
+ }
+ }
+
+ ret.hunks = [];
+ var mineIndex = 0,
+ theirsIndex = 0,
+ mineOffset = 0,
+ theirsOffset = 0;
+
+ while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {
+ var mineCurrent = mine.hunks[mineIndex] || {
+ oldStart: Infinity
+ },
+ theirsCurrent = theirs.hunks[theirsIndex] || {
+ oldStart: Infinity
+ };
+
+ if (hunkBefore(mineCurrent, theirsCurrent)) {
+ // This patch does not overlap with any of the others, yay.
+ ret.hunks.push(cloneHunk(mineCurrent, mineOffset));
+ mineIndex++;
+ theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;
+ } else if (hunkBefore(theirsCurrent, mineCurrent)) {
+ // This patch does not overlap with any of the others, yay.
+ ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));
+ theirsIndex++;
+ mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;
+ } else {
+ // Overlap, merge as best we can
+ var mergedHunk = {
+ oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),
+ oldLines: 0,
+ newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),
+ newLines: 0,
+ lines: []
+ };
+ mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);
+ theirsIndex++;
+ mineIndex++;
+ ret.hunks.push(mergedHunk);
+ }
+ }
+
+ return ret;
+ }
+
+ function loadPatch(param, base) {
+ if (typeof param === 'string') {
+ if (/^@@/m.test(param) || /^Index:/m.test(param)) {
+ return parsePatch(param)[0];
+ }
+
+ if (!base) {
+ throw new Error('Must provide a base reference or pass in a patch');
+ }
+
+ return structuredPatch(undefined, undefined, base, param);
+ }
+
+ return param;
+ }
+
+ function fileNameChanged(patch) {
+ return patch.newFileName && patch.newFileName !== patch.oldFileName;
+ }
+
+ function selectField(index, mine, theirs) {
+ if (mine === theirs) {
+ return mine;
+ } else {
+ index.conflict = true;
+ return {
+ mine: mine,
+ theirs: theirs
+ };
+ }
+ }
+
+ function hunkBefore(test, check) {
+ return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart;
+ }
+
+ function cloneHunk(hunk, offset) {
+ return {
+ oldStart: hunk.oldStart,
+ oldLines: hunk.oldLines,
+ newStart: hunk.newStart + offset,
+ newLines: hunk.newLines,
+ lines: hunk.lines
+ };
+ }
+
+ function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {
+ // This will generally result in a conflicted hunk, but there are cases where the context
+ // is the only overlap where we can successfully merge the content here.
+ var mine = {
+ offset: mineOffset,
+ lines: mineLines,
+ index: 0
+ },
+ their = {
+ offset: theirOffset,
+ lines: theirLines,
+ index: 0
+ }; // Handle any leading content
+
+ insertLeading(hunk, mine, their);
+ insertLeading(hunk, their, mine); // Now in the overlap content. Scan through and select the best changes from each.
+
+ while (mine.index < mine.lines.length && their.index < their.lines.length) {
+ var mineCurrent = mine.lines[mine.index],
+ theirCurrent = their.lines[their.index];
+
+ if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {
+ // Both modified ...
+ mutualChange(hunk, mine, their);
+ } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {
+ var _hunk$lines;
+
+ // Mine inserted
+ (_hunk$lines = hunk.lines).push.apply(_hunk$lines, _toConsumableArray(collectChange(mine)));
+ } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {
+ var _hunk$lines2;
+
+ // Theirs inserted
+ (_hunk$lines2 = hunk.lines).push.apply(_hunk$lines2, _toConsumableArray(collectChange(their)));
+ } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {
+ // Mine removed or edited
+ removal(hunk, mine, their);
+ } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {
+ // Their removed or edited
+ removal(hunk, their, mine, true);
+ } else if (mineCurrent === theirCurrent) {
+ // Context identity
+ hunk.lines.push(mineCurrent);
+ mine.index++;
+ their.index++;
+ } else {
+ // Context mismatch
+ conflict(hunk, collectChange(mine), collectChange(their));
+ }
+ } // Now push anything that may be remaining
+
+
+ insertTrailing(hunk, mine);
+ insertTrailing(hunk, their);
+ calcLineCount(hunk);
+ }
+
+ function mutualChange(hunk, mine, their) {
+ var myChanges = collectChange(mine),
+ theirChanges = collectChange(their);
+
+ if (allRemoves(myChanges) && allRemoves(theirChanges)) {
+ // Special case for remove changes that are supersets of one another
+ if (arrayStartsWith(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {
+ var _hunk$lines3;
+
+ (_hunk$lines3 = hunk.lines).push.apply(_hunk$lines3, _toConsumableArray(myChanges));
+
+ return;
+ } else if (arrayStartsWith(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {
+ var _hunk$lines4;
+
+ (_hunk$lines4 = hunk.lines).push.apply(_hunk$lines4, _toConsumableArray(theirChanges));
+
+ return;
+ }
+ } else if (arrayEqual(myChanges, theirChanges)) {
+ var _hunk$lines5;
+
+ (_hunk$lines5 = hunk.lines).push.apply(_hunk$lines5, _toConsumableArray(myChanges));
+
+ return;
+ }
+
+ conflict(hunk, myChanges, theirChanges);
+ }
+
+ function removal(hunk, mine, their, swap) {
+ var myChanges = collectChange(mine),
+ theirChanges = collectContext(their, myChanges);
+
+ if (theirChanges.merged) {
+ var _hunk$lines6;
+
+ (_hunk$lines6 = hunk.lines).push.apply(_hunk$lines6, _toConsumableArray(theirChanges.merged));
+ } else {
+ conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);
+ }
+ }
+
+ function conflict(hunk, mine, their) {
+ hunk.conflict = true;
+ hunk.lines.push({
+ conflict: true,
+ mine: mine,
+ theirs: their
+ });
+ }
+
+ function insertLeading(hunk, insert, their) {
+ while (insert.offset < their.offset && insert.index < insert.lines.length) {
+ var line = insert.lines[insert.index++];
+ hunk.lines.push(line);
+ insert.offset++;
+ }
+ }
+
+ function insertTrailing(hunk, insert) {
+ while (insert.index < insert.lines.length) {
+ var line = insert.lines[insert.index++];
+ hunk.lines.push(line);
+ }
+ }
+
+ function collectChange(state) {
+ var ret = [],
+ operation = state.lines[state.index][0];
+
+ while (state.index < state.lines.length) {
+ var line = state.lines[state.index]; // Group additions that are immediately after subtractions and treat them as one "atomic" modify change.
+
+ if (operation === '-' && line[0] === '+') {
+ operation = '+';
+ }
+
+ if (operation === line[0]) {
+ ret.push(line);
+ state.index++;
+ } else {
+ break;
+ }
+ }
+
+ return ret;
+ }
+
+ function collectContext(state, matchChanges) {
+ var changes = [],
+ merged = [],
+ matchIndex = 0,
+ contextChanges = false,
+ conflicted = false;
+
+ while (matchIndex < matchChanges.length && state.index < state.lines.length) {
+ var change = state.lines[state.index],
+ match = matchChanges[matchIndex]; // Once we've hit our add, then we are done
+
+ if (match[0] === '+') {
+ break;
+ }
+
+ contextChanges = contextChanges || change[0] !== ' ';
+ merged.push(match);
+ matchIndex++; // Consume any additions in the other block as a conflict to attempt
+ // to pull in the remaining context after this
+
+ if (change[0] === '+') {
+ conflicted = true;
+
+ while (change[0] === '+') {
+ changes.push(change);
+ change = state.lines[++state.index];
+ }
+ }
+
+ if (match.substr(1) === change.substr(1)) {
+ changes.push(change);
+ state.index++;
+ } else {
+ conflicted = true;
+ }
+ }
+
+ if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) {
+ conflicted = true;
+ }
+
+ if (conflicted) {
+ return changes;
+ }
+
+ while (matchIndex < matchChanges.length) {
+ merged.push(matchChanges[matchIndex++]);
+ }
+
+ return {
+ merged: merged,
+ changes: changes
+ };
+ }
+
+ function allRemoves(changes) {
+ return changes.reduce(function (prev, change) {
+ return prev && change[0] === '-';
+ }, true);
+ }
+
+ function skipRemoveSuperset(state, removeChanges, delta) {
+ for (var i = 0; i < delta; i++) {
+ var changeContent = removeChanges[removeChanges.length - delta + i].substr(1);
+
+ if (state.lines[state.index + i] !== ' ' + changeContent) {
+ return false;
+ }
+ }
+
+ state.index += delta;
+ return true;
+ }
+
+ function calcOldNewLineCount(lines) {
+ var oldLines = 0;
+ var newLines = 0;
+ lines.forEach(function (line) {
+ if (typeof line !== 'string') {
+ var myCount = calcOldNewLineCount(line.mine);
+ var theirCount = calcOldNewLineCount(line.theirs);
+
+ if (oldLines !== undefined) {
+ if (myCount.oldLines === theirCount.oldLines) {
+ oldLines += myCount.oldLines;
+ } else {
+ oldLines = undefined;
+ }
+ }
+
+ if (newLines !== undefined) {
+ if (myCount.newLines === theirCount.newLines) {
+ newLines += myCount.newLines;
+ } else {
+ newLines = undefined;
+ }
+ }
+ } else {
+ if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {
+ newLines++;
+ }
+
+ if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {
+ oldLines++;
+ }
+ }
+ });
+ return {
+ oldLines: oldLines,
+ newLines: newLines
+ };
+ }
+
+ // See: http://code.google.com/p/google-diff-match-patch/wiki/API
+ function convertChangesToDMP(changes) {
+ var ret = [],
+ change,
+ operation;
+
+ for (var i = 0; i < changes.length; i++) {
+ change = changes[i];
+
+ if (change.added) {
+ operation = 1;
+ } else if (change.removed) {
+ operation = -1;
+ } else {
+ operation = 0;
+ }
+
+ ret.push([operation, change.value]);
+ }
+
+ return ret;
+ }
+
+ function convertChangesToXML(changes) {
+ var ret = [];
+
+ for (var i = 0; i < changes.length; i++) {
+ var change = changes[i];
+
+ if (change.added) {
+ ret.push('');
+ } else if (change.removed) {
+ ret.push('
+
+ Get professional support for 'find-up' 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/node_modules/flat/.travis.yml b/node_modules/flat/.travis.yml
new file mode 100644
index 0000000..f35768a
--- /dev/null
+++ b/node_modules/flat/.travis.yml
@@ -0,0 +1,8 @@
+language: node_js
+node_js:
+ - "6"
+ - "7"
+ - "8"
+ - "10"
+ - "12"
+ - "14"
diff --git a/node_modules/flat/LICENSE b/node_modules/flat/LICENSE
new file mode 100644
index 0000000..d99b655
--- /dev/null
+++ b/node_modules/flat/LICENSE
@@ -0,0 +1,12 @@
+Copyright (c) 2014, Hugh Kennedy
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/flat/README.md b/node_modules/flat/README.md
new file mode 100644
index 0000000..a036a9f
--- /dev/null
+++ b/node_modules/flat/README.md
@@ -0,0 +1,236 @@
+# flat [](http://travis-ci.org/hughsk/flat)
+
+Take a nested Javascript object and flatten it, or unflatten an object with
+delimited keys.
+
+## Installation
+
+``` bash
+$ npm install flat
+```
+
+## Methods
+
+### flatten(original, options)
+
+Flattens the object - it'll return an object one level deep, regardless of how
+nested the original object was:
+
+``` javascript
+var flatten = require('flat')
+
+flatten({
+ key1: {
+ keyA: 'valueI'
+ },
+ key2: {
+ keyB: 'valueII'
+ },
+ key3: { a: { b: { c: 2 } } }
+})
+
+// {
+// 'key1.keyA': 'valueI',
+// 'key2.keyB': 'valueII',
+// 'key3.a.b.c': 2
+// }
+```
+
+### unflatten(original, options)
+
+Flattening is reversible too, you can call `flatten.unflatten()` on an object:
+
+``` javascript
+var unflatten = require('flat').unflatten
+
+unflatten({
+ 'three.levels.deep': 42,
+ 'three.levels': {
+ nested: true
+ }
+})
+
+// {
+// three: {
+// levels: {
+// deep: 42,
+// nested: true
+// }
+// }
+// }
+```
+
+## Options
+
+### delimiter
+
+Use a custom delimiter for (un)flattening your objects, instead of `.`.
+
+### safe
+
+When enabled, both `flat` and `unflatten` will preserve arrays and their
+contents. This is disabled by default.
+
+``` javascript
+var flatten = require('flat')
+
+flatten({
+ this: [
+ { contains: 'arrays' },
+ { preserving: {
+ them: 'for you'
+ }}
+ ]
+}, {
+ safe: true
+})
+
+// {
+// 'this': [
+// { contains: 'arrays' },
+// { preserving: {
+// them: 'for you'
+// }}
+// ]
+// }
+```
+
+### object
+
+When enabled, arrays will not be created automatically when calling unflatten, like so:
+
+``` javascript
+unflatten({
+ 'hello.you.0': 'ipsum',
+ 'hello.you.1': 'lorem',
+ 'hello.other.world': 'foo'
+}, { object: true })
+
+// hello: {
+// you: {
+// 0: 'ipsum',
+// 1: 'lorem',
+// },
+// other: { world: 'foo' }
+// }
+```
+
+### overwrite
+
+When enabled, existing keys in the unflattened object may be overwritten if they cannot hold a newly encountered nested value:
+
+```javascript
+unflatten({
+ 'TRAVIS': 'true',
+ 'TRAVIS.DIR': '/home/travis/build/kvz/environmental'
+}, { overwrite: true })
+
+// TRAVIS: {
+// DIR: '/home/travis/build/kvz/environmental'
+// }
+```
+
+Without `overwrite` set to `true`, the `TRAVIS` key would already have been set to a string, thus could not accept the nested `DIR` element.
+
+This only makes sense on ordered arrays, and since we're overwriting data, should be used with care.
+
+
+### maxDepth
+
+Maximum number of nested objects to flatten.
+
+``` javascript
+var flatten = require('flat')
+
+flatten({
+ key1: {
+ keyA: 'valueI'
+ },
+ key2: {
+ keyB: 'valueII'
+ },
+ key3: { a: { b: { c: 2 } } }
+}, { maxDepth: 2 })
+
+// {
+// 'key1.keyA': 'valueI',
+// 'key2.keyB': 'valueII',
+// 'key3.a': { b: { c: 2 } }
+// }
+```
+
+### transformKey
+
+Transform each part of a flat key before and after flattening.
+
+```javascript
+var flatten = require('flat')
+var unflatten = require('flat').unflatten
+
+flatten({
+ key1: {
+ keyA: 'valueI'
+ },
+ key2: {
+ keyB: 'valueII'
+ },
+ key3: { a: { b: { c: 2 } } }
+}, {
+ transformKey: function(key){
+ return '__' + key + '__';
+ }
+})
+
+// {
+// '__key1__.__keyA__': 'valueI',
+// '__key2__.__keyB__': 'valueII',
+// '__key3__.__a__.__b__.__c__': 2
+// }
+
+unflatten({
+ '__key1__.__keyA__': 'valueI',
+ '__key2__.__keyB__': 'valueII',
+ '__key3__.__a__.__b__.__c__': 2
+}, {
+ transformKey: function(key){
+ return key.substring(2, key.length - 2)
+ }
+})
+
+// {
+// key1: {
+// keyA: 'valueI'
+// },
+// key2: {
+// keyB: 'valueII'
+// },
+// key3: { a: { b: { c: 2 } } }
+// }
+```
+
+## Command Line Usage
+
+`flat` is also available as a command line tool. You can run it with
+[`npx`](https://ghub.io/npx):
+
+```sh
+npx flat foo.json
+```
+
+Or install the `flat` command globally:
+
+```sh
+npm i -g flat && flat foo.json
+```
+
+Accepts a filename as an argument:
+
+```sh
+flat foo.json
+```
+
+Also accepts JSON on stdin:
+
+```sh
+cat foo.json | flat
+```
diff --git a/node_modules/flat/cli.js b/node_modules/flat/cli.js
new file mode 100644
index 0000000..e4f96b3
--- /dev/null
+++ b/node_modules/flat/cli.js
@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const readline = require('readline')
+
+const flat = require('./index')
+
+const filepath = process.argv.slice(2)[0]
+if (filepath) {
+ // Read from file
+ const file = path.resolve(process.cwd(), filepath)
+ fs.accessSync(file, fs.constants.R_OK) // allow to throw if not readable
+ out(require(file))
+} else if (process.stdin.isTTY) {
+ usage(0)
+} else {
+ // Read from newline-delimited STDIN
+ const lines = []
+ readline.createInterface({
+ input: process.stdin,
+ output: process.stdout,
+ terminal: false
+ })
+ .on('line', line => lines.push(line))
+ .on('close', () => out(JSON.parse(lines.join('\n'))))
+}
+
+function out (data) {
+ process.stdout.write(JSON.stringify(flat(data), null, 2))
+}
+
+function usage (code) {
+ console.log(`
+Usage:
+
+flat foo.json
+cat foo.json | flat
+`)
+
+ process.exit(code || 0)
+}
diff --git a/node_modules/flat/index.js b/node_modules/flat/index.js
new file mode 100644
index 0000000..2a5d7ca
--- /dev/null
+++ b/node_modules/flat/index.js
@@ -0,0 +1,158 @@
+module.exports = flatten
+flatten.flatten = flatten
+flatten.unflatten = unflatten
+
+function isBuffer (obj) {
+ return obj &&
+ obj.constructor &&
+ (typeof obj.constructor.isBuffer === 'function') &&
+ obj.constructor.isBuffer(obj)
+}
+
+function keyIdentity (key) {
+ return key
+}
+
+function flatten (target, opts) {
+ opts = opts || {}
+
+ const delimiter = opts.delimiter || '.'
+ const maxDepth = opts.maxDepth
+ const transformKey = opts.transformKey || keyIdentity
+ const output = {}
+
+ function step (object, prev, currentDepth) {
+ currentDepth = currentDepth || 1
+ Object.keys(object).forEach(function (key) {
+ const value = object[key]
+ const isarray = opts.safe && Array.isArray(value)
+ const type = Object.prototype.toString.call(value)
+ const isbuffer = isBuffer(value)
+ const isobject = (
+ type === '[object Object]' ||
+ type === '[object Array]'
+ )
+
+ const newKey = prev
+ ? prev + delimiter + transformKey(key)
+ : transformKey(key)
+
+ if (!isarray && !isbuffer && isobject && Object.keys(value).length &&
+ (!opts.maxDepth || currentDepth < maxDepth)) {
+ return step(value, newKey, currentDepth + 1)
+ }
+
+ output[newKey] = value
+ })
+ }
+
+ step(target)
+
+ return output
+}
+
+function unflatten (target, opts) {
+ opts = opts || {}
+
+ const delimiter = opts.delimiter || '.'
+ const overwrite = opts.overwrite || false
+ const transformKey = opts.transformKey || keyIdentity
+ const result = {}
+
+ const isbuffer = isBuffer(target)
+ if (isbuffer || Object.prototype.toString.call(target) !== '[object Object]') {
+ return target
+ }
+
+ // safely ensure that the key is
+ // an integer.
+ function getkey (key) {
+ const parsedKey = Number(key)
+
+ return (
+ isNaN(parsedKey) ||
+ key.indexOf('.') !== -1 ||
+ opts.object
+ ) ? key
+ : parsedKey
+ }
+
+ function addKeys (keyPrefix, recipient, target) {
+ return Object.keys(target).reduce(function (result, key) {
+ result[keyPrefix + delimiter + key] = target[key]
+
+ return result
+ }, recipient)
+ }
+
+ function isEmpty (val) {
+ const type = Object.prototype.toString.call(val)
+ const isArray = type === '[object Array]'
+ const isObject = type === '[object Object]'
+
+ if (!val) {
+ return true
+ } else if (isArray) {
+ return !val.length
+ } else if (isObject) {
+ return !Object.keys(val).length
+ }
+ }
+
+ target = Object.keys(target).reduce(function (result, key) {
+ const type = Object.prototype.toString.call(target[key])
+ const isObject = (type === '[object Object]' || type === '[object Array]')
+ if (!isObject || isEmpty(target[key])) {
+ result[key] = target[key]
+ return result
+ } else {
+ return addKeys(
+ key,
+ result,
+ flatten(target[key], opts)
+ )
+ }
+ }, {})
+
+ Object.keys(target).forEach(function (key) {
+ const split = key.split(delimiter).map(transformKey)
+ let key1 = getkey(split.shift())
+ let key2 = getkey(split[0])
+ let recipient = result
+
+ while (key2 !== undefined) {
+ if (key1 === '__proto__') {
+ return
+ }
+
+ const type = Object.prototype.toString.call(recipient[key1])
+ const isobject = (
+ type === '[object Object]' ||
+ type === '[object Array]'
+ )
+
+ // do not write over falsey, non-undefined values if overwrite is false
+ if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+ return
+ }
+
+ if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+ recipient[key1] = (
+ typeof key2 === 'number' &&
+ !opts.object ? [] : {}
+ )
+ }
+
+ recipient = recipient[key1]
+ if (split.length > 0) {
+ key1 = getkey(split.shift())
+ key2 = getkey(split[0])
+ }
+ }
+
+ // unflatten again for 'messy objects'
+ recipient[key1] = unflatten(target[key], opts)
+ })
+
+ return result
+}
diff --git a/node_modules/flat/package.json b/node_modules/flat/package.json
new file mode 100644
index 0000000..c2fbc96
--- /dev/null
+++ b/node_modules/flat/package.json
@@ -0,0 +1,37 @@
+{
+ "name": "flat",
+ "version": "5.0.2",
+ "main": "index.js",
+ "bin": "cli.js",
+ "scripts": {
+ "test": "mocha -u tdd --reporter spec && standard cli.js index.js test/index.js"
+ },
+ "license": "BSD-3-Clause",
+ "description": "Take a nested Javascript object and flatten it, or unflatten an object with delimited keys",
+ "devDependencies": {
+ "mocha": "~8.1.1",
+ "standard": "^14.3.4"
+ },
+ "directories": {
+ "test": "test"
+ },
+ "dependencies": {},
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/hughsk/flat.git"
+ },
+ "keywords": [
+ "flat",
+ "json",
+ "flatten",
+ "unflatten",
+ "split",
+ "object",
+ "nested"
+ ],
+ "author": "Hugh Kennedy + + 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/node_modules/is-unicode-supported/index.d.ts b/node_modules/is-unicode-supported/index.d.ts
new file mode 100644
index 0000000..275b37b
--- /dev/null
+++ b/node_modules/is-unicode-supported/index.d.ts
@@ -0,0 +1,14 @@
+/**
+Detect whether the terminal supports Unicode.
+
+@example
+```
+import isUnicodeSupported = require('is-unicode-supported');
+
+isUnicodeSupported();
+//=> true
+```
+*/
+declare function isUnicodeSupported(): boolean;
+
+export = isUnicodeSupported;
diff --git a/node_modules/is-unicode-supported/index.js b/node_modules/is-unicode-supported/index.js
new file mode 100644
index 0000000..b5a11be
--- /dev/null
+++ b/node_modules/is-unicode-supported/index.js
@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = () => {
+ if (process.platform !== 'win32') {
+ return true;
+ }
+
+ return Boolean(process.env.CI) ||
+ Boolean(process.env.WT_SESSION) || // Windows Terminal
+ process.env.TERM_PROGRAM === 'vscode' ||
+ process.env.TERM === 'xterm-256color' ||
+ process.env.TERM === 'alacritty';
+};
diff --git a/node_modules/is-unicode-supported/license b/node_modules/is-unicode-supported/license
new file mode 100644
index 0000000..fa7ceba
--- /dev/null
+++ b/node_modules/is-unicode-supported/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/node_modules/log-symbols/browser.js b/node_modules/log-symbols/browser.js
new file mode 100644
index 0000000..a66f8ec
--- /dev/null
+++ b/node_modules/log-symbols/browser.js
@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+ info: 'ℹ️',
+ success: '✅',
+ warning: '⚠️',
+ error: '❌️'
+};
diff --git a/node_modules/log-symbols/index.d.ts b/node_modules/log-symbols/index.d.ts
new file mode 100644
index 0000000..8e4bdc5
--- /dev/null
+++ b/node_modules/log-symbols/index.d.ts
@@ -0,0 +1,25 @@
+/**
+Colored symbols for various log levels.
+
+Includes fallbacks for Windows CMD which only supports a [limited character set](https://en.wikipedia.org/wiki/Code_page_437).
+
+@example
+```
+import logSymbols = require('log-symbols');
+
+console.log(logSymbols.success, 'Finished successfully!');
+// Terminals with Unicode support: ✔ Finished successfully!
+// Terminals without Unicode support: √ Finished successfully!
+```
+*/
+declare const logSymbols: {
+ readonly info: string;
+
+ readonly success: string;
+
+ readonly warning: string;
+
+ readonly error: string;
+};
+
+export = logSymbols;
diff --git a/node_modules/log-symbols/index.js b/node_modules/log-symbols/index.js
new file mode 100644
index 0000000..12347e0
--- /dev/null
+++ b/node_modules/log-symbols/index.js
@@ -0,0 +1,19 @@
+'use strict';
+const chalk = require('chalk');
+const isUnicodeSupported = require('is-unicode-supported');
+
+const main = {
+ info: chalk.blue('ℹ'),
+ success: chalk.green('✔'),
+ warning: chalk.yellow('⚠'),
+ error: chalk.red('✖')
+};
+
+const fallback = {
+ info: chalk.blue('i'),
+ success: chalk.green('√'),
+ warning: chalk.yellow('‼'),
+ error: chalk.red('×')
+};
+
+module.exports = isUnicodeSupported() ? main : fallback;
diff --git a/node_modules/log-symbols/license b/node_modules/log-symbols/license
new file mode 100644
index 0000000..fa7ceba
--- /dev/null
+++ b/node_modules/log-symbols/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. + +
+
+## 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/node_modules/log-symbols/node_modules/chalk/index.d.ts b/node_modules/log-symbols/node_modules/chalk/index.d.ts
new file mode 100644
index 0000000..9cd88f3
--- /dev/null
+++ b/node_modules/log-symbols/node_modules/chalk/index.d.ts
@@ -0,0 +1,415 @@
+/**
+Basic foreground colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type ForegroundColor =
+ | 'black'
+ | 'red'
+ | 'green'
+ | 'yellow'
+ | 'blue'
+ | 'magenta'
+ | 'cyan'
+ | 'white'
+ | 'gray'
+ | 'grey'
+ | 'blackBright'
+ | 'redBright'
+ | 'greenBright'
+ | 'yellowBright'
+ | 'blueBright'
+ | 'magentaBright'
+ | 'cyanBright'
+ | 'whiteBright';
+
+/**
+Basic background colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type BackgroundColor =
+ | 'bgBlack'
+ | 'bgRed'
+ | 'bgGreen'
+ | 'bgYellow'
+ | 'bgBlue'
+ | 'bgMagenta'
+ | 'bgCyan'
+ | 'bgWhite'
+ | 'bgGray'
+ | 'bgGrey'
+ | 'bgBlackBright'
+ | 'bgRedBright'
+ | 'bgGreenBright'
+ | 'bgYellowBright'
+ | 'bgBlueBright'
+ | 'bgMagentaBright'
+ | 'bgCyanBright'
+ | 'bgWhiteBright';
+
+/**
+Basic colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support)
+*/
+declare type Color = ForegroundColor | BackgroundColor;
+
+declare type Modifiers =
+ | 'reset'
+ | 'bold'
+ | 'dim'
+ | 'italic'
+ | 'underline'
+ | 'inverse'
+ | 'hidden'
+ | 'strikethrough'
+ | 'visible';
+
+declare namespace chalk {
+ /**
+ Levels:
+ - `0` - All colors disabled.
+ - `1` - Basic 16 colors support.
+ - `2` - ANSI 256 colors support.
+ - `3` - Truecolor 16 million colors support.
+ */
+ type Level = 0 | 1 | 2 | 3;
+
+ interface Options {
+ /**
+ Specify the color support for Chalk.
+
+ By default, color support is automatically detected based on the environment.
+
+ Levels:
+ - `0` - All colors disabled.
+ - `1` - Basic 16 colors support.
+ - `2` - ANSI 256 colors support.
+ - `3` - Truecolor 16 million colors support.
+ */
+ level?: Level;
+ }
+
+ /**
+ Return a new Chalk instance.
+ */
+ type Instance = new (options?: Options) => Chalk;
+
+ /**
+ Detect whether the terminal supports color.
+ */
+ interface ColorSupport {
+ /**
+ The color level used by Chalk.
+ */
+ level: Level;
+
+ /**
+ Return whether Chalk supports basic 16 colors.
+ */
+ hasBasic: boolean;
+
+ /**
+ Return whether Chalk supports ANSI 256 colors.
+ */
+ has256: boolean;
+
+ /**
+ Return whether Chalk supports Truecolor 16 million colors.
+ */
+ has16m: boolean;
+ }
+
+ interface ChalkFunction {
+ /**
+ Use a template string.
+
+ @remarks Template literals are unsupported for nested calls (see [issue #341](https://github.com/chalk/chalk/issues/341))
+
+ @example
+ ```
+ import chalk = require('chalk');
+
+ log(chalk`
+ CPU: {red ${cpu.totalPercent}%}
+ RAM: {green ${ram.used / ram.total * 100}%}
+ DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%}
+ `);
+ ```
+
+ @example
+ ```
+ import chalk = require('chalk');
+
+ log(chalk.red.bgBlack`2 + 3 = {bold ${2 + 3}}`)
+ ```
+ */
+ (text: TemplateStringsArray, ...placeholders: unknown[]): string;
+
+ (...text: unknown[]): string;
+ }
+
+ interface Chalk extends ChalkFunction {
+ /**
+ Return a new Chalk instance.
+ */
+ Instance: Instance;
+
+ /**
+ The color support for Chalk.
+
+ By default, color support is automatically detected based on the environment.
+
+ Levels:
+ - `0` - All colors disabled.
+ - `1` - Basic 16 colors support.
+ - `2` - ANSI 256 colors support.
+ - `3` - Truecolor 16 million colors support.
+ */
+ level: Level;
+
+ /**
+ Use HEX value to set text color.
+
+ @param color - Hexadecimal value representing the desired color.
+
+ @example
+ ```
+ import chalk = require('chalk');
+
+ chalk.hex('#DEADED');
+ ```
+ */
+ hex(color: string): Chalk;
+
+ /**
+ Use keyword color value to set text color.
+
+ @param color - Keyword value representing the desired color.
+
+ @example
+ ```
+ import chalk = require('chalk');
+
+ chalk.keyword('orange');
+ ```
+ */
+ keyword(color: string): Chalk;
+
+ /**
+ Use RGB values to set text color.
+ */
+ rgb(red: number, green: number, blue: number): Chalk;
+
+ /**
+ Use HSL values to set text color.
+ */
+ hsl(hue: number, saturation: number, lightness: number): Chalk;
+
+ /**
+ Use HSV values to set text color.
+ */
+ hsv(hue: number, saturation: number, value: number): Chalk;
+
+ /**
+ Use HWB values to set text color.
+ */
+ hwb(hue: number, whiteness: number, blackness: number): Chalk;
+
+ /**
+ Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set text color.
+
+ 30 <= code && code < 38 || 90 <= code && code < 98
+ For example, 31 for red, 91 for redBright.
+ */
+ ansi(code: number): Chalk;
+
+ /**
+ Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+ */
+ ansi256(index: number): Chalk;
+
+ /**
+ Use HEX value to set background color.
+
+ @param color - Hexadecimal value representing the desired color.
+
+ @example
+ ```
+ import chalk = require('chalk');
+
+ chalk.bgHex('#DEADED');
+ ```
+ */
+ bgHex(color: string): Chalk;
+
+ /**
+ Use keyword color value to set background color.
+
+ @param color - Keyword value representing the desired color.
+
+ @example
+ ```
+ import chalk = require('chalk');
+
+ chalk.bgKeyword('orange');
+ ```
+ */
+ bgKeyword(color: string): Chalk;
+
+ /**
+ Use RGB values to set background color.
+ */
+ bgRgb(red: number, green: number, blue: number): Chalk;
+
+ /**
+ Use HSL values to set background color.
+ */
+ bgHsl(hue: number, saturation: number, lightness: number): Chalk;
+
+ /**
+ Use HSV values to set background color.
+ */
+ bgHsv(hue: number, saturation: number, value: number): Chalk;
+
+ /**
+ Use HWB values to set background color.
+ */
+ bgHwb(hue: number, whiteness: number, blackness: number): Chalk;
+
+ /**
+ Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set background color.
+
+ 30 <= code && code < 38 || 90 <= code && code < 98
+ For example, 31 for red, 91 for redBright.
+ Use the foreground code, not the background code (for example, not 41, nor 101).
+ */
+ bgAnsi(code: number): Chalk;
+
+ /**
+ Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color.
+ */
+ bgAnsi256(index: number): Chalk;
+
+ /**
+ Modifier: Resets the current color chain.
+ */
+ readonly reset: Chalk;
+
+ /**
+ Modifier: Make text bold.
+ */
+ readonly bold: Chalk;
+
+ /**
+ Modifier: Emitting only a small amount of light.
+ */
+ readonly dim: Chalk;
+
+ /**
+ Modifier: Make text italic. (Not widely supported)
+ */
+ readonly italic: Chalk;
+
+ /**
+ Modifier: Make text underline. (Not widely supported)
+ */
+ readonly underline: Chalk;
+
+ /**
+ Modifier: Inverse background and foreground colors.
+ */
+ readonly inverse: Chalk;
+
+ /**
+ Modifier: Prints the text, but makes it invisible.
+ */
+ readonly hidden: Chalk;
+
+ /**
+ Modifier: Puts a horizontal line through the center of the text. (Not widely supported)
+ */
+ readonly strikethrough: Chalk;
+
+ /**
+ Modifier: Prints the text only when Chalk has a color support level > 0.
+ Can be useful for things that are purely cosmetic.
+ */
+ readonly visible: Chalk;
+
+ readonly black: Chalk;
+ readonly red: Chalk;
+ readonly green: Chalk;
+ readonly yellow: Chalk;
+ readonly blue: Chalk;
+ readonly magenta: Chalk;
+ readonly cyan: Chalk;
+ readonly white: Chalk;
+
+ /*
+ Alias for `blackBright`.
+ */
+ readonly gray: Chalk;
+
+ /*
+ Alias for `blackBright`.
+ */
+ readonly grey: Chalk;
+
+ readonly blackBright: Chalk;
+ readonly redBright: Chalk;
+ readonly greenBright: Chalk;
+ readonly yellowBright: Chalk;
+ readonly blueBright: Chalk;
+ readonly magentaBright: Chalk;
+ readonly cyanBright: Chalk;
+ readonly whiteBright: Chalk;
+
+ readonly bgBlack: Chalk;
+ readonly bgRed: Chalk;
+ readonly bgGreen: Chalk;
+ readonly bgYellow: Chalk;
+ readonly bgBlue: Chalk;
+ readonly bgMagenta: Chalk;
+ readonly bgCyan: Chalk;
+ readonly bgWhite: Chalk;
+
+ /*
+ Alias for `bgBlackBright`.
+ */
+ readonly bgGray: Chalk;
+
+ /*
+ Alias for `bgBlackBright`.
+ */
+ readonly bgGrey: Chalk;
+
+ readonly bgBlackBright: Chalk;
+ readonly bgRedBright: Chalk;
+ readonly bgGreenBright: Chalk;
+ readonly bgYellowBright: Chalk;
+ readonly bgBlueBright: Chalk;
+ readonly bgMagentaBright: Chalk;
+ readonly bgCyanBright: Chalk;
+ readonly bgWhiteBright: Chalk;
+ }
+}
+
+/**
+Main Chalk object that allows to chain styles together.
+Call the last one as a method with a string argument.
+Order doesn't matter, and later styles take precedent in case of a conflict.
+This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
+*/
+declare const chalk: chalk.Chalk & chalk.ChalkFunction & {
+ supportsColor: chalk.ColorSupport | false;
+ Level: chalk.Level;
+ Color: Color;
+ ForegroundColor: ForegroundColor;
+ BackgroundColor: BackgroundColor;
+ Modifiers: Modifiers;
+ stderr: chalk.Chalk & {supportsColor: chalk.ColorSupport | false};
+};
+
+export = chalk;
diff --git a/node_modules/log-symbols/node_modules/chalk/license b/node_modules/log-symbols/node_modules/chalk/license
new file mode 100644
index 0000000..e7af2f7
--- /dev/null
+++ b/node_modules/log-symbols/node_modules/chalk/license
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus
+
+
+ 
+
+
+
+
+
+> 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.`