deadbyte-mcp 0.8.7

package/node_modules/eventsource/src/errors.ts

@@ -0,0 +1,141 @@
+/**
+ * An extended version of the `Event` emitted by the `EventSource` object when an error occurs.
+ * While the spec does not include any additional properties, we intentionally go beyond the spec
+ * and provide some (minimal) additional information to aid in debugging.
+ *
+ * @public
+ */
+export class ErrorEvent extends Event {
+  /**
+   * HTTP status code, if this was triggered by an HTTP error
+   * Note: this is not part of the spec, but is included for better error handling.
+   *
+   * @public
+   */
+  public code?: number | undefined
+
+  /**
+   * Optional message attached to the error.
+   * Note: this is not part of the spec, but is included for better error handling.
+   *
+   * @public
+   */
+  public message?: string | undefined
+
+  /**
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
+   *
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
+   */
+  constructor(
+    type: string,
+    errorEventInitDict?: {message?: string | undefined; code?: number | undefined},
+  ) {
+    super(type)
+    this.code = errorEventInitDict?.code ?? undefined
+    this.message = errorEventInitDict?.message ?? undefined
+  }
+
+  /**
+   * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Node.js when you `console.log` an instance of this class.
+   *
+   * @param _depth - The current depth
+   * @param options - The options passed to `util.inspect`
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @returns A string representation of the error
+   */
+  [Symbol.for('nodejs.util.inspect.custom')](
+    _depth: number,
+    options: {colors: boolean},
+    inspect: (obj: unknown, inspectOptions: {colors: boolean}) => string,
+  ): string {
+    return inspect(inspectableError(this), options)
+  }
+
+  /**
+   * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Deno when you `console.log` an instance of this class.
+   *
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @param options - The options passed to `Deno.inspect`
+   * @returns A string representation of the error
+   */
+  [Symbol.for('Deno.customInspect')](
+    inspect: (obj: unknown, inspectOptions: {colors: boolean}) => string,
+    options: {colors: boolean},
+  ): string {
+    return inspect(inspectableError(this), options)
+  }
+}
+
+/**
+ * For environments where DOMException may not exist, we will use a SyntaxError instead.
+ * While this isn't strictly according to spec, it is very close.
+ *
+ * @param message - The message to include in the error
+ * @returns A `DOMException` or `SyntaxError` instance
+ * @internal
+ */
+export function syntaxError(message: string): SyntaxError {
+  // If someone can figure out a way to make this work without depending on DOM/Node.js typings,
+  // and without casting to `any`, please send a PR 🙏
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const DomException = (globalThis as any).DOMException
+  if (typeof DomException === 'function') {
+    return new DomException(message, 'SyntaxError')
+  }
+
+  return new SyntaxError(message)
+}
+
+/**
+ * Flatten an error into a single error message string.
+ * Unwraps nested errors and joins them with a comma.
+ *
+ * @param err - The error to flatten
+ * @returns A string representation of the error
+ * @internal
+ */
+export function flattenError(err: unknown): string {
+  if (!(err instanceof Error)) {
+    return `${err}`
+  }
+
+  if ('errors' in err && Array.isArray(err.errors)) {
+    return err.errors.map(flattenError).join(', ')
+  }
+
+  if ('cause' in err && err.cause instanceof Error) {
+    return `${err}: ${flattenError(err.cause)}`
+  }
+
+  return err.message
+}
+
+/**
+ * Convert an `ErrorEvent` instance into a plain object for inspection.
+ *
+ * @param err - The `ErrorEvent` instance to inspect
+ * @returns A plain object representation of the error
+ * @internal
+ */
+function inspectableError(err: ErrorEvent) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp,
+  }
+}

package/node_modules/eventsource/src/index.ts

@@ -0,0 +1,3 @@
+export {ErrorEvent} from './errors.js'
+export {EventSource} from './EventSource.js'
+export type * from './types.js'

package/node_modules/eventsource/src/types.ts

@@ -0,0 +1,152 @@
+import type {ErrorEvent} from './errors.js'
+
+/**
+ * Stripped down version of `fetch()`, only defining the parts we care about.
+ * This ensures it should work with "most" fetch implementations.
+ *
+ * @public
+ */
+export type FetchLike = (
+  url: string | URL,
+  init: EventSourceFetchInit,
+) => Promise<FetchLikeResponse>
+
+/**
+ * Subset of `RequestInit` used for `fetch()` calls made by the `EventSource` class.
+ * As we know that we will be passing certain values, we can be more specific and have
+ * users not have to do optional chaining and similar for things that will always be there.
+ *
+ * @public
+ */
+export interface EventSourceFetchInit {
+  /** An AbortSignal to set request's signal. Typed as `any` because of polyfill inconsistencies. */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  signal: {aborted: boolean} | any
+
+  /** A Headers object, an object literal, or an array of two-item arrays to set request's headers. */
+  headers: {
+    [key: string]: string
+    Accept: 'text/event-stream'
+  }
+
+  /** A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode. */
+  mode: 'cors' | 'no-cors' | 'same-origin'
+
+  /** A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials. */
+  credentials?: 'include' | 'omit' | 'same-origin'
+
+  /** Controls how the request is cached. */
+  cache: 'no-store'
+
+  /** A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */
+  redirect: 'error' | 'follow' | 'manual'
+}
+
+/**
+ * @public
+ * @deprecated Use `EventSourceFetchInit` instead.
+ * This type is only here for backwards compatibility and will be removed in a future version.
+ */
+export type FetchLikeInit = EventSourceFetchInit
+
+/**
+ * Stripped down version of `ReadableStreamDefaultReader`, only defining the parts we care about.
+ *
+ * @public
+ */
+export interface ReaderLike {
+  read(): Promise<{done: false; value: unknown} | {done: true; value?: undefined}>
+  cancel(): Promise<void>
+}
+
+/**
+ * Minimal version of the `Response` type returned by `fetch()`.
+ *
+ * @public
+ */
+export interface FetchLikeResponse {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  readonly body: {getReader(): ReaderLike} | Response['body'] | null
+  readonly url: string
+  readonly status: number
+  readonly redirected: boolean
+  readonly headers: {get(name: string): string | null}
+}
+
+/**
+ * Mirrors the official DOM typings, with the exception of the extended ErrorEvent.
+ *
+ * @public
+ */
+export interface EventSourceEventMap {
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+/**
+ * Mirrors the official DOM typings (for the most part)
+ *
+ * @public
+ */
+export interface EventSourceInit {
+  /**
+   * A boolean value, defaulting to `false`, indicating if CORS should be set to `include` credentials.
+   */
+  withCredentials?: boolean
+
+  /**
+   * Optional fetch implementation to use. Defaults to `globalThis.fetch`.
+   * Can also be used for advanced use cases like mocking, proxying, custom certs etc.
+   */
+  fetch?: FetchLike
+}
+
+/**
+ * Mirrors the official DOM typings (sorta).
+ *
+ * @public
+ */
+export interface EventListenerOptions {
+  /** Not directly used by Node.js. Added for API completeness. Default: `false`. */
+  capture?: boolean
+}
+
+/**
+ * Mirrors the official DOM typings (sorta).
+ *
+ * @public
+ */
+export interface AddEventListenerOptions extends EventListenerOptions {
+  /** When `true`, the listener is automatically removed when it is first invoked. Default: `false`. */
+  once?: boolean
+  /** When `true`, serves as a hint that the listener will not call the `Event` object's `preventDefault()` method. Default: false. */
+  passive?: boolean
+  /** The listener will be removed when the given AbortSignal object's `abort()` method is called. */
+  signal?: AbortSignal
+}
+
+/**
+ * Mirrors the official DOM typings.
+ *
+ * @public
+ */
+export type EventListenerOrEventListenerObject = EventListener | EventListenerObject
+
+/**
+ * Mirrors the official DOM typings.
+ *
+ * @public
+ */
+export interface EventListener {
+  (evt: Event | MessageEvent): void
+}
+
+/**
+ * Mirrors the official DOM typings.
+ *
+ * @public
+ */
+export interface EventListenerObject {
+  handleEvent(object: Event): void
+}

package/node_modules/eventsource-parser/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Espen Hovlandsdal <espen@hovlandsdal.com>
+
+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.

package/node_modules/eventsource-parser/README.md

@@ -0,0 +1,157 @@
+# eventsource-parser
+
+[![npm version](https://img.shields.io/npm/v/eventsource-parser.svg?style=flat-square)](https://www.npmjs.com/package/eventsource-parser)[![npm bundle size](https://img.shields.io/bundlephobia/minzip/eventsource-parser?style=flat-square)](https://bundlephobia.com/result?p=eventsource-parser)[![npm weekly downloads](https://img.shields.io/npm/dw/eventsource-parser.svg?style=flat-square)](https://www.npmjs.com/package/eventsource-parser)
+
+A streaming parser for [server-sent events/eventsource](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events), without any assumptions about how the actual stream of data is retrieved. It is intended to be a building block for [clients](https://github.com/rexxars/eventsource-client) and polyfills in javascript environments such as browsers, node.js and deno.
+
+If you are looking for a modern client implementation, see [eventsource-client](https://github.com/rexxars/eventsource-client).
+
+You create an instance of the parser, and _feed_ it chunks of data - partial or complete, and the parse emits parsed messages once it receives a complete message. A [TransformStream variant](#stream-usage) is also available for environments that support it (modern browsers, Node 18 and higher).
+
+Other modules in the EventSource family:
+
+- [eventsource-client](https://github.com/rexxars/eventsource-client): modern, feature rich eventsource client for browsers, node.js, bun, deno and other modern JavaScript environments.
+- [eventsource-encoder](https://github.com/rexxars/eventsource-encoder): encodes messages in the EventSource/Server-Sent Events format.
+- [eventsource](https://github.com/eventsource/eventsource): Node.js polyfill for the WhatWG EventSource API.
+
+> [!NOTE]
+> Migrating from eventsource-parser 1.x/2.x? See the [migration guide](./MIGRATE-v3.md).
+
+## Installation
+
+```bash
+npm install --save eventsource-parser
+```
+
+## Usage
+
+```ts
+import {createParser, type EventSourceMessage} from 'eventsource-parser'
+
+function onEvent(event: EventSourceMessage) {
+  console.log('Received event!')
+  console.log('id: %s', event.id || '<none>')
+  console.log('event: %s', event.event || '<none>')
+  console.log('data: %s', event.data)
+}
+
+const parser = createParser({onEvent})
+const sseStream = getSomeReadableStream()
+
+for await (const chunk of sseStream) {
+  parser.feed(chunk)
+}
+
+// If you want to re-use the parser for a new stream of events, make sure to reset it!
+parser.reset()
+console.log('Done!')
+```
+
+### Retry intervals
+
+If the server sends a `retry` field in the event stream, the parser will call any `onRetry` callback specified to the `createParser` function:
+
+```ts
+const parser = createParser({
+  onRetry(retryInterval) {
+    console.log('Server requested retry interval of %dms', retryInterval)
+  },
+  onEvent(event) {
+    // …
+  },
+})
+```
+
+### Parse errors
+
+If the parser encounters an error while parsing, it will call any `onError` callback provided to the `createParser` function:
+
+```ts
+import {type ParseError} from 'eventsource-parser'
+
+const parser = createParser({
+  onError(error: ParseError) {
+    console.error('Error parsing event:', error)
+    if (error.type === 'invalid-field') {
+      console.error('Field name:', error.field)
+      console.error('Field value:', error.value)
+      console.error('Line:', error.line)
+    } else if (error.type === 'invalid-retry') {
+      console.error('Invalid retry interval:', error.value)
+    }
+  },
+  onEvent(event) {
+    // …
+  },
+})
+```
+
+Note that `invalid-field` errors will usually be called for any invalid data - not only data shaped as `field: value`. This is because the EventSource specification says to treat anything prior to a `:` as the field name. Use the `error.line` property to get the full line that caused the error.
+
+> [!NOTE]
+> When encountering the end of a stream, calling `.reset({consume: true})` on the parser to flush any remaining data and reset the parser state. This will trigger the `onError` callback if the pending data is not a valid event.
+
+### Comments
+
+The parser will ignore comments (lines starting with `:`) by default. If you want to handle comments, you can provide an `onComment` callback to the `createParser` function:
+
+```ts
+const parser = createParser({
+  onComment(comment) {
+    console.log('Received comment:', comment)
+  },
+  onEvent(event) {
+    // …
+  },
+})
+```
+
+> [!NOTE]
+> Leading whitespace is not stripped from comments, eg `: comment` will give ` comment` as the comment value, not `comment` (note the leading space).
+
+### Limiting buffered memory (`maxBufferSize`)
+
+By default the parser buffers data indefinitely until a server completes an event. A server (or proxy) that never terminates a line, or that keeps appending `data:` lines without ever sending a blank line to dispatch the event, can therefore grow the parser's buffers without bound.
+
+Pass a `maxBufferSize` (in characters) to `createParser` to cap this. If the combined size of the pending line buffer and the in-progress event's data buffer exceeds the limit, the parser emits a `ParseError` with `type: 'max-buffer-size-exceeded'` and becomes terminated: subsequent calls to `feed()` will throw until `reset()` is called.
+
+```ts
+const parser = createParser({
+  maxBufferSize: 1024 * 1024, // 1 MB
+  onEvent(event) {
+    // …
+  },
+  onError(error) {
+    if (error.type === 'max-buffer-size-exceeded') {
+      // Stream peer is misbehaving — typically you'd close the connection.
+    }
+  },
+})
+```
+
+The same option is available on the [stream variant](#stream-usage); the stream is always errored when this limit is exceeded, regardless of the `onError` setting (since the underlying parser is unrecoverable without a `reset()`).
+
+## Stream usage
+
+```ts
+import {EventSourceParserStream} from 'eventsource-parser/stream'
+
+const eventStream = response.body
+  .pipeThrough(new TextDecoderStream())
+  .pipeThrough(new EventSourceParserStream())
+```
+
+The stream constructor accepts a subset of the `createParser` options (`onComment`, `onRetry`, `maxBufferSize`) plus an `onError` that can either be a function or set to `'terminate'` to error the stream on parse errors. Events are delivered through the stream itself rather than via an `onEvent` callback:
+
+```ts
+new EventSourceParserStream({
+  maxBufferSize: 1024 * 1024,
+  onError: 'terminate',
+})
+```
+
+Note that the TransformStream is exposed under a separate export (`eventsource-parser/stream`), in order to maximize compatibility with environments that do not have the `TransformStream` constructor available.
+
+## License
+
+MIT © [Espen Hovlandsdal](https://espen.codes/)

package/node_modules/eventsource-parser/dist/index.cjs

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: !0 });
+class ParseError extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+}
+const LF = 10, CR = 13, SPACE = 32;
+function noop(_arg) {
+}
+function createParser(config) {
+  if (typeof config == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+  let pendingFragmentsLength = 0, isFirstChunk = !0, id, data = "", dataLines = 0, eventType, terminated = !1;
+  function feed(chunk) {
+    if (terminated)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (isFirstChunk && (isFirstChunk = !1, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    const trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = !0, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+      new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      value2.includes("\0") || (id = value2);
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        value.includes("\0") || (id = value);
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = !0, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = !1;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+exports.ParseError = ParseError;
+exports.createParser = createParser;
+//# sourceMappingURL=index.cjs.map