git commit -m "Code-lab-web"

Author: plazadevina

node/trace_events.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const {
+  ArrayPrototypeJoin,
+  SafeSet,
+} = primordials;
+
+const { hasTracing } = internalBinding('config');
+
+const kMaxTracingCount = 10;
+
+const {
+  ERR_TRACE_EVENTS_CATEGORY_REQUIRED,
+  ERR_TRACE_EVENTS_UNAVAILABLE,
+} = require('internal/errors').codes;
+
+const { ownsProcessState } = require('internal/worker');
+if (!hasTracing || !ownsProcessState)
+  throw new ERR_TRACE_EVENTS_UNAVAILABLE();
+
+const { CategorySet, getEnabledCategories } = internalBinding('trace_events');
+const { customInspectSymbol } = require('internal/util');
+const { format } = require('internal/util/inspect');
+const {
+  validateObject,
+  validateStringArray,
+} = require('internal/validators');
+
+const enabledTracingObjects = new SafeSet();
+
+class Tracing {
+  #handle;
+  #categories;
+  #enabled = false;
+
+  constructor(categories) {
+    this.#handle = new CategorySet(categories);
+    this.#categories = categories;
+  }
+
+  enable() {
+    if (!this.#enabled) {
+      this.#enabled = true;
+      this.#handle.enable();
+      enabledTracingObjects.add(this);
+      if (enabledTracingObjects.size > kMaxTracingCount) {
+        process.emitWarning(
+          'Possible trace_events memory leak detected. There are more than ' +
+          `${kMaxTracingCount} enabled Tracing objects.`,
+        );
+      }
+    }
+  }
+
+  disable() {
+    if (this.#enabled) {
+      this.#enabled = false;
+      this.#handle.disable();
+      enabledTracingObjects.delete(this);
+    }
+  }
+
+  get enabled() {
+    return this.#enabled;
+  }
+
+  get categories() {
+    return ArrayPrototypeJoin(this.#categories, ',');
+  }
+
+  [customInspectSymbol](depth, opts) {
+    if (typeof depth === 'number' && depth < 0)
+      return this;
+
+    const obj = {
+      enabled: this.enabled,
+      categories: this.categories,
+    };
+    return `Tracing ${format(obj)}`;
+  }
+}
+
+function createTracing(options) {
+  validateObject(options, 'options');
+  validateStringArray(options.categories, 'options.categories');
+
+  if (options.categories.length <= 0)
+    throw new ERR_TRACE_EVENTS_CATEGORY_REQUIRED();
+
+  return new Tracing(options.categories);
+}
+
+module.exports = {
+  createTracing,
+  getEnabledCategories,
+};

node/tty.js

@@ -0,0 +1,147 @@
+'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 };