@volter/tabnode 0.2.14-volter.88

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

@@ -0,0 +1,361 @@
+'use strict';
+
+const {
+  Symbol,
+} = primordials;
+
+const {
+  AbortError,
+  aggregateTwoErrors,
+  codes: {
+    ERR_MULTIPLE_CALLBACK,
+  },
+} = require('internal/errors');
+const {
+  kIsDestroyed,
+  isDestroyed,
+  isFinished,
+  isServerRequest,
+  kState,
+  kErrorEmitted,
+  kEmitClose,
+  kClosed,
+  kCloseEmitted,
+  kConstructed,
+  kDestroyed,
+  kAutoDestroy,
+  kErrored,
+} = require('internal/streams/utils');
+
+const kDestroy = Symbol('kDestroy');
+const kConstruct = Symbol('kConstruct');
+
+function checkError(err, w, r) {
+  if (err) {
+    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+    err.stack; // eslint-disable-line no-unused-expressions
+
+    if (w && !w.errored) {
+      w.errored = err;
+    }
+    if (r && !r.errored) {
+      r.errored = err;
+    }
+  }
+}
+
+// Backwards compat. cb() is undocumented and unused in core but
+// unfortunately might be used by modules.
+function destroy(err, cb) {
+  const r = this._readableState;
+  const w = this._writableState;
+  // With duplex streams we use the writable side for state.
+  const s = w || r;
+
+  if (
+    (w && (w[kState] & kDestroyed) !== 0) ||
+    (r && (r[kState] & kDestroyed) !== 0)
+  ) {
+    if (typeof cb === 'function') {
+      cb();
+    }
+
+    return this;
+  }
+
+
+  // We set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
+  checkError(err, w, r);
+
+  if (w) {
+    w[kState] |= kDestroyed;
+  }
+  if (r) {
+    r[kState] |= kDestroyed;
+  }
+
+  // If still constructing then defer calling _destroy.
+  if ((s[kState] & kConstructed) === 0) {
+    this.once(kDestroy, function(er) {
+      _destroy(this, aggregateTwoErrors(er, err), cb);
+    });
+  } else {
+    _destroy(this, err, cb);
+  }
+
+  return this;
+}
+
+function _destroy(self, err, cb) {
+  let called = false;
+
+  function onDestroy(err) {
+    if (called) {
+      return;
+    }
+    called = true;
+
+    const r = self._readableState;
+    const w = self._writableState;
+
+    checkError(err, w, r);
+
+    if (w) {
+      w[kState] |= kClosed;
+    }
+    if (r) {
+      r[kState] |= kClosed;
+    }
+
+    if (typeof cb === 'function') {
+      cb(err);
+    }
+
+    if (err) {
+      process.nextTick(emitErrorCloseNT, self, err);
+    } else {
+      process.nextTick(emitCloseNT, self);
+    }
+  }
+  try {
+    self._destroy(err || null, onDestroy);
+  } catch (err) {
+    onDestroy(err);
+  }
+}
+
+function emitErrorCloseNT(self, err) {
+  emitErrorNT(self, err);
+  emitCloseNT(self);
+}
+
+function emitCloseNT(self) {
+  const r = self._readableState;
+  const w = self._writableState;
+
+  if (w) {
+    w[kState] |= kCloseEmitted;
+  }
+  if (r) {
+    r[kState] |= kCloseEmitted;
+  }
+
+  if (
+    (w && (w[kState] & kEmitClose) !== 0) ||
+    (r && (r[kState] & kEmitClose) !== 0)
+  ) {
+    self.emit('close');
+  }
+}
+
+function emitErrorNT(self, err) {
+  const r = self._readableState;
+  const w = self._writableState;
+
+  if (
+    (w && (w[kState] & kErrorEmitted) !== 0) ||
+    (r && (r[kState] & kErrorEmitted) !== 0)
+  ) {
+    return;
+  }
+
+  if (w) {
+    w[kState] |= kErrorEmitted;
+  }
+  if (r) {
+    r[kState] |= kErrorEmitted;
+  }
+
+  self.emit('error', err);
+}
+
+function undestroy() {
+  const r = this._readableState;
+  const w = this._writableState;
+
+  if (r) {
+    r.constructed = true;
+    r.closed = false;
+    r.closeEmitted = false;
+    r.destroyed = false;
+    r.errored = null;
+    r.errorEmitted = false;
+    r.reading = false;
+    r.ended = r.readable === false;
+    r.endEmitted = r.readable === false;
+  }
+
+  if (w) {
+    w.constructed = true;
+    w.destroyed = false;
+    w.closed = false;
+    w.closeEmitted = false;
+    w.errored = null;
+    w.errorEmitted = false;
+    w.finalCalled = false;
+    w.prefinished = false;
+    w.ended = w.writable === false;
+    w.ending = w.writable === false;
+    w.finished = w.writable === false;
+  }
+}
+
+function errorOrDestroy(stream, err, sync) {
+  // We have tests that rely on errors being emitted
+  // in the same tick, so changing this is semver major.
+  // For now when you opt-in to autoDestroy we allow
+  // the error to be emitted nextTick. In a future
+  // semver major update we should change the default to this.
+
+  const r = stream._readableState;
+  const w = stream._writableState;
+
+  if (
+    (w && (w[kState] ? (w[kState] & kDestroyed) !== 0 : w.destroyed)) ||
+    (r && (r[kState] ? (r[kState] & kDestroyed) !== 0 : r.destroyed))
+  ) {
+    return this;
+  }
+
+  if (
+    (r && (r[kState] & kAutoDestroy) !== 0) ||
+    (w && (w[kState] & kAutoDestroy) !== 0)
+  ) {
+    stream.destroy(err);
+  } else if (err) {
+    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+    err.stack; // eslint-disable-line no-unused-expressions
+
+    if (w && (w[kState] & kErrored) === 0) {
+      w.errored = err;
+    }
+    if (r && (r[kState] & kErrored) === 0) {
+      r.errored = err;
+    }
+    if (sync) {
+      process.nextTick(emitErrorNT, stream, err);
+    } else {
+      emitErrorNT(stream, err);
+    }
+  }
+}
+
+function construct(stream, cb) {
+  if (typeof stream._construct !== 'function') {
+    return;
+  }
+
+  const r = stream._readableState;
+  const w = stream._writableState;
+
+  if (r) {
+    r[kState] &= ~kConstructed;
+  }
+  if (w) {
+    w[kState] &= ~kConstructed;
+  }
+
+  stream.once(kConstruct, cb);
+
+  if (stream.listenerCount(kConstruct) > 1) {
+    // Duplex
+    return;
+  }
+
+  process.nextTick(constructNT, stream);
+}
+
+function constructNT(stream) {
+  let called = false;
+
+  function onConstruct(err) {
+    if (called) {
+      errorOrDestroy(stream, err ?? new ERR_MULTIPLE_CALLBACK());
+      return;
+    }
+    called = true;
+
+    const r = stream._readableState;
+    const w = stream._writableState;
+    const s = w || r;
+
+    if (r) {
+      r[kState] |= kConstructed;
+    }
+    if (w) {
+      w[kState] |= kConstructed;
+    }
+
+    if (s.destroyed) {
+      stream.emit(kDestroy, err);
+    } else if (err) {
+      errorOrDestroy(stream, err, true);
+    } else {
+      stream.emit(kConstruct);
+    }
+  }
+
+  try {
+    stream._construct((err) => {
+      process.nextTick(onConstruct, err);
+    });
+  } catch (err) {
+    process.nextTick(onConstruct, err);
+  }
+}
+
+function isRequest(stream) {
+  return stream?.setHeader && typeof stream.abort === 'function';
+}
+
+function emitCloseLegacy(stream) {
+  stream.emit('close');
+}
+
+function emitErrorCloseLegacy(stream, err) {
+  stream.emit('error', err);
+  process.nextTick(emitCloseLegacy, stream);
+}
+
+// Normalize destroy for legacy.
+function destroyer(stream, err) {
+  if (!stream || isDestroyed(stream)) {
+    return;
+  }
+
+  if (!err && !isFinished(stream)) {
+    err = new AbortError();
+  }
+
+  // TODO: Remove isRequest branches.
+  if (isServerRequest(stream)) {
+    stream.socket = null;
+    stream.destroy(err);
+  } else if (isRequest(stream)) {
+    stream.abort();
+  } else if (isRequest(stream.req)) {
+    stream.req.abort();
+  } else if (typeof stream.destroy === 'function') {
+    stream.destroy(err);
+  } else if (typeof stream.close === 'function') {
+    // TODO: Don't lose err?
+    stream.close();
+  } else if (err) {
+    process.nextTick(emitErrorCloseLegacy, stream, err);
+  } else {
+    process.nextTick(emitCloseLegacy, stream);
+  }
+
+  if (!stream.destroyed) {
+    stream[kIsDestroyed] = true;
+  }
+}
+
+module.exports = {
+  construct,
+  destroyer,
+  destroy,
+  undestroy,
+  errorOrDestroy,
+};

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

@@ -0,0 +1,203 @@
+// 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.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototype inheritance, this class
+// prototypically inherits from Readable, and then parasitically from
+// Writable.
+
+'use strict';
+
+const {
+  ObjectDefineProperties,
+  ObjectGetOwnPropertyDescriptor,
+  ObjectKeys,
+  ObjectSetPrototypeOf,
+} = primordials;
+
+module.exports = Duplex;
+
+const Stream = require('internal/streams/legacy').Stream;
+const Readable = require('internal/streams/readable');
+const Writable = require('internal/streams/writable');
+
+const {
+  addAbortSignal,
+} = require('internal/streams/add-abort-signal');
+
+const destroyImpl = require('internal/streams/destroy');
+const { kOnConstructed } = require('internal/streams/utils');
+
+ObjectSetPrototypeOf(Duplex.prototype, Readable.prototype);
+ObjectSetPrototypeOf(Duplex, Readable);
+
+{
+  const keys = ObjectKeys(Writable.prototype);
+  // Allow the keys array to be GC'ed.
+  for (let i = 0; i < keys.length; i++) {
+    const method = keys[i];
+    Duplex.prototype[method] ||= Writable.prototype[method];
+  }
+}
+
+// Use the `destroy` method of `Writable`.
+Duplex.prototype.destroy = Writable.prototype.destroy;
+
+function Duplex(options) {
+  if (!(this instanceof Duplex))
+    return new Duplex(options);
+
+  this._events ??= {
+    close: undefined,
+    error: undefined,
+    prefinish: undefined,
+    finish: undefined,
+    drain: undefined,
+    data: undefined,
+    end: undefined,
+    readable: undefined,
+    // Skip uncommon events...
+    // pause: undefined,
+    // resume: undefined,
+    // pipe: undefined,
+    // unpipe: undefined,
+    // [destroyImpl.kConstruct]: undefined,
+    // [destroyImpl.kDestroy]: undefined,
+  };
+
+  this._readableState = new Readable.ReadableState(options, this, true);
+  this._writableState = new Writable.WritableState(options, this, true);
+
+  if (options) {
+    this.allowHalfOpen = options.allowHalfOpen !== false;
+
+    if (options.readable === false) {
+      this._readableState.readable = false;
+      this._readableState.ended = true;
+      this._readableState.endEmitted = true;
+    }
+
+    if (options.writable === false) {
+      this._writableState.writable = false;
+      this._writableState.ending = true;
+      this._writableState.ended = true;
+      this._writableState.finished = true;
+    }
+
+    if (typeof options.read === 'function')
+      this._read = options.read;
+
+    if (typeof options.write === 'function')
+      this._write = options.write;
+
+    if (typeof options.writev === 'function')
+      this._writev = options.writev;
+
+    if (typeof options.destroy === 'function')
+      this._destroy = options.destroy;
+
+    if (typeof options.final === 'function')
+      this._final = options.final;
+
+    if (typeof options.construct === 'function')
+      this._construct = options.construct;
+
+    if (options.signal)
+      addAbortSignal(options.signal, this);
+  } else {
+    this.allowHalfOpen = true;
+  }
+
+  Stream.call(this, options);
+
+  if (this._construct != null) {
+    destroyImpl.construct(this, () => {
+      this._readableState[kOnConstructed](this);
+      this._writableState[kOnConstructed](this);
+    });
+  }
+}
+
+ObjectDefineProperties(Duplex.prototype, {
+  writable:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writable') },
+  writableHighWaterMark:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableHighWaterMark') },
+  writableObjectMode:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableObjectMode') },
+  writableBuffer:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableBuffer') },
+  writableLength:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableLength') },
+  writableFinished:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableFinished') },
+  writableCorked:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableCorked') },
+  writableEnded:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableEnded') },
+  writableNeedDrain:
+    { __proto__: null, ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableNeedDrain') },
+
+  destroyed: {
+    __proto__: null,
+    get() {
+      if (this._readableState === undefined ||
+        this._writableState === undefined) {
+        return false;
+      }
+      return this._readableState.destroyed && this._writableState.destroyed;
+    },
+    set(value) {
+      // Backward compatibility, the user is explicitly
+      // managing destroyed.
+      if (this._readableState && this._writableState) {
+        this._readableState.destroyed = value;
+        this._writableState.destroyed = value;
+      }
+    },
+  },
+});
+
+let webStreamsAdapters;
+
+// Lazy to avoid circular references
+function lazyWebStreams() {
+  if (webStreamsAdapters === undefined)
+    webStreamsAdapters = require('internal/webstreams/adapters');
+  return webStreamsAdapters;
+}
+
+Duplex.fromWeb = function(pair, options) {
+  return lazyWebStreams().newStreamDuplexFromReadableWritablePair(
+    pair,
+    options);
+};
+
+Duplex.toWeb = function(duplex) {
+  return lazyWebStreams().newReadableWritablePairFromDuplex(duplex);
+};
+
+let duplexify;
+
+Duplex.from = function(body) {
+  duplexify ??= require('internal/streams/duplexify');
+  return duplexify(body, 'body');
+};