mirror of
https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools.git
synced 2025-09-15 04:17:22 +00:00
278 lines
11 KiB
JavaScript
278 lines
11 KiB
JavaScript
const { EventEmitter } = require('events')
|
|
const STREAM_DESTROYED = new Error('Stream was destroyed')
|
|
const PREMATURE_CLOSE = new Error('Premature close')
|
|
|
|
const FIFO = require('fast-fifo')
|
|
const TextDecoder = require('text-decoder')
|
|
|
|
// if we do a future major, expect queue microtask to be there always, for now a bit defensive
|
|
const qmt = typeof queueMicrotask === 'undefined' ? fn => global.process.nextTick(fn) : queueMicrotask
|
|
|
|
/* eslint-disable no-multi-spaces */
|
|
|
|
// 29 bits used total (4 from shared, 14 from read, and 11 from write)
|
|
const MAX = ((1 << 29) - 1)
|
|
|
|
// Shared state
|
|
const OPENING = 0b0001
|
|
const PREDESTROYING = 0b0010
|
|
const DESTROYING = 0b0100
|
|
const DESTROYED = 0b1000
|
|
|
|
const NOT_OPENING = MAX ^ OPENING
|
|
const NOT_PREDESTROYING = MAX ^ PREDESTROYING
|
|
|
|
// Read state (4 bit offset from shared state)
|
|
const READ_ACTIVE = 0b00000000000001 << 4
|
|
const READ_UPDATING = 0b00000000000010 << 4
|
|
const READ_PRIMARY = 0b00000000000100 << 4
|
|
const READ_QUEUED = 0b00000000001000 << 4
|
|
const READ_RESUMED = 0b00000000010000 << 4
|
|
const READ_PIPE_DRAINED = 0b00000000100000 << 4
|
|
const READ_ENDING = 0b00000001000000 << 4
|
|
const READ_EMIT_DATA = 0b00000010000000 << 4
|
|
const READ_EMIT_READABLE = 0b00000100000000 << 4
|
|
const READ_EMITTED_READABLE = 0b00001000000000 << 4
|
|
const READ_DONE = 0b00010000000000 << 4
|
|
const READ_NEXT_TICK = 0b00100000000000 << 4
|
|
const READ_NEEDS_PUSH = 0b01000000000000 << 4
|
|
const READ_READ_AHEAD = 0b10000000000000 << 4
|
|
|
|
// Combined read state
|
|
const READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED
|
|
const READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH
|
|
const READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE
|
|
const READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED
|
|
const READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD
|
|
|
|
const READ_NOT_ACTIVE = MAX ^ READ_ACTIVE
|
|
const READ_NON_PRIMARY = MAX ^ READ_PRIMARY
|
|
const READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH)
|
|
const READ_PUSHED = MAX ^ READ_NEEDS_PUSH
|
|
const READ_PAUSED = MAX ^ READ_RESUMED
|
|
const READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE)
|
|
const READ_NOT_ENDING = MAX ^ READ_ENDING
|
|
const READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING
|
|
const READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK
|
|
const READ_NOT_UPDATING = MAX ^ READ_UPDATING
|
|
const READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD
|
|
const READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD
|
|
|
|
// Write state (18 bit offset, 4 bit offset from shared state and 14 from read state)
|
|
const WRITE_ACTIVE = 0b00000000001 << 18
|
|
const WRITE_UPDATING = 0b00000000010 << 18
|
|
const WRITE_PRIMARY = 0b00000000100 << 18
|
|
const WRITE_QUEUED = 0b00000001000 << 18
|
|
const WRITE_UNDRAINED = 0b00000010000 << 18
|
|
const WRITE_DONE = 0b00000100000 << 18
|
|
const WRITE_EMIT_DRAIN = 0b00001000000 << 18
|
|
const WRITE_NEXT_TICK = 0b00010000000 << 18
|
|
const WRITE_WRITING = 0b00100000000 << 18
|
|
const WRITE_FINISHING = 0b01000000000 << 18
|
|
const WRITE_CORKED = 0b10000000000 << 18
|
|
|
|
const WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING)
|
|
const WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY
|
|
const WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING)
|
|
const WRITE_DRAINED = MAX ^ WRITE_UNDRAINED
|
|
const WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED
|
|
const WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK
|
|
const WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING
|
|
const WRITE_NOT_CORKED = MAX ^ WRITE_CORKED
|
|
|
|
// Combined shared state
|
|
const ACTIVE = READ_ACTIVE | WRITE_ACTIVE
|
|
const NOT_ACTIVE = MAX ^ ACTIVE
|
|
const DONE = READ_DONE | WRITE_DONE
|
|
const DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING
|
|
const OPEN_STATUS = DESTROY_STATUS | OPENING
|
|
const AUTO_DESTROY = DESTROY_STATUS | DONE
|
|
const NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY
|
|
const ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK
|
|
const TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE
|
|
const IS_OPENING = OPEN_STATUS | TICKING
|
|
|
|
// Combined shared state and read state
|
|
const READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE
|
|
const READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED
|
|
const READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED
|
|
const READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE
|
|
const SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD
|
|
const READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE
|
|
const READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY
|
|
const READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING
|
|
|
|
// Combined write state
|
|
const WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE
|
|
const WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED
|
|
const WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE
|
|
const WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE
|
|
const WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED
|
|
const WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE
|
|
const WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING
|
|
const WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE
|
|
const WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE
|
|
const WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY
|
|
const WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS
|
|
|
|
const asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator')
|
|
|
|
class WritableState {
|
|
constructor (stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
|
|
this.stream = stream
|
|
this.queue = new FIFO()
|
|
this.highWaterMark = highWaterMark
|
|
this.buffered = 0
|
|
this.error = null
|
|
this.pipeline = null
|
|
this.drains = null // if we add more seldomly used helpers we might them into a subobject so its a single ptr
|
|
this.byteLength = byteLengthWritable || byteLength || defaultByteLength
|
|
this.map = mapWritable || map
|
|
this.afterWrite = afterWrite.bind(this)
|
|
this.afterUpdateNextTick = updateWriteNT.bind(this)
|
|
}
|
|
|
|
get ended () {
|
|
return (this.stream._duplexState & WRITE_DONE) !== 0
|
|
}
|
|
|
|
push (data) {
|
|
if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0) return false
|
|
if (this.map !== null) data = this.map(data)
|
|
|
|
this.buffered += this.byteLength(data)
|
|
this.queue.push(data)
|
|
|
|
if (this.buffered < this.highWaterMark) {
|
|
this.stream._duplexState |= WRITE_QUEUED
|
|
return true
|
|
}
|
|
|
|
this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED
|
|
return false
|
|
}
|
|
|
|
shift () {
|
|
const data = this.queue.shift()
|
|
|
|
this.buffered -= this.byteLength(data)
|
|
if (this.buffered === 0) this.stream._duplexState &= WRITE_NOT_QUEUED
|
|
|
|
return data
|
|
}
|
|
|
|
end (data) {
|
|
if (typeof data === 'function') this.stream.once('finish', data)
|
|
else if (data !== undefined && data !== null) this.push(data)
|
|
this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY
|
|
}
|
|
|
|
autoBatch (data, cb) {
|
|
const buffer = []
|
|
const stream = this.stream
|
|
|
|
buffer.push(data)
|
|
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
|
|
buffer.push(stream._writableState.shift())
|
|
}
|
|
|
|
if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null)
|
|
stream._writev(buffer, cb)
|
|
}
|
|
|
|
update () {
|
|
const stream = this.stream
|
|
|
|
stream._duplexState |= WRITE_UPDATING
|
|
|
|
do {
|
|
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
|
|
const data = this.shift()
|
|
stream._duplexState |= WRITE_ACTIVE_AND_WRITING
|
|
stream._write(data, this.afterWrite)
|
|
}
|
|
|
|
if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()
|
|
} while (this.continueUpdate() === true)
|
|
|
|
stream._duplexState &= WRITE_NOT_UPDATING
|
|
}
|
|
|
|
updateNonPrimary () {
|
|
const stream = this.stream
|
|
|
|
if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
|
|
stream._duplexState = stream._duplexState | WRITE_ACTIVE
|
|
stream._final(afterFinal.bind(this))
|
|
return
|
|
}
|
|
|
|
if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
|
|
if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
|
|
stream._duplexState |= ACTIVE
|
|
stream._destroy(afterDestroy.bind(this))
|
|
}
|
|
return
|
|
}
|
|
|
|
if ((stream._duplexState & IS_OPENING) === OPENING) {
|
|
stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING
|
|
stream._open(afterOpen.bind(this))
|
|
}
|
|
}
|
|
|
|
continueUpdate () {
|
|
if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0) return false
|
|
this.stream._duplexState &= WRITE_NOT_NEXT_TICK
|
|
return true
|
|
}
|
|
|
|
updateCallback () {
|
|
if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update()
|
|
else this.updateNextTick()
|
|
}
|
|
|
|
updateNextTick () {
|
|
if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return
|
|
this.stream._duplexState |= WRITE_NEXT_TICK
|
|
if ((this.stream._duplexState & WRITE_UPDATING) === 0) qmt(this.afterUpdateNextTick)
|
|
}
|
|
}
|
|
|
|
class ReadableState {
|
|
constructor (stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
|
|
this.stream = stream
|
|
this.queue = new FIFO()
|
|
this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark
|
|
this.buffered = 0
|
|
this.readAhead = highWaterMark > 0
|
|
this.error = null
|
|
this.pipeline = null
|
|
this.byteLength = byteLengthReadable || byteLength || defaultByteLength
|
|
this.map = mapReadable || map
|
|
this.pipeTo = null
|
|
this.afterRead = afterRead.bind(this)
|
|
this.afterUpdateNextTick = updateReadNT.bind(this)
|
|
}
|
|
|
|
get ended () {
|
|
return (this.stream._duplexState & READ_DONE) !== 0
|
|
}
|
|
|
|
pipe (pipeTo, cb) {
|
|
if (this.pipeTo !== null) throw new Error('Can only pipe to one destination')
|
|
if (typeof cb !== 'function') cb = null
|
|
|
|
this.stream._duplexState |= READ_PIPE_DRAINED
|
|
this.pipeTo = pipeTo
|
|
this.pipeline = new Pipeline(this.stream, pipeTo, cb)
|
|
|
|
if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes
|
|
|
|
if (isStreamx(pipeTo)) {
|
|
pipeTo._writableState.pipeline = this.pipeline
|
|
if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes
|
|
pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself
|
|
} else {
|
|
const onerror = this.pipeline.done.bind(this.pipeline, pipeTo)
|
|
const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool a
|