vibe64 0.1.21

package/node_modules/node-pty/src/windowsTerminal.ts

@@ -0,0 +1,203 @@
+/**
+ * Copyright (c) 2012-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+import { Socket } from 'net';
+import { Terminal, DEFAULT_COLS, DEFAULT_ROWS } from './terminal';
+import { WindowsPtyAgent } from './windowsPtyAgent';
+import { IPtyOpenOptions, IWindowsPtyForkOptions } from './interfaces';
+import { ArgvOrCommandLine } from './types';
+import { assign } from './utils';
+
+const DEFAULT_FILE = 'cmd.exe';
+const DEFAULT_NAME = 'Windows Shell';
+
+export class WindowsTerminal extends Terminal {
+  private _isReady: boolean;
+  private _deferreds: { run: () => void }[];
+  private _agent: WindowsPtyAgent;
+
+  constructor(file?: string, args?: ArgvOrCommandLine, opt?: IWindowsPtyForkOptions) {
+    super(opt);
+
+    this._checkType('args', args, 'string', true);
+
+    // Initialize arguments
+    args = args || [];
+    file = file || DEFAULT_FILE;
+    opt = opt || {};
+    opt.env = opt.env || process.env;
+
+    if (opt.encoding) {
+      console.warn('Setting encoding on Windows is not supported');
+    }
+
+    const env = assign({}, opt.env);
+    this._cols = opt.cols || DEFAULT_COLS;
+    this._rows = opt.rows || DEFAULT_ROWS;
+    const cwd = opt.cwd || process.cwd();
+    const name = opt.name || env.TERM || DEFAULT_NAME;
+    const parsedEnv = this._parseEnv(env);
+
+    // If the terminal is ready
+    this._isReady = false;
+
+    // Functions that need to run after `ready` event is emitted.
+    this._deferreds = [];
+
+    // Create new termal.
+    this._agent = new WindowsPtyAgent(file, args, parsedEnv, cwd, this._cols, this._rows, false, opt.useConpty, opt.useConptyDll, opt.conptyInheritCursor);
+    this._socket = this._agent.outSocket;
+
+    // Not available until `ready` event emitted.
+    this._pid = this._agent.innerPid;
+    this._fd = this._agent.fd;
+    this._pty = this._agent.pty;
+
+    // The forked windows terminal is not available until `ready` event is
+    // emitted.
+    this._socket.on('ready_datapipe', () => {
+
+      // Run deferreds and set ready state once the first data event is received.
+      this._socket.once('data', () => {
+        // Wait until the first data event is fired then we can run deferreds.
+        if (!this._isReady) {
+          // Terminal is now ready and we can avoid having to defer method
+          // calls.
+          this._isReady = true;
+
+          // Execute all deferred methods
+          this._deferreds.forEach(fn => {
+            // NB! In order to ensure that `this` has all its references
+            // updated any variable that need to be available in `this` before
+            // the deferred is run has to be declared above this forEach
+            // statement.
+            fn.run();
+          });
+
+          // Reset
+          this._deferreds = [];
+        }
+      });
+
+      // Shutdown if `error` event is emitted.
+      this._socket.on('error', err => {
+        // Close terminal session.
+        this._close();
+
+        // EIO, happens when someone closes our child process: the only process
+        // in the terminal.
+        // node < 0.6.14: errno 5
+        // node >= 0.6.14: read EIO
+        if ((<any>err).code) {
+          if (~(<any>err).code.indexOf('errno 5') || ~(<any>err).code.indexOf('EIO')) return;
+        }
+
+        // Throw anything else.
+        if (this.listeners('error').length < 2) {
+          throw err;
+        }
+      });
+
+      // Cleanup after the socket is closed.
+      this._socket.on('close', () => {
+        this.emit('exit', this._agent.exitCode);
+        this._close();
+      });
+
+    });
+
+    this._file = file;
+    this._name = name;
+
+    this._readable = true;
+    this._writable = true;
+
+    this._forwardEvents();
+  }
+
+  protected _write(data: string | Buffer): void {
+    this._defer(this._doWrite, data);
+  }
+
+  private _doWrite(data: string | Buffer): void {
+    this._agent.inSocket.write(data);
+  }
+
+  /**
+   * openpty
+   */
+
+  public static open(options?: IPtyOpenOptions): void {
+    throw new Error('open() not supported on windows, use Fork() instead.');
+  }
+
+  /**
+   * TTY
+   */
+
+  public resize(cols: number, rows: number): void {
+    if (cols <= 0 || rows <= 0 || isNaN(cols) || isNaN(rows) || cols === Infinity || rows === Infinity) {
+      throw new Error('resizing must be done using positive cols and rows');
+    }
+    this._deferNoArgs(() => {
+      this._agent.resize(cols, rows);
+      this._cols = cols;
+      this._rows = rows;
+    });
+  }
+
+  public clear(): void {
+    this._deferNoArgs(() => {
+      this._agent.clear();
+    });
+  }
+
+  public destroy(): void {
+    this._deferNoArgs(() => {
+      this.kill();
+    });
+  }
+
+  public kill(signal?: string): void {
+    this._deferNoArgs(() => {
+      if (signal) {
+        throw new Error('Signals not supported on windows.');
+      }
+      this._close();
+      this._agent.kill();
+    });
+  }
+
+  private _deferNoArgs<A>(deferredFn: () => void): void {
+    // If the terminal is ready, execute.
+    if (this._isReady) {
+      deferredFn.call(this);
+      return;
+    }
+
+    // Queue until terminal is ready.
+    this._deferreds.push({
+      run: () => deferredFn.call(this)
+    });
+  }
+
+  private _defer<A>(deferredFn: (arg: A) => void, arg: A): void {
+    // If the terminal is ready, execute.
+    if (this._isReady) {
+      deferredFn.call(this, arg);
+      return;
+    }
+
+    // Queue until terminal is ready.
+    this._deferreds.push({
+      run: () => deferredFn.call(this, arg)
+    });
+  }
+
+  public get process(): string { return this._name; }
+  public get master(): Socket { throw new Error('master is not supported on Windows'); }
+  public get slave(): Socket { throw new Error('slave is not supported on Windows'); }
+}

package/node_modules/node-pty/src/worker/conoutSocketWorker.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2020, Microsoft Corporation (MIT License).
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import { Socket, createServer } from 'net';
+import { ConoutWorkerMessage, IWorkerData, getWorkerPipeName } from '../shared/conout';
+
+const { conoutPipeName } = (workerData as IWorkerData);
+
+const conoutSocket = new Socket();
+conoutSocket.setEncoding('utf8');
+conoutSocket.connect(conoutPipeName, () => {
+  const server = createServer(workerSocket => {
+    conoutSocket.pipe(workerSocket);
+  });
+  server.listen(getWorkerPipeName(conoutPipeName));
+  if (!parentPort) {
+    throw new Error('worker_threads parentPort is null');
+  }
+  parentPort.postMessage(ConoutWorkerMessage.READY);
+});

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

@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+declare module 'node-pty' {
+  /**
+   * 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 | undefined };
+
+    /**
+     * 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;
+
+    /**
+     * (EXPERIMENTAL)
+     *
+     * Whether to use the conpty.dll shipped with the node-pty package instead of the one built into
+     * Windows. Defaults to false.
+     */
+    useConptyDll?: 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 }>;
+
+    /**
+     * 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;
+
+    /**
+     * Clears the pty's internal representation of its buffer. This is a no-op
+     * unless on Windows/ConPTY. This is useful if the buffer is cleared on the
+     * frontend in order to synchronize state with the backend to avoid ConPTY
+     * possibly reprinting the screen.
+     */
+    clear(): void;
+
+    /**
+     * Writes data to the pty.
+     * @param data The data to write.
+     */
+    write(data: string | Buffer): 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/npm-run-path/index.d.ts

@@ -0,0 +1,90 @@
+type CommonOptions = {
+	/**
+	Working directory.
+
+	@default process.cwd()
+	*/
+	readonly cwd?: string | URL;
+
+	/**
+	The path to the current Node.js executable.
+
+	This can be either an absolute path or a path relative to the `cwd` option.
+
+	@default [process.execPath](https://nodejs.org/api/process.html#processexecpath)
+	*/
+	readonly execPath?: string | URL;
+
+	/**
+	Whether to push the current Node.js executable's directory (`execPath` option) to the front of PATH.
+
+	@default true
+	*/
+	readonly addExecPath?: boolean;
+
+	/**
+	Whether to push the locally installed binaries' directory to the front of PATH.
+
+	@default true
+	*/
+	readonly preferLocal?: boolean;
+};
+
+export type RunPathOptions = CommonOptions & {
+	/**
+	PATH to be appended.
+
+	Set it to an empty string to exclude the default PATH.
+
+	@default [`PATH`](https://github.com/sindresorhus/path-key)
+	*/
+	readonly path?: string;
+};
+
+export type ProcessEnv = Record<string, string | undefined>;
+
+export type EnvOptions = CommonOptions & {
+	/**
+	Accepts an object of environment variables, like `process.env`, and modifies the PATH using the correct [PATH key](https://github.com/sindresorhus/path-key). Use this if you're modifying the PATH for use in the `child_process` options.
+
+	@default [process.env](https://nodejs.org/api/process.html#processenv)
+	*/
+	readonly env?: ProcessEnv;
+};
+
+/**
+Get your [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) prepended with locally installed binaries.
+
+@returns The augmented path string.
+
+@example
+```
+import childProcess from 'node:child_process';
+import {npmRunPath} from 'npm-run-path';
+
+console.log(process.env.PATH);
+//=> '/usr/local/bin'
+
+console.log(npmRunPath());
+//=> '/Users/sindresorhus/dev/foo/node_modules/.bin:/Users/sindresorhus/dev/node_modules/.bin:/Users/sindresorhus/node_modules/.bin:/Users/node_modules/.bin:/node_modules/.bin:/usr/local/bin'
+```
+*/
+export function npmRunPath(options?: RunPathOptions): string;
+
+/**
+Get your [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) prepended with locally installed binaries.
+
+@returns The augmented [`process.env`](https://nodejs.org/api/process.html#process_process_env) object.
+
+@example
+```
+import childProcess from 'node:child_process';
+import {npmRunPathEnv} from 'npm-run-path';
+
+// `foo` is a locally installed binary
+childProcess.execFileSync('foo', {
+	env: npmRunPathEnv()
+});
+```
+*/
+export function npmRunPathEnv(options?: EnvOptions): ProcessEnv;

package/node_modules/npm-run-path/index.js

@@ -0,0 +1,55 @@
+import process from 'node:process';
+import path from 'node:path';
+import pathKey from 'path-key';
+import {toPath, traversePathUp} from 'unicorn-magic';
+
+export const npmRunPath = ({
+	cwd = process.cwd(),
+	path: pathOption = process.env[pathKey()],
+	preferLocal = true,
+	execPath = process.execPath,
+	addExecPath = true,
+} = {}) => {
+	const cwdPath = path.resolve(toPath(cwd));
+	const result = [];
+	const pathParts = pathOption.split(path.delimiter);
+
+	if (preferLocal) {
+		applyPreferLocal(result, pathParts, cwdPath);
+	}
+
+	if (addExecPath) {
+		applyExecPath(result, pathParts, execPath, cwdPath);
+	}
+
+	return pathOption === '' || pathOption === path.delimiter
+		? `${result.join(path.delimiter)}${pathOption}`
+		: [...result, pathOption].join(path.delimiter);
+};
+
+const applyPreferLocal = (result, pathParts, cwdPath) => {
+	for (const directory of traversePathUp(cwdPath)) {
+		const pathPart = path.join(directory, 'node_modules/.bin');
+		if (!pathParts.includes(pathPart)) {
+			result.push(pathPart);
+		}
+	}
+};
+
+// Ensure the running `node` binary is used
+const applyExecPath = (result, pathParts, execPath, cwdPath) => {
+	const pathPart = path.resolve(cwdPath, toPath(execPath), '..');
+	if (!pathParts.includes(pathPart)) {
+		result.push(pathPart);
+	}
+};
+
+export const npmRunPathEnv = ({env = process.env, ...options} = {}) => {
+	env = {...env};
+
+	const pathName = pathKey({env});
+	options.path = env[pathName];
+	env[pathName] = npmRunPath(options);
+
+	return env;
+};

package/node_modules/npm-run-path/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/npm-run-path/node_modules/path-key/index.d.ts

@@ -0,0 +1,31 @@
+export interface Options {
+	/**
+	Use a custom environment variables object.
+
+	Default: [`process.env`](https://nodejs.org/api/process.html#process_process_env).
+	*/
+	readonly env?: Record<string, string | undefined>;
+
+	/**
+	Get the PATH key for a specific platform.
+
+	Default: [`process.platform`](https://nodejs.org/api/process.html#process_process_platform).
+	*/
+	readonly platform?: NodeJS.Platform;
+}
+
+/**
+Get the [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) environment variable key cross-platform.
+
+@example
+```
+import pathKey from 'path-key';
+
+const key = pathKey();
+//=> 'PATH'
+
+const PATH = process.env[key];
+//=> '/usr/local/bin:/usr/bin:/bin'
+```
+*/
+export default function pathKey(options?: Options): string;

package/node_modules/npm-run-path/node_modules/path-key/index.js

@@ -0,0 +1,12 @@
+export default function pathKey(options = {}) {
+	const {
+		env = process.env,
+		platform = process.platform
+	} = options;
+
+	if (platform !== 'win32') {
+		return 'PATH';
+	}
+
+	return Object.keys(env).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
+}

package/node_modules/npm-run-path/node_modules/path-key/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.