plugin-data-source-mssql 2.0.3 → 2.0.5

package/dist/node_modules/tedious/node_modules/readable-stream/lib/internal/streams/destroy.js

@@ -1,290 +0,0 @@
-'use strict'
-
-/* replacement start */
-
-const process = require('process/')
-
-/* replacement end */
-
-const {
-  aggregateTwoErrors,
-  codes: { ERR_MULTIPLE_CALLBACK },
-  AbortError
-} = require('../../ours/errors')
-const { Symbol } = require('../../ours/primordials')
-const { kIsDestroyed, isDestroyed, isFinished, isServerRequest } = require('./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 !== null && w !== undefined && w.destroyed) || (r !== null && r !== undefined && r.destroyed)) {
-    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.destroyed = true
-  }
-  if (r) {
-    r.destroyed = true
-  }
-
-  // If still constructing then defer calling _destroy.
-  if (!s.constructed) {
-    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.closed = true
-    }
-    if (r) {
-      r.closed = true
-    }
-    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.closeEmitted = true
-  }
-  if (r) {
-    r.closeEmitted = true
-  }
-  if ((w !== null && w !== undefined && w.emitClose) || (r !== null && r !== undefined && r.emitClose)) {
-    self.emit('close')
-  }
-}
-function emitErrorNT(self, err) {
-  const r = self._readableState
-  const w = self._writableState
-  if ((w !== null && w !== undefined && w.errorEmitted) || (r !== null && r !== undefined && r.errorEmitted)) {
-    return
-  }
-  if (w) {
-    w.errorEmitted = true
-  }
-  if (r) {
-    r.errorEmitted = true
-  }
-  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 !== null && w !== undefined && w.destroyed) || (r !== null && r !== undefined && r.destroyed)) {
-    return this
-  }
-  if ((r !== null && r !== undefined && r.autoDestroy) || (w !== null && w !== undefined && w.autoDestroy))
-    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.errored) {
-      w.errored = err
-    }
-    if (r && !r.errored) {
-      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.constructed = false
-  }
-  if (w) {
-    w.constructed = false
-  }
-  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 !== null && err !== undefined ? err : new ERR_MULTIPLE_CALLBACK())
-      return
-    }
-    called = true
-    const r = stream._readableState
-    const w = stream._writableState
-    const s = w || r
-    if (r) {
-      r.constructed = true
-    }
-    if (w) {
-      w.constructed = true
-    }
-    if (s.destroyed) {
-      stream.emit(kDestroy, err)
-    } else if (err) {
-      errorOrDestroy(stream, err, true)
-    } else {
-      process.nextTick(emitConstructNT, stream)
-    }
-  }
-  try {
-    stream._construct((err) => {
-      process.nextTick(onConstruct, err)
-    })
-  } catch (err) {
-    process.nextTick(onConstruct, err)
-  }
-}
-function emitConstructNT(stream) {
-  stream.emit(kConstruct)
-}
-function isRequest(stream) {
-  return (stream === null || stream === undefined ? undefined : 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/dist/node_modules/tedious/node_modules/readable-stream/lib/internal/streams/duplex.js

@@ -1,143 +0,0 @@
-// 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
-} = require('../../ours/primordials')
-module.exports = Duplex
-const Readable = require('./readable')
-const Writable = require('./writable')
-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]
-    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]
-  }
-}
-function Duplex(options) {
-  if (!(this instanceof Duplex)) return new Duplex(options)
-  Readable.call(this, options)
-  Writable.call(this, options)
-  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
-    }
-  } else {
-    this.allowHalfOpen = true
-  }
-}
-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 = {}
-  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) {
-  if (!duplexify) {
-    duplexify = require('./duplexify')
-  }
-  return duplexify(body, 'body')
-}