codexui-android 0.1.93 → 0.1.94

package/node_modules/node-pty-prebuilt-multiarch/typings/node-pty.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+declare module 'node-pty-prebuilt-multiarch' {
+  /**
+   * Forks a process as a pseudoterminal.
+   * @param file The file to launch.
+   * @param args The file's arguments as argv (string[]) or in a pre-escaped CommandLine format
+   * (string). Note that the CommandLine option is only available on Windows and is expected to be
+   * escaped properly.
+   * @param options The options of the terminal.
+   * @see CommandLineToArgvW https://msdn.microsoft.com/en-us/library/windows/desktop/bb776391(v=vs.85).aspx
+   * @see Parsing C++ Comamnd-Line Arguments https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
+   * @see GetCommandLine https://msdn.microsoft.com/en-us/library/windows/desktop/ms683156.aspx
+   */
+  export function spawn(file: string, args: string[] | string, options: IPtyForkOptions | IWindowsPtyForkOptions): IPty;
+
+  export interface IBasePtyForkOptions {
+
+    /**
+     * Name of the terminal to be set in environment ($TERM variable).
+     */
+    name?: string;
+
+    /**
+     * Number of intial cols of the pty.
+     */
+    cols?: number;
+
+    /**
+     * Number of initial rows of the pty.
+     */
+    rows?: number;
+
+    /**
+     * Working directory to be set for the child program.
+     */
+    cwd?: string;
+
+    /**
+     * Environment to be set for the child program.
+     */
+    env?: { [key: string]: string };
+
+    /**
+     * String encoding of the underlying pty.
+     * If set, incoming data will be decoded to strings and outgoing strings to bytes applying this encoding.
+     * If unset, incoming data will be delivered as raw bytes (Buffer type).
+     * By default 'utf8' is assumed, to unset it explicitly set it to `null`.
+     */
+    encoding?: string | null;
+
+    /**
+     * (EXPERIMENTAL)
+     * Whether to enable flow control handling (false by default). If enabled a message of `flowControlPause`
+     * will pause the socket and thus blocking the child program execution due to buffer back pressure.
+     * A message of `flowControlResume` will resume the socket into flow mode.
+     * For performance reasons only a single message as a whole will match (no message part matching).
+     * If flow control is enabled the `flowControlPause` and `flowControlResume` messages are not forwarded to
+     * the underlying pseudoterminal.
+     */
+    handleFlowControl?: boolean;
+
+    /**
+     * (EXPERIMENTAL)
+     * The string that should pause the pty when `handleFlowControl` is true. Default is XOFF ('\x13').
+     */
+    flowControlPause?: string;
+
+    /**
+     * (EXPERIMENTAL)
+     * The string that should resume the pty when `handleFlowControl` is true. Default is XON ('\x11').
+     */
+    flowControlResume?: string;
+  }
+
+  export interface IPtyForkOptions extends IBasePtyForkOptions {
+    /**
+     * Security warning: use this option with great caution, as opened file descriptors
+     * with higher privileges might leak to the child program.
+     */
+    uid?: number;
+    gid?: number;
+  }
+
+  export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {
+    /**
+     * Whether to use the ConPTY system on Windows. When this is not set, ConPTY will be used when
+     * the Windows build number is >= 18309 (instead of winpty). Note that ConPTY is available from
+     * build 17134 but is too unstable to enable by default.
+     *
+     * This setting does nothing on non-Windows.
+     */
+    useConpty?: boolean;
+
+    /**
+     * Whether to use PSEUDOCONSOLE_INHERIT_CURSOR in conpty.
+     * @see https://docs.microsoft.com/en-us/windows/console/createpseudoconsole
+     */
+    conptyInheritCursor?: boolean;
+  }
+
+  /**
+   * An interface representing a pseudoterminal, on Windows this is emulated via the winpty library.
+   */
+  export interface IPty {
+    /**
+     * The process ID of the outer process.
+     */
+    readonly pid: number;
+
+    /**
+     * The column size in characters.
+     */
+    readonly cols: number;
+
+    /**
+     * The row size in characters.
+     */
+    readonly rows: number;
+
+    /**
+     * The title of the active process.
+     */
+    readonly process: string;
+
+    /**
+     * (EXPERIMENTAL)
+     * Whether to handle flow control. Useful to disable/re-enable flow control during runtime.
+     * Use this for binary data that is likely to contain the `flowControlPause` string by accident.
+     */
+    handleFlowControl: boolean;
+
+    /**
+     * Adds an event listener for when a data event fires. This happens when data is returned from
+     * the pty.
+     * @returns an `IDisposable` to stop listening.
+     */
+    readonly onData: IEvent<string>;
+
+    /**
+     * Adds an event listener for when an exit event fires. This happens when the pty exits.
+     * @returns an `IDisposable` to stop listening.
+     */
+    readonly onExit: IEvent<{ exitCode: number, signal?: number }>;
+
+    /**
+     * Adds a listener to the data event, fired when data is returned from the pty.
+     * @param event The name of the event.
+     * @param listener The callback function.
+     * @deprecated Use IPty.onData
+     */
+    on(event: 'data', listener: (data: string) => void): void;
+
+    /**
+     * Adds a listener to the exit event, fired when the pty exits.
+     * @param event The name of the event.
+     * @param listener The callback function, exitCode is the exit code of the process and signal is
+     * the signal that triggered the exit. signal is not supported on Windows.
+     * @deprecated Use IPty.onExit
+     */
+    on(event: 'exit', listener: (exitCode: number, signal?: number) => void): void;
+
+    /**
+     * Resizes the dimensions of the pty.
+     * @param columns THe number of columns to use.
+     * @param rows The number of rows to use.
+     */
+    resize(columns: number, rows: number): void;
+
+    /**
+     * Writes data to the pty.
+     * @param data The data to write.
+     */
+    write(data: string): void;
+
+    /**
+     * Kills the pty.
+     * @param signal The signal to use, defaults to SIGHUP. This parameter is not supported on
+     * Windows.
+     * @throws Will throw when signal is used on Windows.
+     */
+    kill(signal?: string): void;
+
+    /**
+     * Pauses the pty for customizable flow control.
+     */
+    pause(): void;
+
+    /**
+     * Resumes the pty for customizable flow control.
+     */
+    resume(): void;
+  }
+
+  /**
+   * An object that can be disposed via a dispose function.
+   */
+  export interface IDisposable {
+    dispose(): void;
+  }
+
+  /**
+   * An event that can be listened to.
+   * @returns an `IDisposable` to stop listening.
+   */
+  export interface IEvent<T> {
+    (listener: (e: T) => any): IDisposable;
+  }
+}

package/node_modules/npmlog/CHANGELOG.md

@@ -0,0 +1,49 @@
+### v4.0.2
+
+* Added installation instructions.
+
+### v4.0.1
+
+* Fix bugs where `log.progressEnabled` got out of sync with how `gauge` kept
+  track of these things resulting in a progressbar that couldn't be disabled.
+
+### v4.0.0
+
+* Allow creating log levels that are an empty string or 0.
+
+### v3.1.2
+
+* Update to `gauge@1.6.0` adding support for default values for template
+  items.
+
+### v3.1.1
+
+* Update to `gauge@1.5.3` to fix to `1.x` compatibility when it comes to
+  when a progress bar is enabled.  In `1.x` if you didn't have a TTY the
+  progress bar was never shown.  In `2.x` it merely defaults to disabled,
+  but you can enable it explicitly if you still want progress updates.
+
+### v3.1.0
+
+* Update to `gauge@2.5.2`:
+  * Updates the `signal-exit` dependency which fixes an incompatibility with
+    the node profiler.
+  * Uses externalizes its ansi code generation in `console-control-strings`
+* Make the default progress bar include the last line printed, colored as it
+  would be when printing to a tty.
+
+### v3.0.0
+
+* Switch to `gauge@2.0.0`, for better performance, better look.
+* Set stderr/stdout blocking if they're tty's, so that we can hide a
+  progress bar going to stderr and then safely print to stdout.  Without
+  this the two can end up overlapping producing confusing and sometimes
+  corrupted output.
+
+### v2.0.0
+
+* Make the `error` event non-fatal so that folks can use it as a prefix.
+
+### v1.0.0
+
+* Add progress bar with `gauge@1.1.0`

package/node_modules/npmlog/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, 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.

package/node_modules/npmlog/README.md

@@ -0,0 +1,216 @@
+# npmlog
+
+The logger util that npm uses.
+
+This logger is very basic.  It does the logging for npm.  It supports
+custom levels and colored output.
+
+By default, logs are written to stderr.  If you want to send log messages
+to outputs other than streams, then you can change the `log.stream`
+member, or you can just listen to the events that it emits, and do
+whatever you want with them.
+
+# Installation
+
+```console
+npm install npmlog --save
+```
+
+# Basic Usage
+
+```javascript
+var log = require('npmlog')
+
+// additional stuff ---------------------------+
+// message ----------+                         |
+// prefix ----+      |                         |
+// level -+   |      |                         |
+//        v   v      v                         v
+    log.info('fyi', 'I have a kitty cat: %j', myKittyCat)
+```
+
+## log.level
+
+* {String}
+
+The level to display logs at.  Any logs at or above this level will be
+displayed.  The special level `silent` will prevent anything from being
+displayed ever.
+
+## log.record
+
+* {Array}
+
+An array of all the log messages that have been entered.
+
+## log.maxRecordSize
+
+* {Number}
+
+The maximum number of records to keep.  If log.record gets bigger than
+10% over this value, then it is sliced down to 90% of this value.
+
+The reason for the 10% window is so that it doesn't have to resize a
+large array on every log entry.
+
+## log.prefixStyle
+
+* {Object}
+
+A style object that specifies how prefixes are styled.  (See below)
+
+## log.headingStyle
+
+* {Object}
+
+A style object that specifies how the heading is styled.  (See below)
+
+## log.heading
+
+* {String} Default: ""
+
+If set, a heading that is printed at the start of every line.
+
+## log.stream
+
+* {Stream} Default: `process.stderr`
+
+The stream where output is written.
+
+## log.enableColor()
+
+Force colors to be used on all messages, regardless of the output
+stream.
+
+## log.disableColor()
+
+Disable colors on all messages.
+
+## log.enableProgress()
+
+Enable the display of log activity spinner and progress bar
+
+## log.disableProgress()
+
+Disable the display of a progress bar
+
+## log.enableUnicode()
+
+Force the unicode theme to be used for the progress bar.
+
+## log.disableUnicode()
+
+Disable the use of unicode in the progress bar.
+
+## log.setGaugeTemplate(template)
+
+Set a template for outputting the progress bar. See the [gauge documentation] for details.
+
+[gauge documentation]: https://npmjs.com/package/gauge
+
+## log.setGaugeThemeset(themes)
+
+Select a themeset to pick themes from for the progress bar. See the [gauge documentation] for details.
+
+## log.pause()
+
+Stop emitting messages to the stream, but do not drop them.
+
+## log.resume()
+
+Emit all buffered messages that were written while paused.
+
+## log.log(level, prefix, message, ...)
+
+* `level` {String} The level to emit the message at
+* `prefix` {String} A string prefix.  Set to "" to skip.
+* `message...` Arguments to `util.format`
+
+Emit a log message at the specified level.
+
+## log\[level](prefix, message, ...)
+
+For example,
+
+* log.silly(prefix, message, ...)
+* log.verbose(prefix, message, ...)
+* log.info(prefix, message, ...)
+* log.http(prefix, message, ...)
+* log.warn(prefix, message, ...)
+* log.error(prefix, message, ...)
+
+Like `log.log(level, prefix, message, ...)`.  In this way, each level is
+given a shorthand, so you can do `log.info(prefix, message)`.
+
+## log.addLevel(level, n, style, disp)
+
+* `level` {String} Level indicator
+* `n` {Number} The numeric level
+* `style` {Object} Object with fg, bg, inverse, etc.
+* `disp` {String} Optional replacement for `level` in the output.
+
+Sets up a new level with a shorthand function and so forth.
+
+Note that if the number is `Infinity`, then setting the level to that
+will cause all log messages to be suppressed.  If the number is
+`-Infinity`, then the only way to show it is to enable all log messages.
+
+## log.newItem(name, todo, weight)
+
+* `name` {String} Optional; progress item name.
+* `todo` {Number} Optional; total amount of work to be done. Default 0.
+* `weight` {Number} Optional; the weight of this item relative to others. Default 1.
+
+This adds a new `are-we-there-yet` item tracker to the progress tracker. The
+object returned has the `log[level]` methods but is otherwise an
+`are-we-there-yet` `Tracker` object.
+
+## log.newStream(name, todo, weight)
+
+This adds a new `are-we-there-yet` stream tracker to the progress tracker. The
+object returned has the `log[level]` methods but is otherwise an
+`are-we-there-yet` `TrackerStream` object.
+
+## log.newGroup(name, weight)
+
+This adds a new `are-we-there-yet` tracker group to the progress tracker. The
+object returned has the `log[level]` methods but is otherwise an
+`are-we-there-yet` `TrackerGroup` object.
+
+# Events
+
+Events are all emitted with the message object.
+
+* `log` Emitted for all messages
+* `log.<level>` Emitted for all messages with the `<level>` level.
+* `<prefix>` Messages with prefixes also emit their prefix as an event.
+
+# Style Objects
+
+Style objects can have the following fields:
+
+* `fg` {String} Color for the foreground text
+* `bg` {String} Color for the background
+* `bold`, `inverse`, `underline` {Boolean} Set the associated property
+* `bell` {Boolean} Make a noise (This is pretty annoying, probably.)
+
+# Message Objects
+
+Every log event is emitted with a message object, and the `log.record`
+list contains all of them that have been created.  They have the
+following fields:
+
+* `id` {Number}
+* `level` {String}
+* `prefix` {String}
+* `message` {String} Result of `util.format()`
+* `messageRaw` {Array} Arguments to `util.format()`
+
+# Blocking TTYs
+
+We use [`set-blocking`](https://npmjs.com/package/set-blocking) to set
+stderr and stdout blocking if they are tty's and have the setBlocking call.
+This is a work around for an issue in early versions of Node.js 6.x, which
+made stderr and stdout non-blocking on OSX. (They are always blocking
+Windows and were never blocking on Linux.) `npmlog` needs them to be blocking
+so that it can allow output to stdout and stderr to be interlaced.