@volter/tabnode 0.2.14-volter.88

package/src/node-lib/internal/streams/end-of-stream.js

@@ -0,0 +1,331 @@
+// Ported from https://github.com/mafintosh/end-of-stream with
+// permission from the author, Mathias Buus (@mafintosh).
+
+'use strict';
+
+const {
+  Promise,
+  PromisePrototypeThen,
+} = primordials;
+
+const {
+  AbortError,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_STREAM_PREMATURE_CLOSE,
+  },
+} = require('internal/errors');
+const {
+  kEmptyObject,
+  once,
+  SymbolDispose,
+} = require('internal/util');
+const {
+  validateAbortSignal,
+  validateFunction,
+  validateObject,
+  validateBoolean,
+} = require('internal/validators');
+
+const {
+  isClosed,
+  isReadable,
+  isReadableNodeStream,
+  isReadableStream,
+  isReadableFinished,
+  isReadableErrored,
+  isWritable,
+  isWritableNodeStream,
+  isWritableStream,
+  isWritableFinished,
+  isWritableErrored,
+  isNodeStream,
+  willEmitClose: _willEmitClose,
+  kIsClosedPromise,
+} = require('internal/streams/utils');
+
+// Lazy load
+let AsyncLocalStorage;
+let addAbortListener;
+
+function isRequest(stream) {
+  return stream.setHeader && typeof stream.abort === 'function';
+}
+
+const nop = () => {};
+
+function eos(stream, options, callback) {
+  if (arguments.length === 2) {
+    callback = options;
+    options = kEmptyObject;
+  } else if (options == null) {
+    options = kEmptyObject;
+  } else {
+    validateObject(options, 'options');
+  }
+  validateFunction(callback, 'callback');
+  validateAbortSignal(options.signal, 'options.signal');
+
+  AsyncLocalStorage ??= require('async_hooks').AsyncLocalStorage;
+  callback = once(AsyncLocalStorage.bind(callback));
+
+  if (isReadableStream(stream) || isWritableStream(stream)) {
+    return eosWeb(stream, options, callback);
+  }
+
+  if (!isNodeStream(stream)) {
+    throw new ERR_INVALID_ARG_TYPE('stream', ['ReadableStream', 'WritableStream', 'Stream'], stream);
+  }
+
+  const readable = options.readable ?? isReadableNodeStream(stream);
+  const writable = options.writable ?? isWritableNodeStream(stream);
+
+  const wState = stream._writableState;
+  const rState = stream._readableState;
+
+  const onlegacyfinish = () => {
+    if (!stream.writable) {
+      onfinish();
+    }
+  };
+
+  // TODO (ronag): Improve soft detection to include core modules and
+  // common ecosystem modules that do properly emit 'close' but fail
+  // this generic check.
+  let willEmitClose = (
+    _willEmitClose(stream) &&
+    isReadableNodeStream(stream) === readable &&
+    isWritableNodeStream(stream) === writable
+  );
+
+  let writableFinished = isWritableFinished(stream, false);
+  const onfinish = () => {
+    writableFinished = true;
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) {
+      willEmitClose = false;
+    }
+
+    if (willEmitClose && (!stream.readable || readable)) {
+      return;
+    }
+
+    if (!readable || readableFinished) {
+      callback.call(stream);
+    }
+  };
+
+  let readableFinished = isReadableFinished(stream, false);
+  const onend = () => {
+    readableFinished = true;
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) {
+      willEmitClose = false;
+    }
+
+    if (willEmitClose && (!stream.writable || writable)) {
+      return;
+    }
+
+    if (!writable || writableFinished) {
+      callback.call(stream);
+    }
+  };
+
+  const onerror = (err) => {
+    callback.call(stream, err);
+  };
+
+  let closed = isClosed(stream);
+
+  const onclose = () => {
+    closed = true;
+
+    const errored = isWritableErrored(stream) || isReadableErrored(stream);
+
+    if (errored && typeof errored !== 'boolean') {
+      return callback.call(stream, errored);
+    }
+
+    if (readable && !readableFinished && isReadableNodeStream(stream, true)) {
+      if (!isReadableFinished(stream, false))
+        return callback.call(stream,
+                             new ERR_STREAM_PREMATURE_CLOSE());
+    }
+    if (writable && !writableFinished) {
+      if (!isWritableFinished(stream, false))
+        return callback.call(stream,
+                             new ERR_STREAM_PREMATURE_CLOSE());
+    }
+
+    callback.call(stream);
+  };
+
+  const onclosed = () => {
+    closed = true;
+
+    const errored = isWritableErrored(stream) || isReadableErrored(stream);
+
+    if (errored && typeof errored !== 'boolean') {
+      return callback.call(stream, errored);
+    }
+
+    callback.call(stream);
+  };
+
+  const onrequest = () => {
+    stream.req.on('finish', onfinish);
+  };
+
+  if (isRequest(stream)) {
+    stream.on('complete', onfinish);
+    if (!willEmitClose) {
+      stream.on('abort', onclose);
+    }
+    if (stream.req) {
+      onrequest();
+    } else {
+      stream.on('request', onrequest);
+    }
+  } else if (writable && !wState) { // legacy streams
+    stream.on('end', onlegacyfinish);
+    stream.on('close', onlegacyfinish);
+  }
+
+  // Not all streams will emit 'close' after 'aborted'.
+  if (!willEmitClose && typeof stream.aborted === 'boolean') {
+    stream.on('aborted', onclose);
+  }
+
+  stream.on('end', onend);
+  stream.on('finish', onfinish);
+  if (options.error !== false) {
+    stream.on('error', onerror);
+  }
+  stream.on('close', onclose);
+
+  if (closed) {
+    process.nextTick(onclose);
+  } else if (wState?.errorEmitted || rState?.errorEmitted) {
+    if (!willEmitClose) {
+      process.nextTick(onclosed);
+    }
+  } else if (
+    !readable &&
+    (!willEmitClose || isReadable(stream)) &&
+    (writableFinished || isWritable(stream) === false) &&
+    (wState == null || wState.pendingcb === undefined || wState.pendingcb === 0)
+  ) {
+    process.nextTick(onclosed);
+  } else if (
+    !writable &&
+    (!willEmitClose || isWritable(stream)) &&
+    (readableFinished || isReadable(stream) === false)
+  ) {
+    process.nextTick(onclosed);
+  } else if ((rState && stream.req && stream.aborted)) {
+    process.nextTick(onclosed);
+  }
+
+  const cleanup = () => {
+    callback = nop;
+    stream.removeListener('aborted', onclose);
+    stream.removeListener('complete', onfinish);
+    stream.removeListener('abort', onclose);
+    stream.removeListener('request', onrequest);
+    if (stream.req) stream.req.removeListener('finish', onfinish);
+    stream.removeListener('end', onlegacyfinish);
+    stream.removeListener('close', onlegacyfinish);
+    stream.removeListener('finish', onfinish);
+    stream.removeListener('end', onend);
+    stream.removeListener('error', onerror);
+    stream.removeListener('close', onclose);
+  };
+
+  if (options.signal && !closed) {
+    const abort = () => {
+      // Keep it because cleanup removes it.
+      const endCallback = callback;
+      cleanup();
+      endCallback.call(
+        stream,
+        new AbortError(undefined, { cause: options.signal.reason }));
+    };
+    if (options.signal.aborted) {
+      process.nextTick(abort);
+    } else {
+      addAbortListener ??= require('internal/events/abort_listener').addAbortListener;
+      const disposable = addAbortListener(options.signal, abort);
+      const originalCallback = callback;
+      callback = once((...args) => {
+        disposable[SymbolDispose]();
+        originalCallback.apply(stream, args);
+      });
+    }
+  }
+
+  return cleanup;
+}
+
+function eosWeb(stream, options, callback) {
+  let isAborted = false;
+  let abort = nop;
+  if (options.signal) {
+    abort = () => {
+      isAborted = true;
+      callback.call(stream, new AbortError(undefined, { cause: options.signal.reason }));
+    };
+    if (options.signal.aborted) {
+      process.nextTick(abort);
+    } else {
+      addAbortListener ??= require('internal/events/abort_listener').addAbortListener;
+      const disposable = addAbortListener(options.signal, abort);
+      const originalCallback = callback;
+      callback = once((...args) => {
+        disposable[SymbolDispose]();
+        originalCallback.apply(stream, args);
+      });
+    }
+  }
+  const resolverFn = (...args) => {
+    if (!isAborted) {
+      process.nextTick(() => callback.apply(stream, args));
+    }
+  };
+  PromisePrototypeThen(
+    stream[kIsClosedPromise].promise,
+    resolverFn,
+    resolverFn,
+  );
+  return nop;
+}
+
+function finished(stream, opts) {
+  let autoCleanup = false;
+  if (opts === null) {
+    opts = kEmptyObject;
+  }
+  if (opts?.cleanup) {
+    validateBoolean(opts.cleanup, 'cleanup');
+    autoCleanup = opts.cleanup;
+  }
+  return new Promise((resolve, reject) => {
+    const cleanup = eos(stream, opts, (err) => {
+      if (autoCleanup) {
+        cleanup();
+      }
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+module.exports = eos;
+module.exports.finished = finished;

package/src/node-lib/internal/streams/from.js

@@ -0,0 +1,208 @@
+'use strict';
+
+const {
+  PromisePrototypeThen,
+  SymbolAsyncIterator,
+  SymbolIterator,
+} = primordials;
+const { Buffer } = require('buffer');
+
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_STREAM_NULL_VALUES,
+} = require('internal/errors').codes;
+
+function from(Readable, iterable, opts) {
+  let iterator;
+  if (typeof iterable === 'string' || iterable instanceof Buffer) {
+    return new Readable({
+      objectMode: true,
+      ...opts,
+      read() {
+        this.push(iterable);
+        this.push(null);
+      },
+    });
+  }
+
+  let isAsync;
+  if (iterable?.[SymbolAsyncIterator]) {
+    isAsync = true;
+    iterator = iterable[SymbolAsyncIterator]();
+  } else if (iterable?.[SymbolIterator]) {
+    isAsync = false;
+    iterator = iterable[SymbolIterator]();
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
+  }
+
+
+  const readable = new Readable({
+    objectMode: true,
+    highWaterMark: 1,
+    // TODO(ronag): What options should be allowed?
+    ...opts,
+  });
+
+  // Flag to protect against _read
+  // being called before last iteration completion.
+  let reading = false;
+  let isAsyncValues = false;
+
+  readable._read = function() {
+    if (!reading) {
+      reading = true;
+
+      if (isAsync) {
+        nextAsync();
+      } else if (isAsyncValues) {
+        nextSyncWithAsyncValues();
+      } else {
+        nextSyncWithSyncValues();
+      }
+    }
+  };
+
+  readable._destroy = function(error, cb) {
+    PromisePrototypeThen(
+      close(error),
+      () => process.nextTick(cb, error), // nextTick is here in case cb throws
+      (e) => process.nextTick(cb, e || error),
+    );
+  };
+
+  async function close(error) {
+    const hadError = (error !== undefined) && (error !== null);
+    const hasThrow = typeof iterator.throw === 'function';
+    if (hadError && hasThrow) {
+      const { value, done } = await iterator.throw(error);
+      await value;
+      if (done) {
+        return;
+      }
+    }
+    if (typeof iterator.return === 'function') {
+      const { value } = await iterator.return();
+      await value;
+    }
+  }
+
+  // There are a lot of duplication here, it's done on purpose for performance
+  // reasons - avoid await when not needed.
+
+  function nextSyncWithSyncValues() {
+    for (;;) {
+      try {
+        const { value, done } = iterator.next();
+
+        if (done) {
+          readable.push(null);
+          return;
+        }
+
+        if (value &&
+          typeof value.then === 'function') {
+          return changeToAsyncValues(value);
+        }
+
+        if (value === null) {
+          reading = false;
+          throw new ERR_STREAM_NULL_VALUES();
+        }
+
+        if (readable.push(value)) {
+          continue;
+        }
+
+        reading = false;
+      } catch (err) {
+        readable.destroy(err);
+      }
+      break;
+    }
+  }
+
+  async function changeToAsyncValues(value) {
+    isAsyncValues = true;
+
+    try {
+      const res = await value;
+
+      if (res === null) {
+        reading = false;
+        throw new ERR_STREAM_NULL_VALUES();
+      }
+
+      if (readable.push(res)) {
+        nextSyncWithAsyncValues();
+        return;
+      }
+
+      reading = false;
+    } catch (err) {
+      readable.destroy(err);
+    }
+  }
+
+  async function nextSyncWithAsyncValues() {
+    for (;;) {
+      try {
+        const { value, done } = iterator.next();
+
+        if (done) {
+          readable.push(null);
+          return;
+        }
+
+        const res = (value &&
+          typeof value.then === 'function') ?
+          await value :
+          value;
+
+        if (res === null) {
+          reading = false;
+          throw new ERR_STREAM_NULL_VALUES();
+        }
+
+        if (readable.push(res)) {
+          continue;
+        }
+
+        reading = false;
+      } catch (err) {
+        readable.destroy(err);
+      }
+      break;
+    }
+  }
+
+  async function nextAsync() {
+    for (;;) {
+      try {
+        const { value, done } = await iterator.next();
+
+        if (done) {
+          readable.push(null);
+          return;
+        }
+
+        if (value === null) {
+          reading = false;
+          throw new ERR_STREAM_NULL_VALUES();
+        }
+
+        if (readable.push(value)) {
+          continue;
+        }
+
+        reading = false;
+      } catch (err) {
+        readable.destroy(err);
+      }
+      break;
+    }
+  }
+  return readable;
+}
+
+module.exports = from;

package/src/node-lib/internal/streams/lazy_transform.js

@@ -0,0 +1,57 @@
+// LazyTransform is a special type of Transform stream that is lazily loaded.
+// This is used for performance with bi-API-ship: when two APIs are available
+// for the stream, one conventional and one non-conventional.
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectSetPrototypeOf,
+} = primordials;
+
+const stream = require('stream');
+
+module.exports = LazyTransform;
+
+function LazyTransform(options) {
+  this._options = options;
+}
+ObjectSetPrototypeOf(LazyTransform.prototype, stream.Transform.prototype);
+ObjectSetPrototypeOf(LazyTransform, stream.Transform);
+
+function makeGetter(name) {
+  return function() {
+    stream.Transform.call(this, this._options);
+    this._writableState.decodeStrings = false;
+    return this[name];
+  };
+}
+
+function makeSetter(name) {
+  return function(val) {
+    ObjectDefineProperty(this, name, {
+      __proto__: null,
+      value: val,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    });
+  };
+}
+
+ObjectDefineProperties(LazyTransform.prototype, {
+  _readableState: {
+    __proto__: null,
+    get: makeGetter('_readableState'),
+    set: makeSetter('_readableState'),
+    configurable: true,
+    enumerable: true,
+  },
+  _writableState: {
+    __proto__: null,
+    get: makeGetter('_writableState'),
+    set: makeSetter('_writableState'),
+    configurable: true,
+    enumerable: true,
+  },
+});

package/src/node-lib/internal/streams/legacy.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const {
+  ArrayIsArray,
+  ObjectSetPrototypeOf,
+  ReflectOwnKeys,
+} = primordials;
+
+const EE = require('events');
+
+function Stream(opts) {
+  EE.call(this, opts);
+}
+ObjectSetPrototypeOf(Stream.prototype, EE.prototype);
+ObjectSetPrototypeOf(Stream, EE);
+
+Stream.prototype.pipe = function(dest, options) {
+  const source = this;
+
+  function ondata(chunk) {
+    if (dest.writable && dest.write(chunk) === false && source.pause) {
+      source.pause();
+    }
+  }
+
+  source.on('data', ondata);
+
+  function ondrain() {
+    if (source.readable && source.resume) {
+      source.resume();
+    }
+  }
+
+  dest.on('drain', ondrain);
+
+  // If the 'end' option is not supplied, dest.end() will be called when
+  // source gets the 'end' or 'close' events.  Only dest.end() once.
+  if (!dest._isStdio && (!options || options.end !== false)) {
+    source.on('end', onend);
+    source.on('close', onclose);
+  }
+
+  let didOnEnd = false;
+  function onend() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    dest.end();
+  }
+
+
+  function onclose() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    if (typeof dest.destroy === 'function') dest.destroy();
+  }
+
+  // Don't leave dangling pipes when there are errors.
+  function onerror(er) {
+    cleanup();
+    if (EE.listenerCount(this, 'error') === 0) {
+      this.emit('error', er);
+    }
+  }
+
+  prependListener(source, 'error', onerror);
+  prependListener(dest, 'error', onerror);
+
+  // Remove all the event listeners that were added.
+  function cleanup() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+
+    source.removeListener('end', onend);
+    source.removeListener('close', onclose);
+
+    source.removeListener('error', onerror);
+    dest.removeListener('error', onerror);
+
+    source.removeListener('end', cleanup);
+    source.removeListener('close', cleanup);
+
+    dest.removeListener('close', cleanup);
+  }
+
+  source.on('end', cleanup);
+  source.on('close', cleanup);
+
+  dest.on('close', cleanup);
+  dest.emit('pipe', source);
+
+  // Allow for unix-like usage: A.pipe(B).pipe(C)
+  return dest;
+};
+
+Stream.prototype.eventNames = function eventNames() {
+  const names = [];
+  for (const key of ReflectOwnKeys(this._events)) {
+    if (typeof this._events[key] === 'function' || (ArrayIsArray(this._events[key]) && this._events[key].length > 0)) {
+      names.push(key);
+    }
+  }
+  return names;
+};
+
+function prependListener(emitter, event, fn) {
+  // Sadly this is not cacheable as some libraries bundle their own
+  // event emitter implementation with them.
+  if (typeof emitter.prependListener === 'function')
+    return emitter.prependListener(event, fn);
+
+  // This is a hack to make sure that our error handler is attached before any
+  // userland ones.  NEVER DO THIS. This is here only because this code needs
+  // to continue to work with older versions of Node.js that do not include
+  // the prependListener() method. The goal is to eventually remove this hack.
+  if (!emitter._events || !emitter._events[event])
+    emitter.on(event, fn);
+  else if (ArrayIsArray(emitter._events[event]))
+    emitter._events[event].unshift(fn);
+  else
+    emitter._events[event] = [fn, emitter._events[event]];
+}
+
+module.exports = { Stream, prependListener };