@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/eventsource/dist/errors.js

@@ -0,0 +1,120 @@
+/**
+ * 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
+     */
+    code;
+    /**
+     * Optional message attached to the error.
+     * Note: this is not part of the spec, but is included for better error handling.
+     *
+     * @public
+     */
+    message;
+    /**
+     * 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, errorEventInitDict) {
+        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, options, inspect) {
+        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, options) {
+        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) {
+    // 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.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) {
+    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) {
+    return {
+        type: err.type,
+        message: err.message,
+        code: err.code,
+        defaultPrevented: err.defaultPrevented,
+        cancelable: err.cancelable,
+        timeStamp: err.timeStamp,
+    };
+}
+//# sourceMappingURL=errors.js.map

package/node_modules/eventsource/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IACnC;;;;;OAKG;IACI,IAAI,CAAqB;IAEhC;;;;;OAKG;IACI,OAAO,CAAqB;IAEnC;;;;;;OAMG;IACH,YACE,IAAY,EACZ,kBAA8E;QAE9E,KAAK,CAAC,IAAI,CAAC,CAAA;QACX,IAAI,CAAC,IAAI,GAAG,kBAAkB,EAAE,IAAI,IAAI,SAAS,CAAA;QACjD,IAAI,CAAC,OAAO,GAAG,kBAAkB,EAAE,OAAO,IAAI,SAAS,CAAA;IACzD,CAAC;IAED;;;;;;;;;;;OAWG;IACH,CAAC,MAAM,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC,CACxC,MAAc,EACd,OAA0B,EAC1B,OAAoE;QAEpE,OAAO,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAA;IACjD,CAAC;IAED;;;;;;;;;;OAUG;IACH,CAAC,MAAM,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC,CAChC,OAAoE,EACpE,OAA0B;QAE1B,OAAO,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,CAAA;IACjD,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,8FAA8F;IAC9F,oDAAoD;IAEpD,8DAA8D;IAC9D,MAAM,YAAY,GAAI,UAAkB,CAAC,YAAY,CAAA;IACrD,IAAI,OAAO,YAAY,KAAK,UAAU,EAAE,CAAC;QACvC,OAAO,IAAI,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,CAAA;IACjD,CAAC;IAED,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,GAAY;IACvC,IAAI,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,GAAG,GAAG,EAAE,CAAA;IACjB,CAAC;IAED,IAAI,QAAQ,IAAI,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;QACjD,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAChD,CAAC;IAED,IAAI,OAAO,IAAI,GAAG,IAAI,GAAG,CAAC,KAAK,YAAY,KAAK,EAAE,CAAC;QACjD,OAAO,GAAG,GAAG,KAAK,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAA;IAC7C,CAAC;IAED,OAAO,GAAG,CAAC,OAAO,CAAA;AACpB,CAAC;AAED;;;;;;GAMG;AACH,SAAS,gBAAgB,CAAC,GAAe;IACvC,OAAO;QACL,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,OAAO,EAAE,GAAG,CAAC,OAAO;QACpB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,gBAAgB,EAAE,GAAG,CAAC,gBAAgB;QACtC,UAAU,EAAE,GAAG,CAAC,UAAU;QAC1B,SAAS,EAAE,GAAG,CAAC,SAAS;KACzB,CAAA;AACH,CAAC"}

package/node_modules/eventsource/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { ErrorEvent } from './errors.ts';
+export { EventSource, type EventSourceConstructor } from './EventSource.ts';
+export type * from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/eventsource/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AACtC,OAAO,EAAC,WAAW,EAAE,KAAK,sBAAsB,EAAC,MAAM,kBAAkB,CAAA;AACzE,mBAAmB,YAAY,CAAA"}

package/node_modules/eventsource/dist/index.js

@@ -0,0 +1,3 @@
+export { ErrorEvent } from './errors.js';
+export { EventSource } from './EventSource.js';
+//# sourceMappingURL=index.js.map

package/node_modules/eventsource/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AACtC,OAAO,EAAC,WAAW,EAA8B,MAAM,kBAAkB,CAAA"}

package/node_modules/eventsource/dist/types.d.ts

@@ -0,0 +1,156 @@
+import type { ErrorEvent } from './errors.ts';
+/**
+ * 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. */
+    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';
+}
+/**
+ * A chunk read off a response body.
+ *
+ * Chunks are handed to a `TextDecoder`, which only accepts buffers, so this is what a reader has
+ * to yield to be usable. The union is spelled out because the node (`TypedArray | DataView`) and
+ * DOM (`ArrayBufferView`) typings describe "any buffer view" differently, and these three members
+ * are accepted by both.
+ */
+type BodyChunk = Uint8Array | DataView | ArrayBuffer;
+/**
+ * Stripped down version of `ReadableStreamDefaultReader`, only defining the parts we care about.
+ *
+ * Note that the `done: true` result allows `value` to be missing _or_ explicitly `undefined`:
+ * TypeScript 5.9's DOM lib types `ReadableStreamDefaultReader.read()`'s done-result as
+ * `{done: true, value: T | undefined}`, so under `exactOptionalPropertyTypes` an optional
+ * property alone would reject standard readers.
+ *
+ * @public
+ */
+export interface ReaderLike {
+    read(): Promise<{
+        done: false;
+        value: BodyChunk;
+    } | {
+        done: true;
+        value?: BodyChunk | undefined;
+    }>;
+    cancel(): Promise<void>;
+}
+/**
+ * Minimal version of the `Response` type returned by `fetch()`.
+ *
+ * @public
+ */
+export interface FetchLikeResponse {
+    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;
+    /**
+     * Maximum number of characters to buffer while parsing an incomplete EventSource line.
+     * Defaults to 100 MB.
+     */
+    maxBufferSize?: number;
+}
+/**
+ * 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;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/node_modules/eventsource/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/node_modules/eventsource/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/node_modules/eventsource/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/node_modules/eventsource/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/node_modules/eventsource-parser/README.md

@@ -0,0 +1,177 @@
+# eventsource-parser
+
+[![npm version](https://npmx.dev/api/registry/badge/version/eventsource-parser?color=69E3EE)](https://npmx.dev/package/eventsource-parser) [![num dependendencies](https://npmx.dev/api/registry/badge/dependencies/eventsource-parser)](https://npmx.dev/package/eventsource-parser) [![npm weekly downloads](https://npmx.dev/api/registry/badge/downloads-week/eventsource-parser)](https://npmx.dev/package/eventsource-parser) [![install size](https://npmx.dev/api/registry/badge/size/eventsource-parser?color=00C16A)](https://npmx.dev/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 parser 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 22.12 and higher).
+
+Other modules in the EventSource family:
+
+- [eventsource](https://github.com/eventsource/eventsource): Cross-runtime polyfill for the WhatWG EventSource API.
+- [eventsource-encoder](https://github.com/rexxars/eventsource-encoder): encodes messages in the EventSource/Server-Sent Events format.
+- [eventsource-client](https://github.com/rexxars/eventsource-client): modern, feature rich eventsource client for browsers, node.js, bun, deno and other modern JavaScript environments.
+
+> [!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!')
+```
+
+### Event IDs
+
+Use `onId` if you need to track event IDs for reconnection. The parser calls it once when a blank
+line ends a block containing a valid `id` field. It runs for blocks with or without `data`, and it
+runs before `onEvent` when the same block produces an event. An empty `id` field is reported as an
+empty string. An `id` field containing U+0000 is ignored.
+
+```ts
+let lastEventId = ''
+
+const parser = createParser({
+  onId(id) {
+    lastEventId = id
+  },
+  onEvent(event) {
+    // …
+  },
+})
+```
+
+### 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 === 'unknown-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 `unknown-field` errors are emitted for completed invalid lines, not only data shaped as `field: value`. This is because the EventSource specification says to treat anything prior to a `:` as the field name. Incomplete lines that cannot become a valid SSE field may be discarded before completion to avoid unbounded buffering, in which case `onError` is not called and no `line`, `field`, or `value` is retained.
+
+> [!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 has not already been discarded as an invalid line.
+
+### 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 valid partial lines and event data until a server completes an event. A server (or proxy) that starts a valid field and never terminates the 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. Lines that cannot become valid SSE fields are discarded without buffering.
+
+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`, `onId`, `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/node_modules/eventsource-parser/dist/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The type of error that occurred.
+ * @public
+ */
+export type ErrorType = 'invalid-retry' | 'unknown-field' | 'max-buffer-size-exceeded';
+/**
+ * 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 a completed unknown field encountered in the stream, this will be the field name.
+     */
+    field?: string | undefined;
+    /**
+     * In the case of a completed 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;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/node_modules/eventsource/node_modules/eventsource-parser/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,eAAe,GAAG,eAAe,GAAG,0BAA0B,CAAA;AAEtF;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC;;OAEG;IACH,IAAI,EAAE,SAAS,CAAA;IAEf;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAE1B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAE1B;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAEzB,YACE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QAAC,IAAI,EAAE,SAAS,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,EAQ1E;CACF"}

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

@@ -0,0 +1,16 @@
+/**
+ * Error thrown when encountering an issue during parsing.
+ *
+ * @public
+ */
+export 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;
+    }
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IAqBnC,YACE,OAAe,EACf,OAAyE;QAEzE,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,YAAY,CAAA;QACxB,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;QACxB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAC1B,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,CAAA;QAC1B,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAA;IAC1B,CAAC;CACF"}

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

@@ -0,0 +1,4 @@
+export { type ErrorType, ParseError } from './errors.ts';
+export { createParser } from './parse.ts';
+export type { EventSourceMessage, EventSourceParser, ParserCallbacks, ParserConfig } from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/eventsource/node_modules/eventsource-parser/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,SAAS,EAAE,UAAU,EAAC,MAAM,aAAa,CAAA;AACtD,OAAO,EAAC,YAAY,EAAC,MAAM,YAAY,CAAA;AACvC,YAAY,EAAC,kBAAkB,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAC,MAAM,YAAY,CAAA"}

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

@@ -0,0 +1,3 @@
+export { ParseError } from './errors.js';
+export { createParser } from './parse.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,UAAU,EAAC,MAAM,aAAa,CAAA;AACtD,OAAO,EAAC,YAAY,EAAC,MAAM,YAAY,CAAA"}

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

@@ -0,0 +1,12 @@
+import type { EventSourceParser, ParserConfig } from './types.ts';
+/**
+ * Creates a new EventSource parser.
+ *
+ * @param config - Parser configuration. Accepts callbacks (see {@link ParserCallbacks})
+ *   and options like `maxBufferSize` (see {@link ParserConfig}).
+ *
+ * @returns A new EventSource parser, with `feed` and `reset` methods.
+ * @public
+ */
+export declare function createParser(config: ParserConfig): EventSourceParser;
+//# sourceMappingURL=parse.d.ts.map

package/node_modules/eventsource/node_modules/eventsource-parser/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,iBAAiB,EAAE,YAAY,EAAC,MAAM,YAAY,CAAA;AAQ/D;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,iBAAiB,CAsfpE"}