Tracking de l'application VApp (IHM du jeu)
This commit is contained in:
329
VApp/node_modules/readable-stream/lib/internal/streams/utils.js
generated
vendored
Normal file
329
VApp/node_modules/readable-stream/lib/internal/streams/utils.js
generated
vendored
Normal file
@ -0,0 +1,329 @@
|
||||
'use strict'
|
||||
|
||||
const { SymbolAsyncIterator, SymbolIterator, SymbolFor } = require('../../ours/primordials')
|
||||
|
||||
// We need to use SymbolFor to make these globally available
|
||||
// for interopt with readable-stream, i.e. readable-stream
|
||||
// and node core needs to be able to read/write private state
|
||||
// from each other for proper interoperability.
|
||||
const kIsDestroyed = SymbolFor('nodejs.stream.destroyed')
|
||||
const kIsErrored = SymbolFor('nodejs.stream.errored')
|
||||
const kIsReadable = SymbolFor('nodejs.stream.readable')
|
||||
const kIsWritable = SymbolFor('nodejs.stream.writable')
|
||||
const kIsDisturbed = SymbolFor('nodejs.stream.disturbed')
|
||||
const kIsClosedPromise = SymbolFor('nodejs.webstream.isClosedPromise')
|
||||
const kControllerErrorFunction = SymbolFor('nodejs.webstream.controllerErrorFunction')
|
||||
function isReadableNodeStream(obj, strict = false) {
|
||||
var _obj$_readableState
|
||||
return !!(
|
||||
(
|
||||
obj &&
|
||||
typeof obj.pipe === 'function' &&
|
||||
typeof obj.on === 'function' &&
|
||||
(!strict || (typeof obj.pause === 'function' && typeof obj.resume === 'function')) &&
|
||||
(!obj._writableState ||
|
||||
((_obj$_readableState = obj._readableState) === null || _obj$_readableState === undefined
|
||||
? undefined
|
||||
: _obj$_readableState.readable) !== false) &&
|
||||
// Duplex
|
||||
(!obj._writableState || obj._readableState)
|
||||
) // Writable has .pipe.
|
||||
)
|
||||
}
|
||||
|
||||
function isWritableNodeStream(obj) {
|
||||
var _obj$_writableState
|
||||
return !!(
|
||||
(
|
||||
obj &&
|
||||
typeof obj.write === 'function' &&
|
||||
typeof obj.on === 'function' &&
|
||||
(!obj._readableState ||
|
||||
((_obj$_writableState = obj._writableState) === null || _obj$_writableState === undefined
|
||||
? undefined
|
||||
: _obj$_writableState.writable) !== false)
|
||||
) // Duplex
|
||||
)
|
||||
}
|
||||
|
||||
function isDuplexNodeStream(obj) {
|
||||
return !!(
|
||||
obj &&
|
||||
typeof obj.pipe === 'function' &&
|
||||
obj._readableState &&
|
||||
typeof obj.on === 'function' &&
|
||||
typeof obj.write === 'function'
|
||||
)
|
||||
}
|
||||
function isNodeStream(obj) {
|
||||
return (
|
||||
obj &&
|
||||
(obj._readableState ||
|
||||
obj._writableState ||
|
||||
(typeof obj.write === 'function' && typeof obj.on === 'function') ||
|
||||
(typeof obj.pipe === 'function' && typeof obj.on === 'function'))
|
||||
)
|
||||
}
|
||||
function isReadableStream(obj) {
|
||||
return !!(
|
||||
obj &&
|
||||
!isNodeStream(obj) &&
|
||||
typeof obj.pipeThrough === 'function' &&
|
||||
typeof obj.getReader === 'function' &&
|
||||
typeof obj.cancel === 'function'
|
||||
)
|
||||
}
|
||||
function isWritableStream(obj) {
|
||||
return !!(obj && !isNodeStream(obj) && typeof obj.getWriter === 'function' && typeof obj.abort === 'function')
|
||||
}
|
||||
function isTransformStream(obj) {
|
||||
return !!(obj && !isNodeStream(obj) && typeof obj.readable === 'object' && typeof obj.writable === 'object')
|
||||
}
|
||||
function isWebStream(obj) {
|
||||
return isReadableStream(obj) || isWritableStream(obj) || isTransformStream(obj)
|
||||
}
|
||||
function isIterable(obj, isAsync) {
|
||||
if (obj == null) return false
|
||||
if (isAsync === true) return typeof obj[SymbolAsyncIterator] === 'function'
|
||||
if (isAsync === false) return typeof obj[SymbolIterator] === 'function'
|
||||
return typeof obj[SymbolAsyncIterator] === 'function' || typeof obj[SymbolIterator] === 'function'
|
||||
}
|
||||
function isDestroyed(stream) {
|
||||
if (!isNodeStream(stream)) return null
|
||||
const wState = stream._writableState
|
||||
const rState = stream._readableState
|
||||
const state = wState || rState
|
||||
return !!(stream.destroyed || stream[kIsDestroyed] || (state !== null && state !== undefined && state.destroyed))
|
||||
}
|
||||
|
||||
// Have been end():d.
|
||||
function isWritableEnded(stream) {
|
||||
if (!isWritableNodeStream(stream)) return null
|
||||
if (stream.writableEnded === true) return true
|
||||
const wState = stream._writableState
|
||||
if (wState !== null && wState !== undefined && wState.errored) return false
|
||||
if (typeof (wState === null || wState === undefined ? undefined : wState.ended) !== 'boolean') return null
|
||||
return wState.ended
|
||||
}
|
||||
|
||||
// Have emitted 'finish'.
|
||||
function isWritableFinished(stream, strict) {
|
||||
if (!isWritableNodeStream(stream)) return null
|
||||
if (stream.writableFinished === true) return true
|
||||
const wState = stream._writableState
|
||||
if (wState !== null && wState !== undefined && wState.errored) return false
|
||||
if (typeof (wState === null || wState === undefined ? undefined : wState.finished) !== 'boolean') return null
|
||||
return !!(wState.finished || (strict === false && wState.ended === true && wState.length === 0))
|
||||
}
|
||||
|
||||
// Have been push(null):d.
|
||||
function isReadableEnded(stream) {
|
||||
if (!isReadableNodeStream(stream)) return null
|
||||
if (stream.readableEnded === true) return true
|
||||
const rState = stream._readableState
|
||||
if (!rState || rState.errored) return false
|
||||
if (typeof (rState === null || rState === undefined ? undefined : rState.ended) !== 'boolean') return null
|
||||
return rState.ended
|
||||
}
|
||||
|
||||
// Have emitted 'end'.
|
||||
function isReadableFinished(stream, strict) {
|
||||
if (!isReadableNodeStream(stream)) return null
|
||||
const rState = stream._readableState
|
||||
if (rState !== null && rState !== undefined && rState.errored) return false
|
||||
if (typeof (rState === null || rState === undefined ? undefined : rState.endEmitted) !== 'boolean') return null
|
||||
return !!(rState.endEmitted || (strict === false && rState.ended === true && rState.length === 0))
|
||||
}
|
||||
function isReadable(stream) {
|
||||
if (stream && stream[kIsReadable] != null) return stream[kIsReadable]
|
||||
if (typeof (stream === null || stream === undefined ? undefined : stream.readable) !== 'boolean') return null
|
||||
if (isDestroyed(stream)) return false
|
||||
return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream)
|
||||
}
|
||||
function isWritable(stream) {
|
||||
if (stream && stream[kIsWritable] != null) return stream[kIsWritable]
|
||||
if (typeof (stream === null || stream === undefined ? undefined : stream.writable) !== 'boolean') return null
|
||||
if (isDestroyed(stream)) return false
|
||||
return isWritableNodeStream(stream) && stream.writable && !isWritableEnded(stream)
|
||||
}
|
||||
function isFinished(stream, opts) {
|
||||
if (!isNodeStream(stream)) {
|
||||
return null
|
||||
}
|
||||
if (isDestroyed(stream)) {
|
||||
return true
|
||||
}
|
||||
if ((opts === null || opts === undefined ? undefined : opts.readable) !== false && isReadable(stream)) {
|
||||
return false
|
||||
}
|
||||
if ((opts === null || opts === undefined ? undefined : opts.writable) !== false && isWritable(stream)) {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
function isWritableErrored(stream) {
|
||||
var _stream$_writableStat, _stream$_writableStat2
|
||||
if (!isNodeStream(stream)) {
|
||||
return null
|
||||
}
|
||||
if (stream.writableErrored) {
|
||||
return stream.writableErrored
|
||||
}
|
||||
return (_stream$_writableStat =
|
||||
(_stream$_writableStat2 = stream._writableState) === null || _stream$_writableStat2 === undefined
|
||||
? undefined
|
||||
: _stream$_writableStat2.errored) !== null && _stream$_writableStat !== undefined
|
||||
? _stream$_writableStat
|
||||
: null
|
||||
}
|
||||
function isReadableErrored(stream) {
|
||||
var _stream$_readableStat, _stream$_readableStat2
|
||||
if (!isNodeStream(stream)) {
|
||||
return null
|
||||
}
|
||||
if (stream.readableErrored) {
|
||||
return stream.readableErrored
|
||||
}
|
||||
return (_stream$_readableStat =
|
||||
(_stream$_readableStat2 = stream._readableState) === null || _stream$_readableStat2 === undefined
|
||||
? undefined
|
||||
: _stream$_readableStat2.errored) !== null && _stream$_readableStat !== undefined
|
||||
? _stream$_readableStat
|
||||
: null
|
||||
}
|
||||
function isClosed(stream) {
|
||||
if (!isNodeStream(stream)) {
|
||||
return null
|
||||
}
|
||||
if (typeof stream.closed === 'boolean') {
|
||||
return stream.closed
|
||||
}
|
||||
const wState = stream._writableState
|
||||
const rState = stream._readableState
|
||||
if (
|
||||
typeof (wState === null || wState === undefined ? undefined : wState.closed) === 'boolean' ||
|
||||
typeof (rState === null || rState === undefined ? undefined : rState.closed) === 'boolean'
|
||||
) {
|
||||
return (
|
||||
(wState === null || wState === undefined ? undefined : wState.closed) ||
|
||||
(rState === null || rState === undefined ? undefined : rState.closed)
|
||||
)
|
||||
}
|
||||
if (typeof stream._closed === 'boolean' && isOutgoingMessage(stream)) {
|
||||
return stream._closed
|
||||
}
|
||||
return null
|
||||
}
|
||||
function isOutgoingMessage(stream) {
|
||||
return (
|
||||
typeof stream._closed === 'boolean' &&
|
||||
typeof stream._defaultKeepAlive === 'boolean' &&
|
||||
typeof stream._removedConnection === 'boolean' &&
|
||||
typeof stream._removedContLen === 'boolean'
|
||||
)
|
||||
}
|
||||
function isServerResponse(stream) {
|
||||
return typeof stream._sent100 === 'boolean' && isOutgoingMessage(stream)
|
||||
}
|
||||
function isServerRequest(stream) {
|
||||
var _stream$req
|
||||
return (
|
||||
typeof stream._consuming === 'boolean' &&
|
||||
typeof stream._dumped === 'boolean' &&
|
||||
((_stream$req = stream.req) === null || _stream$req === undefined ? undefined : _stream$req.upgradeOrConnect) ===
|
||||
undefined
|
||||
)
|
||||
}
|
||||
function willEmitClose(stream) {
|
||||
if (!isNodeStream(stream)) return null
|
||||
const wState = stream._writableState
|
||||
const rState = stream._readableState
|
||||
const state = wState || rState
|
||||
return (
|
||||
(!state && isServerResponse(stream)) || !!(state && state.autoDestroy && state.emitClose && state.closed === false)
|
||||
)
|
||||
}
|
||||
function isDisturbed(stream) {
|
||||
var _stream$kIsDisturbed
|
||||
return !!(
|
||||
stream &&
|
||||
((_stream$kIsDisturbed = stream[kIsDisturbed]) !== null && _stream$kIsDisturbed !== undefined
|
||||
? _stream$kIsDisturbed
|
||||
: stream.readableDidRead || stream.readableAborted)
|
||||
)
|
||||
}
|
||||
function isErrored(stream) {
|
||||
var _ref,
|
||||
_ref2,
|
||||
_ref3,
|
||||
_ref4,
|
||||
_ref5,
|
||||
_stream$kIsErrored,
|
||||
_stream$_readableStat3,
|
||||
_stream$_writableStat3,
|
||||
_stream$_readableStat4,
|
||||
_stream$_writableStat4
|
||||
return !!(
|
||||
stream &&
|
||||
((_ref =
|
||||
(_ref2 =
|
||||
(_ref3 =
|
||||
(_ref4 =
|
||||
(_ref5 =
|
||||
(_stream$kIsErrored = stream[kIsErrored]) !== null && _stream$kIsErrored !== undefined
|
||||
? _stream$kIsErrored
|
||||
: stream.readableErrored) !== null && _ref5 !== undefined
|
||||
? _ref5
|
||||
: stream.writableErrored) !== null && _ref4 !== undefined
|
||||
? _ref4
|
||||
: (_stream$_readableStat3 = stream._readableState) === null || _stream$_readableStat3 === undefined
|
||||
? undefined
|
||||
: _stream$_readableStat3.errorEmitted) !== null && _ref3 !== undefined
|
||||
? _ref3
|
||||
: (_stream$_writableStat3 = stream._writableState) === null || _stream$_writableStat3 === undefined
|
||||
? undefined
|
||||
: _stream$_writableStat3.errorEmitted) !== null && _ref2 !== undefined
|
||||
? _ref2
|
||||
: (_stream$_readableStat4 = stream._readableState) === null || _stream$_readableStat4 === undefined
|
||||
? undefined
|
||||
: _stream$_readableStat4.errored) !== null && _ref !== undefined
|
||||
? _ref
|
||||
: (_stream$_writableStat4 = stream._writableState) === null || _stream$_writableStat4 === undefined
|
||||
? undefined
|
||||
: _stream$_writableStat4.errored)
|
||||
)
|
||||
}
|
||||
module.exports = {
|
||||
isDestroyed,
|
||||
kIsDestroyed,
|
||||
isDisturbed,
|
||||
kIsDisturbed,
|
||||
isErrored,
|
||||
kIsErrored,
|
||||
isReadable,
|
||||
kIsReadable,
|
||||
kIsClosedPromise,
|
||||
kControllerErrorFunction,
|
||||
kIsWritable,
|
||||
isClosed,
|
||||
isDuplexNodeStream,
|
||||
isFinished,
|
||||
isIterable,
|
||||
isReadableNodeStream,
|
||||
isReadableStream,
|
||||
isReadableEnded,
|
||||
isReadableFinished,
|
||||
isReadableErrored,
|
||||
isNodeStream,
|
||||
isWebStream,
|
||||
isWritable,
|
||||
isWritableNodeStream,
|
||||
isWritableStream,
|
||||
isWritableEnded,
|
||||
isWritableFinished,
|
||||
isWritableErrored,
|
||||
isServerRequest,
|
||||
isServerResponse,
|
||||
willEmitClose,
|
||||
isTransformStream
|
||||
}
|
||||
Reference in New Issue
Block a user