@volter/tabnode 0.2.14-volter.88

package/src/node-lib/tty.js

@@ -0,0 +1,168 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+'use strict';
+
+const {
+  NumberIsInteger,
+  ObjectSetPrototypeOf,
+} = primordials;
+
+const net = require('net');
+const { TTY, isTTY } = internalBinding('tty_wrap');
+const {
+  ErrnoException,
+  codes: {
+    ERR_INVALID_FD,
+    ERR_TTY_INIT_FAILED,
+  },
+} = require('internal/errors');
+const {
+  getColorDepth,
+  hasColors,
+} = require('internal/tty');
+
+// Lazy loaded for startup performance.
+let readline;
+
+function isatty(fd) {
+  return NumberIsInteger(fd) && fd >= 0 && fd <= 2147483647 &&
+         isTTY(fd);
+}
+
+function ReadStream(fd, options) {
+  if (!(this instanceof ReadStream))
+    return new ReadStream(fd, options);
+  if (fd >> 0 !== fd || fd < 0)
+    throw new ERR_INVALID_FD(fd);
+
+  const ctx = {};
+  const tty = new TTY(fd, ctx);
+  if (ctx.code !== undefined) {
+    throw new ERR_TTY_INIT_FAILED(ctx);
+  }
+
+  net.Socket.call(this, {
+    readableHighWaterMark: 0,
+    handle: tty,
+    manualStart: true,
+    ...options,
+  });
+
+  this.isRaw = false;
+  this.isTTY = true;
+}
+
+ObjectSetPrototypeOf(ReadStream.prototype, net.Socket.prototype);
+ObjectSetPrototypeOf(ReadStream, net.Socket);
+
+ReadStream.prototype.setRawMode = function(flag) {
+  flag = !!flag;
+  const err = this._handle?.setRawMode(flag);
+  if (err) {
+    this.emit('error', new ErrnoException(err, 'setRawMode'));
+    return this;
+  }
+  this.isRaw = flag;
+  return this;
+};
+
+function WriteStream(fd) {
+  if (!(this instanceof WriteStream))
+    return new WriteStream(fd);
+  if (fd >> 0 !== fd || fd < 0)
+    throw new ERR_INVALID_FD(fd);
+
+  const ctx = {};
+  const tty = new TTY(fd, ctx);
+  if (ctx.code !== undefined) {
+    throw new ERR_TTY_INIT_FAILED(ctx);
+  }
+
+  net.Socket.call(this, {
+    readableHighWaterMark: 0,
+    handle: tty,
+    manualStart: true,
+  });
+
+  // Prevents interleaved or dropped stdout/stderr output for terminals.
+  // As noted in the following reference, local TTYs tend to be quite fast and
+  // this behavior has become expected due historical functionality on OS X,
+  // even though it was originally intended to change in v1.0.2 (Libuv 1.2.1).
+  // Ref: https://github.com/nodejs/node/pull/1771#issuecomment-119351671
+  this._handle.setBlocking(true);
+
+  const winSize = [0, 0];
+  const err = this._handle.getWindowSize(winSize);
+  if (!err) {
+    this.columns = winSize[0];
+    this.rows = winSize[1];
+  }
+}
+
+ObjectSetPrototypeOf(WriteStream.prototype, net.Socket.prototype);
+ObjectSetPrototypeOf(WriteStream, net.Socket);
+
+WriteStream.prototype.isTTY = true;
+
+WriteStream.prototype.getColorDepth = getColorDepth;
+
+WriteStream.prototype.hasColors = hasColors;
+
+WriteStream.prototype._refreshSize = function() {
+  const oldCols = this.columns;
+  const oldRows = this.rows;
+  const winSize = [0, 0];
+  const err = this._handle.getWindowSize(winSize);
+  if (err) {
+    this.emit('error', new ErrnoException(err, 'getWindowSize'));
+    return;
+  }
+  const { 0: newCols, 1: newRows } = winSize;
+  if (oldCols !== newCols || oldRows !== newRows) {
+    this.columns = newCols;
+    this.rows = newRows;
+    this.emit('resize');
+  }
+};
+
+// Backwards-compat
+WriteStream.prototype.cursorTo = function(x, y, callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.cursorTo(this, x, y, callback);
+};
+WriteStream.prototype.moveCursor = function(dx, dy, callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.moveCursor(this, dx, dy, callback);
+};
+WriteStream.prototype.clearLine = function(dir, callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.clearLine(this, dir, callback);
+};
+WriteStream.prototype.clearScreenDown = function(callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.clearScreenDown(this, callback);
+};
+WriteStream.prototype.getWindowSize = function() {
+  return [this.columns, this.rows];
+};
+
+module.exports = { isatty, ReadStream, WriteStream };

package/src/node-lib/util-module.ts

@@ -0,0 +1,104 @@
+/**
+ * `util`, as Node's own `lib/util.js`.
+ *
+ * What died: the engine's `util` was hand-written, 632 lines, and its
+ * `inspect` was a recursive `JSON`-ish printer. Node's own `test-util-*`: 3
+ * of 27 passed. `inspect` is not a convenience -- it is what `console.log`
+ * prints, what an `AssertionError` shows, what a thrown object reads as in a
+ * stack, and what every one of Node's own tests compares against. A
+ * hand-written one disagrees with Node in the exact places a person is
+ * reading output to find out what went wrong.
+ *
+ * What this is: Node's `lib/util.js` and `lib/internal/util/inspect.js`
+ * v22.18.0, vendored unmodified, with `internal/util`, `internal/util/
+ * comparisons`, `internal/util/debuglog` and `internal/util/colors` beside
+ * them. `format`, `inspect`, `promisify`, `callbackify`, `deprecate`,
+ * `isDeepStrictEqual`, `parseArgs`, `styleText` and the rest are Node's own
+ * code.
+ *
+ * THE ONE NAMED LOSS: `internalBinding('util')`'s `getProxyDetails` and
+ * `getPromiseDetails` are V8 introspection, and no JavaScript in a tab can
+ * answer them -- a `Proxy` is invisible to the code it wraps by design, and a
+ * promise's state cannot be read without awaiting it. So `inspect` prints a
+ * proxy as the object it stands for (which is what Node prints without
+ * `--show-proxy`) and a promise as `Promise { <pending> }` whatever it has
+ * settled to. Everything else the binding is asked for -- an object's
+ * non-index properties, a constructor's name, a Map's or a Set's entries --
+ * the engine answers for real.
+ *
+ * The rule for this file: it binds, it does not implement.
+ */
+import { lazyModule, lazyExport } from './lazy';
+
+/** What `util.inspect` takes. */
+export interface InspectOptions {
+  depth?: number | null;
+  colors?: boolean;
+  showHidden?: boolean;
+  customInspect?: boolean;
+  showProxy?: boolean;
+  maxArrayLength?: number | null;
+  maxStringLength?: number | null;
+  breakLength?: number;
+  compact?: boolean | number;
+  sorted?: boolean | ((a: string, b: string) => number);
+  getters?: boolean | 'get' | 'set';
+  numericSeparator?: boolean;
+}
+
+/** The whole of Node's `util` module object. */
+export interface UtilModule {
+  format(...args: unknown[]): string;
+  formatWithOptions(options: InspectOptions, ...args: unknown[]): string;
+  inspect: ((value: unknown, options?: InspectOptions) => string) & {
+    custom: symbol;
+    colors: Record<string, [number, number]>;
+    styles: Record<string, string>;
+    defaultOptions: InspectOptions;
+  };
+  promisify: ((fn: (...args: never[]) => void) => (...args: never[]) => Promise<unknown>) & { custom: symbol };
+  callbackify(fn: (...args: never[]) => Promise<unknown>): (...args: never[]) => void;
+  deprecate<T>(fn: T, message: string, code?: string): T;
+  debuglog(section: string, callback?: (fn: (...args: unknown[]) => void) => void): (...args: unknown[]) => void;
+  debug: UtilModule['debuglog'];
+  isDeepStrictEqual(a: unknown, b: unknown): boolean;
+  parseArgs(config?: unknown): unknown;
+  parseEnv(content: string): Record<string, string>;
+  stripVTControlCharacters(value: string): string;
+  styleText(format: string | string[], text: string, options?: unknown): string;
+  toUSVString(value: string): string;
+  transferableAbortController(): AbortController;
+  transferableAbortSignal(signal: AbortSignal): AbortSignal;
+  aborted(signal: AbortSignal, resource: object): Promise<void>;
+  getSystemErrorName(errno: number): string;
+  getSystemErrorMap(): Map<number, [string, string]>;
+  getCallSites?: (frames?: number) => unknown[];
+  types: Record<string, (value: unknown) => boolean>;
+  TextEncoder: typeof TextEncoder;
+  TextDecoder: typeof TextDecoder;
+  MIMEType: unknown;
+  MIMEParams: unknown;
+  /** Node's deprecated type tests, still exported and still read by old packages. */
+  isArray(value: unknown): boolean;
+  isDate(value: unknown): boolean;
+  isError(value: unknown): boolean;
+  isFunction(value: unknown): boolean;
+  isNullOrUndefined(value: unknown): boolean;
+  isNumber(value: unknown): boolean;
+  isObject(value: unknown): boolean;
+  isPrimitive(value: unknown): boolean;
+  isRegExp(value: unknown): boolean;
+  isString(value: unknown): boolean;
+  isUndefined(value: unknown): boolean;
+  _extend(target: object, source: object): object;
+  inherits(constructor: unknown, superConstructor: unknown): void;
+}
+
+/** Node's own `util.js`, built by the loader on the first property read. */
+export const utilModule = lazyModule<UtilModule>('util');
+
+/** The two names the engine's own parts reach for directly. */
+export const inspect = lazyExport<UtilModule['inspect']>('util', 'inspect');
+export const format = lazyExport<UtilModule['format']>('util', 'format');
+
+export default utilModule;