@otonoma/paranet-client 2.18.2 → 2.19.0-rc.12

package/dist/esm/{index-HCY5Ez1I.mjs → index-PztyZob7.mjs}

@@ -8947,7 +8947,7 @@ async function connectH1$1 (client, socket) {
 
 function clearIdleSocketValidation (socket) {
   if (socket[kIdleSocketValidationTimeout]) {
-    clearImmediate(socket[kIdleSocketValidationTimeout]);
+    clearTimeout(socket[kIdleSocketValidationTimeout]);
     socket[kIdleSocketValidationTimeout] = null;
   }
 
@@ -8956,23 +8956,15 @@ function clearIdleSocketValidation (socket) {
 
 function scheduleIdleSocketValidation (client, socket) {
   socket[kIdleSocketValidation] = 1;
-  // Yield to the check phase (after poll) so unsolicited bytes / FIN / RST
-  // already pending on this idle keep-alive socket are processed before the
-  // next request is written (GHSA-35p6-xmwp-9g52).
-  //
-  // setTimeout(0) pays Node's ~1ms timer floor on every sequential reuse
-  // (#5493). setImmediate avoids that, but an *unref'd* Immediate lets poll
-  // block for ~500ms when the event loop is otherwise idle (#5600 / #5606).
-  // A ref'd Immediate both keeps the pending request alive and makes poll
-  // return immediately — the hybrid those issues asked for.
-  socket[kIdleSocketValidationTimeout] = setImmediate(() => {
+  socket[kIdleSocketValidationTimeout] = setTimeout(() => {
     socket[kIdleSocketValidationTimeout] = null;
     socket[kIdleSocketValidation] = 2;
 
     if (client[kSocket$1] === socket && !socket.destroyed) {
       client[kResume$3]();
     }
-  });
+  }, 0);
+  socket[kIdleSocketValidationTimeout].unref?.();
 }
 
 /**
@@ -12477,7 +12469,6 @@ let RetryHandler$3 = class RetryHandler {
     this.end = null;
     this.etag = null;
     this.resume = null;
-    this.headersSent = false;
 
     // Handle possible onConnect duplication
     this.handler.onConnect(reason => {
@@ -12490,20 +12481,6 @@ let RetryHandler$3 = class RetryHandler {
     });
   }
 
-  checkpointResponseEnd (headers, resume) {
-    if (this.end == null && this.opts.method !== 'HEAD') {
-      const contentLength = headers['content-length'];
-      this.end = contentLength != null ? Number(contentLength) - 1 : null;
-
-      assert$7(
-        this.end == null || Number.isFinite(this.end),
-        'invalid content-length'
-      );
-    }
-
-    this.resume = this.end != null ? resume : null;
-  }
-
   onRequestSent () {
     if (this.handler.onRequestSent) {
       this.handler.onRequestSent();
@@ -12593,8 +12570,6 @@ let RetryHandler$3 = class RetryHandler {
 
     if (statusCode >= 300) {
       if (this.retryOpts.statusCodes.includes(statusCode) === false) {
-        this.headersSent = true;
-        this.checkpointResponseEnd(headers, resume);
         return this.handler.onHeaders(
           statusCode,
           rawHeaders,
@@ -12663,15 +12638,8 @@ let RetryHandler$3 = class RetryHandler {
 
       const { start, size, end = size - 1 } = contentRange;
 
-      if (this.start !== start || (this.end != null && this.end !== end)) {
-        this.abort(
-          new RequestRetryError('Content-Range mismatch', statusCode, {
-            headers,
-            data: { count: this.retryCount }
-          })
-        );
-        return false
-      }
+      assert$7(this.start === start, 'content-range mismatch');
+      assert$7(this.end == null || this.end === end, 'content-range mismatch');
 
       this.resume = resume;
       return true
@@ -12683,7 +12651,6 @@ let RetryHandler$3 = class RetryHandler {
         const range = parseRangeHeader(headers['content-range']);
 
         if (range == null) {
-          this.headersSent = true;
           return this.handler.onHeaders(
             statusCode,
             rawHeaders,
@@ -12722,7 +12689,6 @@ let RetryHandler$3 = class RetryHandler {
       );
 
       this.resume = resume;
-      this.headersSent = true;
       this.etag = headers.etag != null ? headers.etag : null;
 
       // Weak etags are not useful for comparison nor cache
@@ -12762,7 +12728,7 @@ let RetryHandler$3 = class RetryHandler {
   }
 
   onError (err) {
-    if (this.aborted || isDisturbed(this.opts.body) || (this.headersSent && this.resume == null)) {
+    if (this.aborted || isDisturbed(this.opts.body)) {
       return this.handler.onError(err)
     }
 
@@ -24671,7 +24637,7 @@ function requireConnection () {
 	        // is specified, the server needs to include the same field and one of
 	        // the selected subprotocol values in its response for the connection to
 	        // be established.
-	        if (requestProtocols === null || !requestProtocols.includes(secProtocol)) {
+	        if (!requestProtocols.includes(secProtocol)) {
 	          failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.');
 	          return
 	        }
@@ -24918,12 +24884,7 @@ function requirePermessageDeflate () {
 
 	        if (this.#maxPayloadSize > 0 && this.#inflate[kLength] > this.#maxPayloadSize) {
 	          callback(new MessageSizeExceededError());
-	          // The inflater may still hold buffered input that can emit a late
-	          // zlib error. Remove the data listener, then deterministically stop
-	          // the stream so a subsequent 'error' cannot fire without a listener
-	          // (which would terminate the process as an unhandled error event).
 	          this.#inflate.removeAllListeners();
-	          this.#inflate.destroy();
 	          this.#inflate = null;
 	          return
 	        }
@@ -26272,49 +26233,6 @@ function requireEventsourceStream () {
 	 */
 	const SPACE = 0x20;
 
-	const DATA = Buffer.from('data');
-	const EVENT = Buffer.from('event');
-	const ID = Buffer.from('id');
-	const RETRY = Buffer.from('retry');
-
-	function isASCIINumberBytes (buffer, start) {
-	  if (start >= buffer.length) {
-	    return false
-	  }
-
-	  for (let i = start; i < buffer.length; i++) {
-	    if (buffer[i] < 0x30 || buffer[i] > 0x39) {
-	      return false
-	    }
-	  }
-
-	  return true
-	}
-
-	function isValidLastEventIdBytes (buffer, start) {
-	  for (let i = start; i < buffer.length; i++) {
-	    if (buffer[i] === 0x00) {
-	      return false
-	    }
-	  }
-
-	  return true
-	}
-
-	function isFieldName (line, length, field) {
-	  if (length !== field.length) {
-	    return false
-	  }
-
-	  for (let i = 0; i < length; i++) {
-	    if (line[i] !== field[i]) {
-	      return false
-	    }
-	  }
-
-	  return true
-	}
-
 	/**
 	 * @typedef {object} EventSourceStreamEvent
 	 * @type {object}
@@ -26355,14 +26273,11 @@ function requireEventsourceStream () {
 	  eventEndCheck = false
 
 	  /**
-	   * @type {Buffer[]}
+	   * @type {Buffer}
 	   */
-	  chunks = []
+	  buffer = null
 
-	  chunkIndex = 0
 	  pos = 0
-	  lineChunkIndex = 0
-	  linePos = 0
 
 	  event = {
 	    data: undefined,
@@ -26401,20 +26316,92 @@ function requireEventsourceStream () {
 	      return
 	    }
 
-	    this.chunks.push(chunk);
+	    // Cache the chunk in the buffer, as the data might not be complete while
+	    // processing it
+	    // TODO: Investigate if there is a more performant way to handle
+	    // incoming chunks
+	    // see: https://github.com/nodejs/undici/issues/2630
+	    if (this.buffer) {
+	      this.buffer = Buffer.concat([this.buffer, chunk]);
+	    } else {
+	      this.buffer = chunk;
+	    }
 
 	    // Strip leading byte-order-mark if we opened the stream and started
 	    // the processing of the incoming data
 	    if (this.checkBOM) {
-	      if (this.handleBOM()) {
-	        callback();
-	        return
+	      switch (this.buffer.length) {
+	        case 1:
+	          // Check if the first byte is the same as the first byte of the BOM
+	          if (this.buffer[0] === BOM[0]) {
+	            // If it is, we need to wait for more data
+	            callback();
+	            return
+	          }
+	          // Set the checkBOM flag to false as we don't need to check for the
+	          // BOM anymore
+	          this.checkBOM = false;
+
+	          // The buffer only contains one byte so we need to wait for more data
+	          callback();
+	          return
+	        case 2:
+	          // Check if the first two bytes are the same as the first two bytes
+	          // of the BOM
+	          if (
+	            this.buffer[0] === BOM[0] &&
+	            this.buffer[1] === BOM[1]
+	          ) {
+	            // If it is, we need to wait for more data, because the third byte
+	            // is needed to determine if it is the BOM or not
+	            callback();
+	            return
+	          }
+
+	          // Set the checkBOM flag to false as we don't need to check for the
+	          // BOM anymore
+	          this.checkBOM = false;
+	          break
+	        case 3:
+	          // Check if the first three bytes are the same as the first three
+	          // bytes of the BOM
+	          if (
+	            this.buffer[0] === BOM[0] &&
+	            this.buffer[1] === BOM[1] &&
+	            this.buffer[2] === BOM[2]
+	          ) {
+	            // If it is, we can drop the buffered data, as it is only the BOM
+	            this.buffer = Buffer.alloc(0);
+	            // Set the checkBOM flag to false as we don't need to check for the
+	            // BOM anymore
+	            this.checkBOM = false;
+
+	            // Await more data
+	            callback();
+	            return
+	          }
+	          // If it is not the BOM, we can start processing the data
+	          this.checkBOM = false;
+	          break
+	        default:
+	          // The buffer is longer than 3 bytes, so we can drop the BOM if it is
+	          // present
+	          if (
+	            this.buffer[0] === BOM[0] &&
+	            this.buffer[1] === BOM[1] &&
+	            this.buffer[2] === BOM[2]
+	          ) {
+	            // Remove the BOM from the buffer
+	            this.buffer = this.buffer.subarray(3);
+	          }
+
+	          // Set the checkBOM flag to false as we don't need to check for the
+	          this.checkBOM = false;
+	          break
 	      }
 	    }
 
-	    while (this.hasCurrentByte()) {
-	      const byte = this.currentByte();
-
+	    while (this.pos < this.buffer.length) {
 	      // If the previous line ended with an end-of-line, we need to check
 	      // if the next character is also an end-of-line.
 	      if (this.eventEndCheck) {
@@ -26427,9 +26414,10 @@ function requireEventsourceStream () {
 	        if (this.crlfCheck) {
 	          // If the current character is a line feed, we can remove it
 	          // from the buffer and reset the crlfCheck flag
-	          if (byte === LF) {
+	          if (this.buffer[this.pos] === LF) {
+	            this.buffer = this.buffer.subarray(this.pos + 1);
+	            this.pos = 0;
 	            this.crlfCheck = false;
-	            this.consumeCurrentByte();
 
 	            // It is possible that the line feed is not the end of the
 	            // event. We need to check if the next character is an
@@ -26445,17 +26433,19 @@ function requireEventsourceStream () {
 	          this.crlfCheck = false;
 	        }
 
-	        if (byte === LF || byte === CR) {
+	        if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
 	          // If the current character is a carriage return, we need to
 	          // set the crlfCheck flag to true, as we need to check if the
 	          // next character is a line feed so we can remove it from the
 	          // buffer
-	          if (byte === CR) {
+	          if (this.buffer[this.pos] === CR) {
 	            this.crlfCheck = true;
 	          }
 
-	          this.consumeCurrentByte();
-	          if (this.hasPendingEvent()) {
+	          this.buffer = this.buffer.subarray(this.pos + 1);
+	          this.pos = 0;
+	          if (
+	            this.event.data !== undefined || this.event.event || this.event.id || this.event.retry) {
 	            this.processEvent(this.event);
 	          }
 	          this.clearEvent();
@@ -26469,18 +26459,22 @@ function requireEventsourceStream () {
 
 	      // If the current character is an end-of-line, we can process the
 	      // line
-	      if (byte === LF || byte === CR) {
+	      if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
 	        // If the current character is a carriage return, we need to
 	        // set the crlfCheck flag to true, as we need to check if the
 	        // next character is a line feed
-	        if (byte === CR) {
+	        if (this.buffer[this.pos] === CR) {
 	          this.crlfCheck = true;
 	        }
 
 	        // In any case, we can process the line as we reached an
 	        // end-of-line character
-	        this.parseLine(this.readLine(), this.event);
-	        this.consumeCurrentByte();
+	        this.parseLine(this.buffer.subarray(0, this.pos), this.event);
+
+	        // Remove the processed line from the buffer
+	        this.buffer = this.buffer.subarray(this.pos + 1);
+	        // Reset the position as we removed the processed line from the buffer
+	        this.pos = 0;
 	        // A line was processed and this could be the end of the event. We need
 	        // to check if the next line is empty to determine if the event is
 	        // finished.
@@ -26488,7 +26482,7 @@ function requireEventsourceStream () {
 	        continue
 	      }
 
-	      this.advanceCursor();
+	      this.pos++;
 	    }
 
 	    callback();
@@ -26513,53 +26507,64 @@ function requireEventsourceStream () {
 	      return
 	    }
 
-	    let fieldLength = line.length;
-	    let valueStart = line.length;
+	    let field = '';
+	    let value = '';
 
 	    // If the line contains a U+003A COLON character (:)
 	    if (colonPosition !== -1) {
-	      fieldLength = colonPosition;
+	      // Collect the characters on the line before the first U+003A COLON
+	      // character (:), and let field be that string.
+	      // TODO: Investigate if there is a more performant way to extract the
+	      // field
+	      // see: https://github.com/nodejs/undici/issues/2630
+	      field = line.subarray(0, colonPosition).toString('utf8');
 
 	      // Collect the characters on the line after the first U+003A COLON
 	      // character (:), and let value be that string.
 	      // If value starts with a U+0020 SPACE character, remove it from value.
-	      valueStart = colonPosition + 1;
+	      let valueStart = colonPosition + 1;
 	      if (line[valueStart] === SPACE) {
 	        ++valueStart;
 	      }
-	    }
-
-	    if (isFieldName(line, fieldLength, DATA)) {
-	      const value = line.toString('utf8', valueStart);
-
-	      if (event.data === undefined) {
-	        event.data = value;
-	      } else {
-	        event.data += `\n${value}`;
-	      }
-	      return
-	    }
-
-	    if (isFieldName(line, fieldLength, RETRY)) {
-	      if (isASCIINumberBytes(line, valueStart)) {
-	        event.retry = line.toString('utf8', valueStart);
-	      }
-	      return
-	    }
-
-	    if (isFieldName(line, fieldLength, ID)) {
-	      if (isValidLastEventIdBytes(line, valueStart)) {
-	        event.id = line.toString('utf8', valueStart);
-	      }
-	      return
-	    }
+	      // TODO: Investigate if there is a more performant way to extract the
+	      // value
+	      // see: https://github.com/nodejs/undici/issues/2630
+	      value = line.subarray(valueStart).toString('utf8');
 
-	    if (isFieldName(line, fieldLength, EVENT)) {
-	      const value = line.toString('utf8', valueStart);
-
-	      if (value.length > 0) {
-	        event.event = value;
-	      }
+	      // Otherwise, the string is not empty but does not contain a U+003A COLON
+	      // character (:)
+	    } else {
+	      // Process the field using the steps described below, using the whole
+	      // line as the field name, and the empty string as the field value.
+	      field = line.toString('utf8');
+	      value = '';
+	    }
+
+	    // Modify the event with the field name and value. The value is also
+	    // decoded as UTF-8
+	    switch (field) {
+	      case 'data':
+	        if (event[field] === undefined) {
+	          event[field] = value;
+	        } else {
+	          event[field] += `\n${value}`;
+	        }
+	        break
+	      case 'retry':
+	        if (isASCIINumber(value)) {
+	          event[field] = value;
+	        }
+	        break
+	      case 'id':
+	        if (isValidLastEventId(value)) {
+	          event[field] = value;
+	        }
+	        break
+	      case 'event':
+	        if (value.length > 0) {
+	          event[field] = value;
+	        }
+	        break
 	    }
 	  }
 
@@ -26589,151 +26594,12 @@ function requireEventsourceStream () {
 	  }
 
 	  clearEvent () {
-	    this.event.data = undefined;
-	    this.event.event = undefined;
-	    this.event.id = undefined;
-	    this.event.retry = undefined;
-	  }
-
-	  hasPendingEvent () {
-	    return this.event.data !== undefined ||
-	      this.event.event !== undefined ||
-	      this.event.id !== undefined ||
-	      this.event.retry !== undefined
-	  }
-
-	  hasCurrentByte () {
-	    return this.chunkIndex < this.chunks.length &&
-	      this.pos < this.chunks[this.chunkIndex].length
-	  }
-
-	  currentByte () {
-	    return this.chunks[this.chunkIndex][this.pos]
-	  }
-
-	  consumeCurrentByte () {
-	    this.advanceCursor();
-	    this.syncLineStartToCursor();
-	  }
-
-	  advanceCursor () {
-	    this.pos++;
-
-	    while (this.chunkIndex < this.chunks.length && this.pos >= this.chunks[this.chunkIndex].length) {
-	      this.chunkIndex++;
-	      this.pos = 0;
-	    }
-	  }
-
-	  syncLineStartToCursor () {
-	    this.lineChunkIndex = this.chunkIndex;
-	    this.linePos = this.pos;
-	    this.dropConsumedChunks();
-	  }
-
-	  dropConsumedChunks () {
-	    while (this.lineChunkIndex > 0) {
-	      this.chunks.shift();
-	      this.lineChunkIndex--;
-	      this.chunkIndex--;
-	    }
-
-	    if (this.chunkIndex === this.chunks.length) {
-	      this.chunks.length = 0;
-	      this.chunkIndex = 0;
-	      this.pos = 0;
-	      this.lineChunkIndex = 0;
-	      this.linePos = 0;
-	    }
-	  }
-
-	  readLine () {
-	    if (this.lineChunkIndex === this.chunkIndex) {
-	      return this.chunks[this.chunkIndex].subarray(this.linePos, this.pos)
-	    }
-
-	    const chunks = [];
-	    let length = 0;
-
-	    for (let i = this.lineChunkIndex; i <= this.chunkIndex; i++) {
-	      const chunk = this.chunks[i];
-	      const start = i === this.lineChunkIndex ? this.linePos : 0;
-	      const end = i === this.chunkIndex ? this.pos : chunk.length;
-	      const slice = chunk.subarray(start, end);
-	      length += slice.length;
-	      chunks.push(slice);
-	    }
-
-	    return Buffer.concat(chunks, length)
-	  }
-
-	  peekBufferedByte (offset) {
-	    let chunkIndex = this.lineChunkIndex;
-	    let pos = this.linePos;
-
-	    while (chunkIndex < this.chunks.length) {
-	      const chunk = this.chunks[chunkIndex];
-	      const remaining = chunk.length - pos;
-
-	      if (offset < remaining) {
-	        return chunk[pos + offset]
-	      }
-
-	      offset -= remaining;
-	      chunkIndex++;
-	      pos = 0;
-	    }
-	  }
-
-	  discardLeadingBytes (count) {
-	    while (count > 0 && this.lineChunkIndex < this.chunks.length) {
-	      const chunk = this.chunks[this.lineChunkIndex];
-	      const remaining = chunk.length - this.linePos;
-
-	      if (count < remaining) {
-	        this.linePos += count;
-	        count = 0;
-	      } else {
-	        count -= remaining;
-	        this.lineChunkIndex++;
-	        this.linePos = 0;
-	      }
-	    }
-
-	    this.chunkIndex = this.lineChunkIndex;
-	    this.pos = this.linePos;
-	    this.dropConsumedChunks();
-	  }
-
-	  handleBOM () {
-	    const first = this.peekBufferedByte(0);
-	    const second = this.peekBufferedByte(1);
-	    const third = this.peekBufferedByte(2);
-
-	    if (second === undefined) {
-	      if (first === BOM[0]) {
-	        return true
-	      }
-
-	      this.checkBOM = false;
-	      return true
-	    }
-
-	    if (third === undefined) {
-	      if (first === BOM[0] && second === BOM[1]) {
-	        return true
-	      }
-
-	      this.checkBOM = false;
-	      return false
-	    }
-
-	    if (first === BOM[0] && second === BOM[1] && third === BOM[2]) {
-	      this.discardLeadingBytes(3);
-	    }
-
-	    this.checkBOM = false;
-	    return !this.hasCurrentByte()
+	    this.event = {
+	      data: undefined,
+	      event: undefined,
+	      id: undefined,
+	      retry: undefined
+	    };
 	  }
 	}
 
@@ -27453,4 +27319,4 @@ var index = /*#__PURE__*/_mergeNamespaces({
 }, [undici]);
 
 export { index as i };
-//# sourceMappingURL=index-HCY5Ez1I.mjs.map
+//# sourceMappingURL=index-PztyZob7.mjs.map