n8n-nodes-vercel-ai-sdk-universal-temp 0.2.35 → 0.2.37

package/node_modules/eventsource-parser/dist/stream.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export declare type ErrorType = 'invalid-retry' | 'unknown-field'
+
+/**
+ * A parsed EventSource message event
+ *
+ * @public
+ */
+export declare interface EventSourceMessage {
+  /**
+   * The event type sent from the server. Note that this differs from the browser `EventSource`
+   * implementation in that browsers will default this to `message`, whereas this parser will
+   * leave this as `undefined` if not explicitly declared.
+   */
+  event?: string | undefined
+  /**
+   * ID of the message, if any was provided by the server. Can be used by clients to keep the
+   * last received message ID in sync when reconnecting.
+   */
+  id?: string | undefined
+  /**
+   * The data received for this message
+   */
+  data: string
+}
+
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.
+ *
+ * @example Basic usage
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ *
+ * @example Terminate stream on parsing errors
+ * ```
+ * const eventStream =
+ *  response.body
+ *   .pipeThrough(new TextDecoderStream())
+ *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))
+ * ```
+ *
+ * @public
+ */
+export declare class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {
+  constructor({onError, onRetry, onComment}?: StreamOptions)
+}
+
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export declare class ParseError extends Error {
+  /**
+   * The type of error that occurred.
+   */
+  type: ErrorType
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the field name.
+   */
+  field?: string | undefined
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the value of the field.
+   */
+  value?: string | undefined
+  /**
+   * The line that caused the error, if available.
+   */
+  line?: string | undefined
+  constructor(
+    message: string,
+    options: {
+      type: ErrorType
+      field?: string
+      value?: string
+      line?: string
+    },
+  )
+}
+
+/**
+ * Options for the EventSourceParserStream.
+ *
+ * @public
+ */
+export declare interface StreamOptions {
+  /**
+   * Behavior when a parsing error occurs.
+   *
+   * - A custom function can be provided to handle the error.
+   * - `'terminate'` will error the stream and stop parsing.
+   * - Any other value will ignore the error and continue parsing.
+   *
+   * @defaultValue `undefined`
+   */
+  onError?: ('terminate' | ((error: Error) => void)) | undefined
+  /**
+   * Callback for when a reconnection interval is sent from the server.
+   *
+   * @param retry - The number of milliseconds to wait before reconnecting.
+   */
+  onRetry?: ((retry: number) => void) | undefined
+  /**
+   * Callback for when a comment is encountered in the stream.
+   *
+   * @param comment - The comment encountered in the stream.
+   */
+  onComment?: ((comment: string) => void) | undefined
+}
+
+export {}

package/node_modules/eventsource-parser/dist/stream.js

@@ -0,0 +1,29 @@
+import { createParser } from "./index.js";
+import { ParseError } from "./index.js";
+class EventSourceParserStream extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+}
+export {
+  EventSourceParserStream,
+  ParseError
+};
+//# sourceMappingURL=stream.js.map

package/node_modules/eventsource-parser/dist/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sources":["../src/stream.ts"],"sourcesContent":["import {createParser} from './parse.ts'\nimport type {EventSourceMessage, EventSourceParser} from './types.ts'\n\n/**\n * Options for the EventSourceParserStream.\n *\n * @public\n */\nexport interface StreamOptions {\n  /**\n   * Behavior when a parsing error occurs.\n   *\n   * - A custom function can be provided to handle the error.\n   * - `'terminate'` will error the stream and stop parsing.\n   * - Any other value will ignore the error and continue parsing.\n   *\n   * @defaultValue `undefined`\n   */\n  onError?: ('terminate' | ((error: Error) => void)) | undefined\n\n  /**\n   * Callback for when a reconnection interval is sent from the server.\n   *\n   * @param retry - The number of milliseconds to wait before reconnecting.\n   */\n  onRetry?: ((retry: number) => void) | undefined\n\n  /**\n   * Callback for when a comment is encountered in the stream.\n   *\n   * @param comment - The comment encountered in the stream.\n   */\n  onComment?: ((comment: string) => void) | undefined\n}\n\n/**\n * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.\n *\n * @example Basic usage\n * ```\n * const eventStream =\n *   response.body\n *     .pipeThrough(new TextDecoderStream())\n *     .pipeThrough(new EventSourceParserStream())\n * ```\n *\n * @example Terminate stream on parsing errors\n * ```\n * const eventStream =\n *  response.body\n *   .pipeThrough(new TextDecoderStream())\n *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))\n * ```\n *\n * @public\n */\nexport class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {\n  constructor({onError, onRetry, onComment}: StreamOptions = {}) {\n    let parser!: EventSourceParser\n\n    super({\n      start(controller) {\n        parser = createParser({\n          onEvent: (event) => {\n            controller.enqueue(event)\n          },\n          onError(error) {\n            if (onError === 'terminate') {\n              controller.error(error)\n            } else if (typeof onError === 'function') {\n              onError(error)\n            }\n\n            // Ignore by default\n          },\n          onRetry,\n          onComment,\n        })\n      },\n      transform(chunk) {\n        parser.feed(chunk)\n      },\n    })\n  }\n}\n\nexport {type ErrorType, ParseError} from './errors.ts'\nexport type {EventSourceMessage} from './types.ts'\n"],"names":[],"mappings":";;AAwDO,MAAM,gCAAgC,gBAA4C;AAAA,EACvF,YAAY,EAAC,SAAS,SAAS,UAAA,IAA4B,CAAA,GAAI;AAC7D,QAAI;AAEJ,UAAM;AAAA,MACJ,MAAM,YAAY;AAChB,iBAAS,aAAa;AAAA,UACpB,SAAS,CAAC,UAAU;AAClB,uBAAW,QAAQ,KAAK;AAAA,UAC1B;AAAA,UACA,QAAQ,OAAO;AACT,wBAAY,cACd,WAAW,MAAM,KAAK,IACb,OAAO,WAAY,cAC5B,QAAQ,KAAK;AAAA,UAIjB;AAAA,UACA;AAAA,UACA;AAAA,QAAA,CACD;AAAA,MACH;AAAA,MACA,UAAU,OAAO;AACf,eAAO,KAAK,KAAK;AAAA,MACnB;AAAA,IAAA,CACD;AAAA,EACH;AACF;"}

package/node_modules/eventsource-parser/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "eventsource-parser",
+  "version": "3.0.6",
+  "description": "Streaming, source-agnostic EventSource/Server-Sent Events parser",
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./stream": {
+      "source": "./src/stream.ts",
+      "import": "./dist/stream.js",
+      "require": "./dist/stream.cjs",
+      "default": "./dist/stream.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "stream": [
+        "./dist/stream.d.ts"
+      ]
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "browserslist": [
+    "node >= 20",
+    "chrome >= 71",
+    "safari >= 14.1",
+    "firefox >= 105",
+    "edge >= 79"
+  ],
+  "files": [
+    "dist",
+    "!dist/stats.html",
+    "src",
+    "stream.js"
+  ],
+  "scripts": {
+    "build": "pkg-utils build && pkg-utils --strict",
+    "clean": "rimraf dist coverage",
+    "lint": "eslint . && tsc --noEmit",
+    "posttest": "npm run lint",
+    "prebuild": "npm run clean",
+    "prepublishOnly": "npm run build",
+    "test": "npm run test:node",
+    "test:bun": "bun test",
+    "test:deno": "deno run --allow-write --allow-net --allow-run --allow-sys --allow-ffi --allow-env --allow-read npm:vitest",
+    "test:node": "vitest --reporter=verbose"
+  },
+  "author": "Espen Hovlandsdal <espen@hovlandsdal.com>",
+  "keywords": [
+    "sse",
+    "eventsource",
+    "server-sent-events"
+  ],
+  "devDependencies": {
+    "@sanity/pkg-utils": "^8.0.0",
+    "@sanity/semantic-release-preset": "^5.0.0",
+    "@types/node": "^20.19.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.51.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-sanity": "^7.1.2",
+    "eventsource-encoder": "^1.0.1",
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "rollup-plugin-visualizer": "^6.0.3",
+    "semantic-release": "^24.2.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.3"
+  },
+  "homepage": "https://github.com/rexxars/eventsource-parser#readme",
+  "bugs": {
+    "url": "https://github.com/rexxars/eventsource-parser/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/rexxars/eventsource-parser.git"
+  },
+  "license": "MIT",
+  "prettier": {
+    "bracketSpacing": false,
+    "printWidth": 100,
+    "semi": false,
+    "singleQuote": true
+  },
+  "eslintConfig": {
+    "parserOptions": {
+      "ecmaFeatures": {
+        "modules": true
+      },
+      "ecmaVersion": 9,
+      "sourceType": "module"
+    },
+    "extends": [
+      "sanity",
+      "sanity/typescript",
+      "prettier"
+    ],
+    "ignorePatterns": [
+      "lib/**/"
+    ]
+  }
+}

package/node_modules/eventsource-parser/src/errors.ts

@@ -0,0 +1,44 @@
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export type ErrorType = 'invalid-retry' | 'unknown-field'
+
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export class ParseError extends Error {
+  /**
+   * The type of error that occurred.
+   */
+  type: ErrorType
+
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the field name.
+   */
+  field?: string | undefined
+
+  /**
+   * In the case of an unknown field encountered in the stream, this will be the value of the field.
+   */
+  value?: string | undefined
+
+  /**
+   * The line that caused the error, if available.
+   */
+  line?: string | undefined
+
+  constructor(
+    message: string,
+    options: {type: ErrorType; field?: string; value?: string; line?: string},
+  ) {
+    super(message)
+    this.name = 'ParseError'
+    this.type = options.type
+    this.field = options.field
+    this.value = options.value
+    this.line = options.line
+  }
+}

package/node_modules/eventsource-parser/src/index.ts

@@ -0,0 +1,3 @@
+export {type ErrorType, ParseError} from './errors.ts'
+export {createParser} from './parse.ts'
+export type {EventSourceMessage, EventSourceParser, ParserCallbacks} from './types.ts'

package/node_modules/eventsource-parser/src/parse.ts

@@ -0,0 +1,232 @@
+/**
+ * EventSource/Server-Sent Events parser
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html
+ */
+import {ParseError} from './errors.ts'
+import type {EventSourceParser, ParserCallbacks} from './types.ts'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function noop(_arg: unknown) {
+  // intentional noop
+}
+
+/**
+ * Creates a new EventSource parser.
+ *
+ * @param callbacks - Callbacks to invoke on different parsing events:
+ *   - `onEvent` when a new event is parsed
+ *   - `onError` when an error occurs
+ *   - `onRetry` when a new reconnection interval has been sent from the server
+ *   - `onComment` when a comment is encountered in the stream
+ *
+ * @returns A new EventSource parser, with `parse` and `reset` methods.
+ * @public
+ */
+export function createParser(callbacks: ParserCallbacks): EventSourceParser {
+  if (typeof callbacks === 'function') {
+    throw new TypeError(
+      '`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?',
+    )
+  }
+
+  const {onEvent = noop, onError = noop, onRetry = noop, onComment} = callbacks
+
+  let incompleteLine = ''
+
+  let isFirstChunk = true
+  let id: string | undefined
+  let data = ''
+  let eventType = ''
+
+  function feed(newChunk: string) {
+    // Strip any UTF8 byte order mark (BOM) at the start of the stream
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, '') : newChunk
+
+    // If there was a previous incomplete line, append it to the new chunk,
+    // so we may process it together as a new (hopefully complete) chunk.
+    const [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`)
+
+    for (const line of complete) {
+      parseLine(line)
+    }
+
+    incompleteLine = incomplete
+    isFirstChunk = false
+  }
+
+  function parseLine(line: string) {
+    // If the line is empty (a blank line), dispatch the event
+    if (line === '') {
+      dispatchEvent()
+      return
+    }
+
+    // If the line starts with a U+003A COLON character (:), ignore the line.
+    if (line.startsWith(':')) {
+      if (onComment) {
+        onComment(line.slice(line.startsWith(': ') ? 2 : 1))
+      }
+      return
+    }
+
+    // If the line contains a U+003A COLON character (:)
+    const fieldSeparatorIndex = line.indexOf(':')
+    if (fieldSeparatorIndex !== -1) {
+      // Collect the characters on the line before the first U+003A COLON character (:),
+      // and let `field` be that string.
+      const field = line.slice(0, fieldSeparatorIndex)
+
+      // 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.
+      const offset = line[fieldSeparatorIndex + 1] === ' ' ? 2 : 1
+      const value = line.slice(fieldSeparatorIndex + offset)
+
+      processField(field, value, line)
+      return
+    }
+
+    // Otherwise, the string is not empty but does not contain a U+003A COLON character (:)
+    // Process the field using the whole line as the field name, and an empty string as the field value.
+    // 👆 This is according to spec. That means that a line that has the value `data` will result in
+    // a newline being added to the current `data` buffer, for instance.
+    processField(line, '', line)
+  }
+
+  function processField(field: string, value: string, line: string) {
+    // Field names must be compared literally, with no case folding performed.
+    switch (field) {
+      case 'event':
+        // Set the `event type` buffer to field value
+        eventType = value
+        break
+      case 'data':
+        // Append the field value to the `data` buffer, then append a single U+000A LINE FEED(LF)
+        // character to the `data` buffer.
+        data = `${data}${value}\n`
+        break
+      case 'id':
+        // If the field value does not contain U+0000 NULL, then set the `ID` buffer to
+        // the field value. Otherwise, ignore the field.
+        id = value.includes('\0') ? undefined : value
+        break
+      case 'retry':
+        // If the field value consists of only ASCII digits, then interpret the field value as an
+        // integer in base ten, and set the event stream's reconnection time to that integer.
+        // Otherwise, ignore the field.
+        if (/^\d+$/.test(value)) {
+          onRetry(parseInt(value, 10))
+        } else {
+          onError(
+            new ParseError(`Invalid \`retry\` value: "${value}"`, {
+              type: 'invalid-retry',
+              value,
+              line,
+            }),
+          )
+        }
+        break
+      default:
+        // Otherwise, the field is ignored.
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}…` : field}"`,
+            {type: 'unknown-field', field, value, line},
+          ),
+        )
+        break
+    }
+  }
+
+  function dispatchEvent() {
+    const shouldDispatch = data.length > 0
+    if (shouldDispatch) {
+      onEvent({
+        id,
+        event: eventType || undefined,
+        // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+        // then remove the last character from the data buffer.
+        data: data.endsWith('\n') ? data.slice(0, -1) : data,
+      })
+    }
+
+    // Reset for the next event
+    id = undefined
+    data = ''
+    eventType = ''
+  }
+
+  function reset(options: {consume?: boolean} = {}) {
+    if (incompleteLine && options.consume) {
+      parseLine(incompleteLine)
+    }
+
+    isFirstChunk = true
+    id = undefined
+    data = ''
+    eventType = ''
+    incompleteLine = ''
+  }
+
+  return {feed, reset}
+}
+
+/**
+ * For the given `chunk`, split it into lines according to spec, and return any remaining incomplete line.
+ *
+ * @param chunk - The chunk to split into lines
+ * @returns A tuple containing an array of complete lines, and any remaining incomplete line
+ * @internal
+ */
+function splitLines(chunk: string): [complete: Array<string>, incomplete: string] {
+  /**
+   * According to the spec, a line is terminated by either:
+   * - U+000D CARRIAGE RETURN U+000A LINE FEED (CRLF) character pair
+   * - a single U+000A LINE FEED(LF) character not preceded by a U+000D CARRIAGE RETURN(CR) character
+   * - a single U+000D CARRIAGE RETURN(CR) character not followed by a U+000A LINE FEED(LF) character
+   */
+  const lines: Array<string> = []
+  let incompleteLine = ''
+  let searchIndex = 0
+
+  while (searchIndex < chunk.length) {
+    // Find next line terminator
+    const crIndex = chunk.indexOf('\r', searchIndex)
+    const lfIndex = chunk.indexOf('\n', searchIndex)
+
+    // Determine line end
+    let lineEnd = -1
+    if (crIndex !== -1 && lfIndex !== -1) {
+      // CRLF case
+      lineEnd = Math.min(crIndex, lfIndex)
+    } else if (crIndex !== -1) {
+      // CR at the end of a chunk might be part of a CRLF sequence that spans chunks,
+      // so we shouldn't treat it as a line terminator (yet)
+      if (crIndex === chunk.length - 1) {
+        lineEnd = -1
+      } else {
+        lineEnd = crIndex
+      }
+    } else if (lfIndex !== -1) {
+      lineEnd = lfIndex
+    }
+
+    // Extract line if terminator found
+    if (lineEnd === -1) {
+      // No terminator found, rest is incomplete
+      incompleteLine = chunk.slice(searchIndex)
+      break
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd)
+      lines.push(line)
+
+      // Move past line terminator
+      searchIndex = lineEnd + 1
+      if (chunk[searchIndex - 1] === '\r' && chunk[searchIndex] === '\n') {
+        searchIndex++
+      }
+    }
+  }
+
+  return [lines, incompleteLine]
+}

package/node_modules/eventsource-parser/src/stream.ts

@@ -0,0 +1,88 @@
+import {createParser} from './parse.ts'
+import type {EventSourceMessage, EventSourceParser} from './types.ts'
+
+/**
+ * Options for the EventSourceParserStream.
+ *
+ * @public
+ */
+export interface StreamOptions {
+  /**
+   * Behavior when a parsing error occurs.
+   *
+   * - A custom function can be provided to handle the error.
+   * - `'terminate'` will error the stream and stop parsing.
+   * - Any other value will ignore the error and continue parsing.
+   *
+   * @defaultValue `undefined`
+   */
+  onError?: ('terminate' | ((error: Error) => void)) | undefined
+
+  /**
+   * Callback for when a reconnection interval is sent from the server.
+   *
+   * @param retry - The number of milliseconds to wait before reconnecting.
+   */
+  onRetry?: ((retry: number) => void) | undefined
+
+  /**
+   * Callback for when a comment is encountered in the stream.
+   *
+   * @param comment - The comment encountered in the stream.
+   */
+  onComment?: ((comment: string) => void) | undefined
+}
+
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of `EventSourceMessage`.
+ *
+ * @example Basic usage
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ *
+ * @example Terminate stream on parsing errors
+ * ```
+ * const eventStream =
+ *  response.body
+ *   .pipeThrough(new TextDecoderStream())
+ *   .pipeThrough(new EventSourceParserStream({terminateOnError: true}))
+ * ```
+ *
+ * @public
+ */
+export class EventSourceParserStream extends TransformStream<string, EventSourceMessage> {
+  constructor({onError, onRetry, onComment}: StreamOptions = {}) {
+    let parser!: EventSourceParser
+
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event)
+          },
+          onError(error) {
+            if (onError === 'terminate') {
+              controller.error(error)
+            } else if (typeof onError === 'function') {
+              onError(error)
+            }
+
+            // Ignore by default
+          },
+          onRetry,
+          onComment,
+        })
+      },
+      transform(chunk) {
+        parser.feed(chunk)
+      },
+    })
+  }
+}
+
+export {type ErrorType, ParseError} from './errors.ts'
+export type {EventSourceMessage} from './types.ts'