@ahoo-wang/fetcher-eventbus 2.8.5

package/dist/index.es.js

@@ -0,0 +1,1460 @@
+class pe {
+  /**
+   * Creates a generic event bus
+   *
+   * @param typeEventBusSupplier - Function to create TypedEventBus for specific event types
+   */
+  constructor(e) {
+    this.typeEventBusSupplier = e, this.buses = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Adds an event handler for a specific event type
+   *
+   * @template Key - The event type
+   * @param type - The event type to listen for
+   * @param handler - The event handler to add
+   * @returns true if the handler was added, false if a handler with the same name already exists
+   */
+  on(e, t) {
+    let r = this.buses.get(e);
+    return r || (r = this.typeEventBusSupplier(e), this.buses.set(e, r)), r?.on(t) ?? !1;
+  }
+  /**
+   * Removes an event handler for a specific event type
+   *
+   * @template Key - The event type
+   * @param type - The event type
+   * @param name - The name of the event handler to remove
+   * @returns true if a handler was removed, false otherwise
+   */
+  off(e, t) {
+    return this.buses.get(e)?.off(t) ?? !1;
+  }
+  /**
+   * Emits an event for a specific event type
+   *
+   * @template Key - The event type
+   * @param type - The event type to emit
+   * @param event - The event data
+   * @returns Promise if the underlying bus is async, void otherwise
+   */
+  emit(e, t) {
+    return this.buses.get(e)?.emit(t);
+  }
+  /**
+   * Cleans up all managed event buses
+   */
+  destroy() {
+    for (const e of this.buses.values())
+      e.destroy();
+    this.buses.clear();
+  }
+}
+class fe {
+  /**
+   * Creates a parallel typed event bus
+   *
+   * @param type - The event type identifier for this bus
+   */
+  constructor(e) {
+    this.type = e, this.eventHandlers = [];
+  }
+  /**
+   * Gets a copy of all registered event handlers, sorted by order
+   */
+  get handlers() {
+    return [...this.eventHandlers];
+  }
+  /**
+   * Emits an event to all registered handlers in parallel
+   *
+   * Handlers are executed concurrently. Once-only handlers are removed after all executions complete.
+   * Errors in individual handlers are logged but do not affect other handlers.
+   *
+   * @param event - The event to emit
+   */
+  async emit(e) {
+    const t = [], r = this.eventHandlers.map(async (n) => {
+      try {
+        await n.handle(e);
+      } catch (a) {
+        console.warn(`Event handler error for ${n.name}:`, a);
+      } finally {
+        n.once && t.push(n);
+      }
+    });
+    await Promise.all(r), t.length > 0 && (this.eventHandlers = this.eventHandlers.filter(
+      (n) => !t.includes(n)
+    ));
+  }
+  /**
+   * Removes an event handler by name
+   *
+   * @param name - The name of the handler to remove
+   * @returns true if a handler was removed, false otherwise
+   */
+  off(e) {
+    const t = this.eventHandlers;
+    return t.some((r) => r.name === e) ? (this.eventHandlers = t.filter((r) => r.name !== e), !0) : !1;
+  }
+  /**
+   * Adds an event handler if not already present
+   *
+   * Handlers are sorted by their order property after addition.
+   *
+   * @param handler - The event handler to add
+   * @returns true if the handler was added, false if a handler with the same name already exists
+   */
+  on(e) {
+    const t = this.eventHandlers;
+    return t.some((r) => r.name === e.name) ? !1 : (this.eventHandlers = [...t, e], !0);
+  }
+  destroy() {
+    this.eventHandlers = [];
+  }
+}
+function M(s) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(s);
+}
+function B(s, e) {
+  return M(e) ? e : e ? s.replace(/\/?\/$/, "") + "/" + e.replace(/^\/+/, "") : s;
+}
+function G(s) {
+  return s === 1 ? X : $;
+}
+function H(s, e, t) {
+  return t ? s.replace(e, (r, n) => {
+    const a = t[n];
+    if (a === void 0)
+      throw new Error(`Missing required path parameter: ${n}`);
+    return encodeURIComponent(a);
+  }) : s;
+}
+function v(s, e) {
+  const t = [];
+  let r;
+  for (; (r = e.exec(s)) !== null; )
+    t.push(r[1]);
+  return t;
+}
+const I = class m {
+  /**
+   * Extracts path parameters from a URL string.
+   *
+   * @param urlTemplate - The URL string to extract path parameters from
+   * @returns An array of path parameter names without the curly braces, or an empty array if no matches found
+   *
+   * @example
+   * ```typescript
+   * const resolver = uriTemplateResolver;
+   *
+   * // Extract multiple parameters
+   * const params = resolver.extractPathParams('/users/{id}/posts/{postId}');
+   * // params = ['id', 'postId']
+   *
+   * // Extract parameters from full URLs
+   * const urlParams = resolver.extractPathParams('https://api.example.com/{resource}/{id}');
+   * // urlParams = ['resource', 'id']
+   *
+   * // No parameters
+   * const noParams = resolver.extractPathParams('/users/profile');
+   * // noParams = []
+   * ```
+   */
+  extractPathParams(e) {
+    return v(
+      e,
+      m.PATH_PARAM_REGEX
+    );
+  }
+  /**
+   * Replaces placeholders in the URL with path parameters.
+   *
+   * @param urlTemplate - Path string containing placeholders, e.g., "http://localhost/users/{id}/posts/{postId}"
+   * @param pathParams - Path parameter object used to replace placeholders in the URL
+   * @returns Path string with placeholders replaced
+   * @throws Error when required path parameters are missing
+   *
+   * @example
+   * ```typescript
+   * const resolver = uriTemplateResolver;
+   *
+   * // Replace parameters
+   * const url = resolver.resolve('/users/{id}/posts/{postId}', { id: 123, postId: 456 });
+   * // url = '/users/123/posts/456'
+   *
+   * // Handle string parameter values
+   * const stringUrl = resolver.resolve('/users/{username}', { username: 'john_doe' });
+   * // stringUrl = '/users/john_doe'
+   *
+   * // URL encode parameter values
+   * const encodedUrl = resolver.resolve('/search/{query}', { query: 'hello world' });
+   * // encodedUrl = '/search/hello%20world'
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Missing required parameter throws an error
+   * const resolver = uriTemplateResolver;
+   * try {
+   *   resolver.resolve('/users/{id}', { name: 'John' });
+   * } catch (error) {
+   *   console.error(error.message); // "Missing required path parameter: id"
+   * }
+   * ```
+   */
+  resolve(e, t) {
+    return H(
+      e,
+      m.PATH_PARAM_REGEX,
+      t
+    );
+  }
+};
+I.PATH_PARAM_REGEX = /{([^}]+)}/g;
+let U = I;
+const $ = new U(), S = class E {
+  /**
+   * Extracts path parameters from an Express-style URL string.
+   *
+   * @param urlTemplate - The URL string with Express-style parameter placeholders
+   * @returns An array of parameter names extracted from the URL template
+   *
+   * @example
+   * ```typescript
+   * const resolver = new expressUrlTemplateResolver;
+   *
+   * // Extract multiple parameters
+   * const params = resolver.extractPathParams('/users/:id/posts/:postId');
+   * // params = ['id', 'postId']
+   *
+   * // No parameters
+   * const noParams = resolver.extractPathParams('/users/profile');
+   * // noParams = []
+   * ```
+   */
+  extractPathParams(e) {
+    return v(
+      e,
+      E.PATH_PARAM_REGEX
+    );
+  }
+  /**
+   * Replaces Express-style placeholders in the URL with path parameters.
+   *
+   * @param urlTemplate - Path string containing Express-style placeholders
+   * @param pathParams - Object containing parameter values to replace placeholders
+   * @returns Path string with placeholders replaced
+   * @throws Error when required path parameters are missing
+   *
+   * @example
+   * ```typescript
+   * const resolver = expressUrlTemplateResolver;
+   *
+   * // Replace parameters
+   * const url = resolver.resolve('/users/:id/posts/:postId', { id: 123, postId: 456 });
+   * // url = '/users/123/posts/456'
+   *
+   * // Handle string parameter values
+   * const stringUrl = resolver.resolve('/users/:username', { username: 'john_doe' });
+   * // stringUrl = '/users/john_doe'
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Missing required parameter throws an error
+   * const resolver = expressUrlTemplateResolver;
+   * try {
+   *   resolver.resolve('/users/:id', { name: 'John' });
+   * } catch (error) {
+   *   console.error(error.message); // "Missing required path parameter: id"
+   * }
+   * ```
+   */
+  resolve(e, t) {
+    return H(
+      e,
+      E.PATH_PARAM_REGEX,
+      t
+    );
+  }
+};
+S.PATH_PARAM_REGEX = /:([^/]+)/g;
+let L = S;
+const X = new L();
+class j {
+  /**
+   * Initializes a new UrlBuilder instance.
+   *
+   * @param baseURL - Base URL that all constructed URLs will be based on
+   * @param urlTemplateStyle - Optional style configuration for URL template resolution.
+   *                           Determines how path parameters are parsed and resolved.
+   *                           Defaults to UriTemplate style if not specified.
+   *
+   * @example
+   * ```typescript
+   * // Create a URL builder with default URI template style
+   * const urlBuilder = new UrlBuilder('https://api.example.com');
+   *
+   * // Create a URL builder with Express-style template resolution
+   * const expressUrlBuilder = new UrlBuilder('https://api.example.com', UrlTemplateStyle.Express);
+   * ```
+   */
+  constructor(e, t) {
+    this.baseURL = e, this.urlTemplateResolver = G(t);
+  }
+  /**
+   * Builds a complete URL, including path parameter replacement and query parameter addition.
+   *
+   * @param url - URL path to build (e.g., '/users/{id}/posts')
+   * @param params - URL parameters including path and query parameters
+   * @returns Complete URL string with base URL, path parameters interpolated, and query string appended
+   * @throws Error when required path parameters are missing
+   *
+   * @example
+   * ```typescript
+   * const urlBuilder = new UrlBuilder('https://api.example.com');
+   * const url = urlBuilder.build('/users/{id}/posts/{postId}', {
+   *   path: { id: 123, postId: 456 },
+   *   query: { filter: 'active', limit: 10 }
+   * });
+   * // Result: https://api.example.com/users/123/posts/456?filter=active&limit=10
+   * ```
+   */
+  build(e, t) {
+    const r = t?.path, n = t?.query, a = B(this.baseURL, e);
+    let i = this.urlTemplateResolver.resolve(a, r);
+    if (n) {
+      const u = new URLSearchParams(n).toString();
+      u && (i += "?" + u);
+    }
+    return i;
+  }
+  /**
+   * Resolves a complete URL from a FetchRequest.
+   *
+   * Used internally by the Fetcher to build the final URL for a request
+   * by combining the request URL with its URL parameters using this UrlBuilder.
+   *
+   * @param request - The FetchRequest containing URL and URL parameters
+   * @returns Complete resolved URL string
+   */
+  resolveRequestUrl(e) {
+    return this.build(e.url, e.urlParams);
+  }
+}
+class d extends Error {
+  /**
+   * Creates a new FetcherError instance.
+   *
+   * @param errorMsg - Optional error message. If not provided, will use the cause's message or a default message.
+   * @param cause - Optional underlying error that caused this error.
+   */
+  constructor(e, t) {
+    const r = e || t?.message || "An error occurred in the fetcher";
+    super(r), this.cause = t, this.name = "FetcherError", t?.stack && (this.stack = t.stack), Object.setPrototypeOf(this, d.prototype);
+  }
+}
+class l extends d {
+  /**
+   * Creates a new ExchangeError instance.
+   *
+   * @param exchange - The FetchExchange object containing request/response/error information.
+   * @param errorMsg - An optional error message.
+   */
+  constructor(e, t) {
+    const r = t || e.error?.message || e.response?.statusText || `Request to ${e.request.url} failed during exchange`;
+    super(r, e.error), this.exchange = e, this.name = "ExchangeError", Object.setPrototypeOf(this, l.prototype);
+  }
+}
+class T extends d {
+  /**
+   * Creates a new FetchTimeoutError instance.
+   *
+   * @param request - The request options that timed out
+   */
+  constructor(e) {
+    const t = e.method || "GET", r = `Request timeout of ${e.timeout}ms exceeded for ${t} ${e.url}`;
+    super(r), this.name = "FetchTimeoutError", this.request = e, Object.setPrototypeOf(this, T.prototype);
+  }
+}
+function D(s, e) {
+  return typeof s < "u" ? s : e;
+}
+async function J(s) {
+  const e = s.url, t = s.timeout, r = s;
+  if (s.signal)
+    return await fetch(e, r);
+  if (!t)
+    return s.abortController && (r.signal = s.abortController.signal), await fetch(e, r);
+  const n = s.abortController ?? new AbortController();
+  s.abortController = n, r.signal = n.signal;
+  let a = null;
+  const i = new Promise((u, F) => {
+    a = setTimeout(() => {
+      a && clearTimeout(a);
+      const b = new T(s);
+      n.abort(b), F(b);
+    }, t);
+  });
+  try {
+    return await Promise.race([fetch(e, r), i]);
+  } finally {
+    a && clearTimeout(a);
+  }
+}
+const V = (s) => s, k = (s) => s.requiredResponse, R = {
+  /**
+   * Returns the original FetchExchange object
+   */
+  Exchange: V,
+  /**
+   * Extracts the raw Response object
+   */
+  Response: k
+};
+function z(s, e) {
+  if (e ??= /* @__PURE__ */ new Map(), !s)
+    return e;
+  if (s instanceof Map) {
+    for (const [t, r] of s)
+      e.set(t, r);
+    return e;
+  }
+  for (const [t, r] of Object.entries(s))
+    e.set(t, r);
+  return e;
+}
+class Q {
+  constructor(e) {
+    this.fetcher = e.fetcher, this.request = e.request, this.resultExtractor = e.resultExtractor ?? R.Exchange, this.attributes = z(e.attributes), this._response = e.response, this.error = e.error;
+  }
+  /**
+   * Ensures that request headers object exists, creating it if necessary.
+   *
+   * This method checks if the request headers object is present and initializes
+   * it as an empty object if it's missing. This guarantees that headers can
+   * be safely accessed and modified after calling this method.
+   *
+   * @returns The request headers object, guaranteed to be non-null
+   */
+  ensureRequestHeaders() {
+    return this.request.headers || (this.request.headers = {}), this.request.headers;
+  }
+  /**
+   * Ensures that request URL parameters object exists with all required properties,
+   * creating them if necessary.
+   *
+   * This method checks if the request URL parameters object is present and initializes
+   * it with empty path and query objects if it's missing. It also ensures that both
+   * path and query sub-objects exist. This guarantees that URL parameters can be
+   * safely accessed and modified after calling this method.
+   *
+   * @returns The request URL parameters object with guaranteed non-null path and query properties
+   */
+  ensureRequestUrlParams() {
+    return this.request.urlParams || (this.request.urlParams = {
+      path: {},
+      query: {}
+    }), this.request.urlParams.path || (this.request.urlParams.path = {}), this.request.urlParams.query || (this.request.urlParams.query = {}), this.request.urlParams;
+  }
+  /**
+   * Checks if the exchange has an error.
+   *
+   * @returns true if an error is present, false otherwise
+   */
+  hasError() {
+    return !!this.error;
+  }
+  /**
+   * Sets the response object for this exchange.
+   * Also invalidates the cached extracted result to ensure data consistency
+   * when the response changes.
+   *
+   * @param response - The Response object to set, or undefined to clear the response
+   */
+  set response(e) {
+    this._response = e, this.cachedExtractedResult = void 0;
+  }
+  /**
+   * Gets the response object for this exchange.
+   *
+   * @returns The response object if available, undefined otherwise
+   */
+  get response() {
+    return this._response;
+  }
+  /**
+   * Checks if the exchange has a response.
+   *
+   * @returns true if a response is present, false otherwise
+   */
+  hasResponse() {
+    return !!this.response;
+  }
+  /**
+   * Gets the required response object, throwing an error if no response is available.
+   *
+   * This getter ensures that a response object is available, and throws an ExchangeError
+   * with details about the request if no response was received. This is useful for
+   * guaranteeing that downstream code always has a valid Response object to work with.
+   *
+   * @throws {ExchangeError} If no response is available for the current exchange
+   * @returns The Response object for this exchange
+   */
+  get requiredResponse() {
+    if (!this.response)
+      throw new l(
+        this,
+        `Request to ${this.request.url} failed with no response`
+      );
+    return this.response;
+  }
+  /**
+   * Extracts the result by applying the result extractor to the exchange.
+   * The result is cached after the first computation to avoid repeated computations.
+   *
+   * @returns The extracted result
+   */
+  async extractResult() {
+    return this.cachedExtractedResult !== void 0 ? await this.cachedExtractedResult : (this.cachedExtractedResult = this.resultExtractor(this), await this.cachedExtractedResult);
+  }
+}
+var o = /* @__PURE__ */ ((s) => (s.GET = "GET", s.POST = "POST", s.PUT = "PUT", s.DELETE = "DELETE", s.PATCH = "PATCH", s.HEAD = "HEAD", s.OPTIONS = "OPTIONS", s.TRACE = "TRACE", s))(o || {});
+const h = "Content-Type", y = class {
+};
+y.APPLICATION_JSON = "application/json", y.TEXT_EVENT_STREAM = "text/event-stream";
+let C = y;
+const Y = "UrlResolveInterceptor", O = Number.MIN_SAFE_INTEGER + 1e3;
+class K {
+  constructor() {
+    this.name = Y, this.order = O;
+  }
+  /**
+   * Resolves the final URL by combining the base URL, path parameters, and query parameters.
+   *
+   * @param exchange - The fetch exchange containing the request information
+   */
+  intercept(e) {
+    const t = e.request;
+    t.url = e.fetcher.urlBuilder.resolveRequestUrl(t);
+  }
+}
+const W = "RequestBodyInterceptor", Z = O + 1e3;
+class ee {
+  constructor() {
+    this.name = W, this.order = Z;
+  }
+  /**
+   * Checks if the provided body is of a supported complex type that doesn't require JSON serialization.
+   *
+   * @param body - The request body to check
+   * @returns True if the body is an ArrayBuffer, TypedArray, DataView or ReadableStream, false otherwise
+   */
+  isSupportedComplexBodyType(e) {
+    return e instanceof ArrayBuffer || ArrayBuffer.isView(e) || e instanceof ReadableStream;
+  }
+  /**
+   * Checks if the provided body is of a type that automatically appends Content-Type header.
+   *
+   * @param body - The request body to check
+   * @returns True if the body is a Blob, File, FormData or URLSearchParams, false otherwise
+   */
+  isAutoAppendContentType(e) {
+    return e instanceof Blob || e instanceof File || e instanceof FormData || e instanceof URLSearchParams;
+  }
+  /**
+   * Attempts to convert request body to a valid fetch API body type.
+   *
+   * This method follows a specific processing order to handle different types of request bodies:
+   * 1. Check if the body is null or undefined and return early if so
+   * 2. Check if the body is a non-object type and return early if so
+   * 3. Check if the body is a type that automatically appends Content-Type header
+   * 4. Check if the body is a supported complex type that doesn't require JSON serialization
+   * 5. For plain objects, convert to JSON string and set Content-Type header to application/json
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#setting_a_body}
+   *
+   * Supported types:
+   *   - a string
+   *   - ArrayBuffer
+   *   - TypedArray
+   *   - DataView
+   *   - Blob
+   *   - File
+   *   - URLSearchParams
+   *   - FormData
+   *   - ReadableStream
+   *
+   * For unsupported object types (like plain objects), they will be automatically
+   * converted to JSON strings.
+   *
+   * @param exchange - The exchange object containing the request to process
+   *
+   * @example
+   * // Plain object body will be converted to JSON
+   * const fetcher = new Fetcher();
+   * const exchange = new FetchExchange(
+   *   fetcher,
+   *   {
+   *     body: { name: 'John', age: 30 }
+   *   }
+   * );
+   * interceptor.intercept(exchange);
+   * // exchange.request.body will be '{"name":"John","age":30}'
+   * // exchange.request.headers will include 'Content-Type: application/json'
+   */
+  intercept(e) {
+    const t = e.request;
+    if (t.body === void 0 || t.body === null || typeof t.body != "object")
+      return;
+    const r = e.ensureRequestHeaders();
+    if (this.isAutoAppendContentType(t.body)) {
+      r[h] && delete r[h];
+      return;
+    }
+    this.isSupportedComplexBodyType(t.body) || (e.request.body = JSON.stringify(t.body), r[h] || (r[h] = C.APPLICATION_JSON));
+  }
+}
+const te = "FetchInterceptor", re = Number.MAX_SAFE_INTEGER - 1e3;
+class se {
+  constructor() {
+    this.name = te, this.order = re;
+  }
+  /**
+   * Intercept and process HTTP requests.
+   *
+   * Executes the actual HTTP request and applies timeout control. This is the final
+   * step in the request processing chain, responsible for calling the timeoutFetch
+   * function to send the network request.
+   *
+   * @param exchange - Exchange object containing request information
+   *
+   * @throws {FetchTimeoutError} Throws timeout exception when request times out
+   *
+   * @example
+   * // Usually called internally by Fetcher
+   * const fetcher = new Fetcher();
+   * const exchange = new FetchExchange(
+   *   fetcher,
+   *   {
+   *     url: 'https://api.example.com/users',
+   *     method: 'GET',
+   *     timeout: 5000
+   *   }
+   * );
+   * await fetchInterceptor.intercept(exchange);
+   * console.log(exchange.response); // HTTP response object
+   */
+  async intercept(e) {
+    e.response = await J(e.request);
+  }
+}
+const A = 0;
+function q(s, e) {
+  return (s.order ?? A) - (e.order ?? A);
+}
+function c(s, e) {
+  return e ? s.filter(e).sort(q) : [...s].sort(q);
+}
+class p {
+  /**
+   * Initializes a new InterceptorRegistry instance.
+   *
+   * @param interceptors - Initial array of interceptors to manage
+   *
+   * @remarks
+   * The provided interceptors will be sorted by their order property immediately
+   * upon construction.
+   */
+  constructor(e = []) {
+    this.sortedInterceptors = [], this.sortedInterceptors = c(e);
+  }
+  /**
+   * Gets the name of this interceptor registry.
+   *
+   * @returns The constructor name of this class
+   */
+  get name() {
+    return this.constructor.name;
+  }
+  /**
+   * Gets the order of this interceptor registry.
+   *
+   * @returns Number.MIN_SAFE_INTEGER, indicating this registry should execute early
+   */
+  get order() {
+    return Number.MIN_SAFE_INTEGER;
+  }
+  /**
+   * Returns an array of all interceptors in the registry.
+   */
+  get interceptors() {
+    return [...this.sortedInterceptors];
+  }
+  /**
+   * Adds an interceptor to this registry.
+   *
+   * @param interceptor - The interceptor to add
+   * @returns True if the interceptor was added, false if an interceptor with the
+   *          same name already exists
+   *
+   * @remarks
+   * Interceptors are uniquely identified by their name property. Attempting to add
+   * an interceptor with a name that already exists in the registry will fail.
+   *
+   * After adding, interceptors are automatically sorted by their order property.
+   */
+  use(e) {
+    return this.sortedInterceptors.some((t) => t.name === e.name) ? !1 : (this.sortedInterceptors = c([
+      ...this.sortedInterceptors,
+      e
+    ]), !0);
+  }
+  /**
+   * Removes an interceptor by name.
+   *
+   * @param name - The name of the interceptor to remove
+   * @returns True if an interceptor was removed, false if no interceptor with the
+   *          given name was found
+   */
+  eject(e) {
+    const t = this.sortedInterceptors;
+    return this.sortedInterceptors = c(
+      t,
+      (r) => r.name !== e
+    ), t.length !== this.sortedInterceptors.length;
+  }
+  /**
+   * Removes all interceptors from this registry.
+   */
+  clear() {
+    this.sortedInterceptors = [];
+  }
+  /**
+   * Executes all managed interceptors on the given exchange object.
+   *
+   * @param exchange - The exchange object to process
+   * @returns A promise that resolves when all interceptors have been executed
+   *
+   * @remarks
+   * Interceptors are executed in order, with each interceptor receiving the result
+   * of the previous interceptor. The first interceptor receives the original
+   * exchange object.
+   *
+   * If any interceptor throws an error, the execution chain is broken and the error
+   * is propagated to the caller.
+   */
+  async intercept(e) {
+    for (const t of this.sortedInterceptors)
+      await t.intercept(e);
+  }
+}
+class P extends l {
+  constructor(e) {
+    super(
+      e,
+      `Request failed with status code ${e.response?.status} for ${e.request.url}`
+    ), this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, P.prototype);
+  }
+}
+const ne = (s) => s >= 200 && s < 300, ae = "ValidateStatusInterceptor", oe = Number.MAX_SAFE_INTEGER - 1e3;
+class ie {
+  /**
+   * Creates a new ValidateStatusInterceptor instance.
+   *
+   * @param validateStatus - Function that determines if a status code is valid
+   */
+  constructor(e = ne) {
+    this.validateStatus = e;
+  }
+  /**
+   * Gets the name of this interceptor.
+   *
+   * @returns The name of this interceptor
+   */
+  get name() {
+    return ae;
+  }
+  /**
+   * Gets the order of this interceptor.
+   *
+   * @returns VALIDATE_STATUS_INTERCEPTOR_ORDER, indicating this interceptor should execute early
+   */
+  get order() {
+    return oe;
+  }
+  /**
+   * Validates the response status code.
+   *
+   * @param exchange - The exchange containing the response to validate
+   * @throws HttpStatusValidationError if the status code is not valid
+   *
+   * @remarks
+   * This method runs at the beginning of the response interceptor chain to ensure
+   * status validation happens before any other response processing. Invalid responses
+   * are caught and converted to HttpStatusValidationError early in the pipeline,
+   * preventing other response handlers from attempting to process them. Valid responses
+   * proceed through the rest of the response interceptor chain normally.
+   */
+  intercept(e) {
+    if (!e.response)
+      return;
+    const t = e.response.status;
+    if (!this.validateStatus(t))
+      throw new P(e);
+  }
+}
+class ce {
+  constructor() {
+    this.request = new p([
+      new K(),
+      new ee(),
+      new se()
+    ]), this.response = new p([
+      new ie()
+    ]), this.error = new p();
+  }
+  /**
+   * Processes a FetchExchange through the interceptor pipeline.
+   *
+   * This method is the core of the Fetcher's interceptor system. It executes the three
+   * phases of interceptors in sequence:
+   * 1. Request interceptors - Process the request before sending
+   * 2. Response interceptors - Process the response after receiving
+   * 3. Error interceptors - Handle any errors that occurred during the process
+   *
+   * The interceptor pipeline follows the Chain of Responsibility pattern, where each
+   * interceptor can modify the exchange object and decide whether to continue or
+   * terminate the chain.
+   *
+   * @param fetchExchange - The exchange object containing request, response, and error information
+   * @returns Promise that resolves to the processed FetchExchange
+   * @throws ExchangeError if an unhandled error occurs during processing
+   *
+   * @remarks
+   * The method handles three distinct phases:
+   *
+   * 1. Request Phase: Executes request interceptors which can modify headers, URL, body, etc.
+   *    Built-in interceptors handle URL resolution, body serialization, and actual HTTP execution.
+   *
+   * 2. Response Phase: Executes response interceptors which can transform or validate responses.
+   *    These interceptors only run if the request phase completed without throwing.
+   *
+   * 3. Error Phase: Executes error interceptors when any phase throws an error. Error interceptors
+   *    can handle errors by clearing the error property. If error interceptors clear the error,
+   *    the exchange is returned successfully.
+   *
+   * Error Handling:
+   * - If any interceptor throws an error, the error phase is triggered
+   * - Error interceptors can "fix" errors by clearing the error property on the exchange
+   * - If errors remain after error interceptors run, they are wrapped in ExchangeError
+   *
+   * Order of Execution:
+   * 1. Request interceptors (sorted by order property, ascending)
+   * 2. Response interceptors (sorted by order property, ascending) - only if no error in request phase
+   * 3. Error interceptors (sorted by order property, ascending) - only if an error occurred
+   *
+   * @example
+   * ```typescript
+   * // Create a fetcher with custom interceptors
+   * const fetcher = new Fetcher();
+   *
+   * // Add a request interceptor
+   * fetcher.interceptors.request.use({
+   *   name: 'AuthInterceptor',
+   *   order: 100,
+   *   async intercept(exchange: FetchExchange) {
+   *     exchange.request.headers = {
+   *       ...exchange.request.headers,
+   *       'Authorization': 'Bearer ' + getToken()
+   *     };
+   *   }
+   * });
+   *
+   * // Add a response interceptor
+   * fetcher.interceptors.response.use({
+   *   name: 'ResponseLogger',
+   *   order: 100,
+   *   async intercept(exchange: FetchExchange) {
+   *     console.log(`Response status: ${exchange.response?.status}`);
+   *   }
+   * });
+   *
+   * // Add an error interceptor
+   * fetcher.interceptors.error.use({
+   *   name: 'ErrorLogger',
+   *   order: 100,
+   *   async intercept(exchange: FetchExchange) {
+   *     console.error(`Request to ${exchange.request.url} failed:`, exchange.error);
+   *     // Clear the error to indicate it's been handled
+   *     exchange.error = undefined;
+   *   }
+   * });
+   *
+   * // Create and process an exchange
+   * const request: FetchRequest = {
+   *   url: '/api/users',
+   *   method: HttpMethod.GET
+   * };
+   * const exchange = new FetchExchange(fetcher, request);
+   * const result = await fetcher.exchange(exchange);
+   * ```
+   */
+  async exchange(e) {
+    try {
+      return await this.request.intercept(e), await this.response.intercept(e), e;
+    } catch (t) {
+      if (e.error = t, await this.error.intercept(e), !e.hasError())
+        return e;
+      throw new l(e);
+    }
+  }
+}
+function f(s, e) {
+  return e && e.resultExtractor && e.attributes ? e : {
+    resultExtractor: e?.resultExtractor ?? s?.resultExtractor ?? _.resultExtractor,
+    attributes: e?.attributes ?? s?.attributes
+  };
+}
+const w = {
+  [h]: C.APPLICATION_JSON
+}, N = {
+  baseURL: "",
+  headers: w
+}, _ = {
+  resultExtractor: R.Exchange
+}, x = {
+  resultExtractor: R.Response
+};
+class ue {
+  /**
+   * Initializes a new Fetcher instance with optional configuration.
+   *
+   * Creates a Fetcher with default settings that can be overridden through the options parameter.
+   * If no interceptors are provided, a default set of interceptors will be used.
+   *
+   * @param options - Configuration options for the Fetcher instance
+   * @param options.baseURL - The base URL to prepend to all requests. Defaults to empty string.
+   * @param options.headers - Default headers to include in all requests. Defaults to JSON content type.
+   * @param options.timeout - Default timeout for requests in milliseconds. No timeout by default.
+   * @param options.urlTemplateStyle - Style for URL template parameter interpolation.
+   * @param options.interceptors - Interceptor manager for processing requests and responses.
+   */
+  constructor(e = N) {
+    this.headers = w, this.urlBuilder = new j(e.baseURL, e.urlTemplateStyle), this.headers = e.headers ?? w, this.timeout = e.timeout, this.interceptors = e.interceptors ?? new ce();
+  }
+  /**
+   * Processes an HTTP request through the Fetcher's internal workflow.
+   *
+   * This method creates a FetchExchange object and passes it through the interceptor chain.
+   * It handles header merging, timeout resolution, and result extractor configuration.
+   *
+   * @param request - The HTTP request configuration to process
+   * @param options - Optional request options including result extractor and attributes
+   * @returns Promise that resolves to the processed FetchExchange object
+   */
+  async exchange(e, t) {
+    const r = {
+      ...this.headers,
+      ...e.headers
+    }, n = {
+      ...e,
+      headers: r,
+      timeout: D(e.timeout, this.timeout)
+    }, { resultExtractor: a, attributes: i } = f(
+      _,
+      t
+    ), u = new Q({
+      fetcher: this,
+      request: n,
+      resultExtractor: a,
+      attributes: i
+    });
+    return await this.interceptors.exchange(u);
+  }
+  /**
+   * Processes an HTTP request through the Fetcher's internal workflow.
+   *
+   * This method prepares the request by merging headers and timeout settings,
+   * creates a FetchExchange object, and passes it through the exchange method
+   * for interceptor processing.
+   *
+   * @template R - The type of the result to be returned
+   * @param request - Complete request configuration object
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ExchangeResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the extracted result based on resultExtractor
+   * @throws Error if an unhandled error occurs during request processing
+   */
+  async request(e, t) {
+    return await (await this.exchange(e, t)).extractResult();
+  }
+  /**
+   * Executes an HTTP request with the specified URL and options.
+   *
+   * This is the primary method for making HTTP requests. It processes the request
+   * through the interceptor chain and returns the resulting Response.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request (relative to baseURL if set)
+   * @param request - Request configuration including headers, body, parameters, etc.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   * @throws FetchError if the request fails and no response is generated
+   */
+  async fetch(e, t = {}, r) {
+    const n = {
+      ...t,
+      url: e
+    };
+    return await this.request(
+      n,
+      f(x, r)
+    );
+  }
+  /**
+   * Internal helper method for making HTTP requests with a specific method.
+   *
+   * This private method is used by the public HTTP method methods (get, post, etc.)
+   * to execute requests with the appropriate HTTP verb.
+   *
+   * @template R - The type of the result to be returned
+   * @param method - The HTTP method to use for the request
+   * @param url - The URL path for the request
+   * @param request - Additional request options
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async methodFetch(e, t, r = {}, n) {
+    const a = {
+      ...r,
+      url: t,
+      method: e
+    };
+    return await this.request(
+      a,
+      f(x, n)
+    );
+  }
+  /**
+   * Makes a GET HTTP request.
+   *
+   * Convenience method for making GET requests. The request body is omitted
+   * as GET requests should not contain a body according to HTTP specification.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request
+   * @param request - Request options excluding method and body
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async get(e, t = {}, r) {
+    return await this.methodFetch(o.GET, e, t, r);
+  }
+  /**
+   * Makes a PUT HTTP request.
+   *
+   * Convenience method for making PUT requests, commonly used for updating resources.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request
+   * @param request - Request options including body and other parameters
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async put(e, t = {}, r) {
+    return await this.methodFetch(o.PUT, e, t, r);
+  }
+  /**
+   * Makes a POST HTTP request.
+   *
+   * Convenience method for making POST requests, commonly used for creating resources.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request
+   * @param request - Request options including body and other parameters
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async post(e, t = {}, r) {
+    return await this.methodFetch(o.POST, e, t, r);
+  }
+  /**
+   * Makes a PATCH HTTP request.
+   *
+   * Convenience method for making PATCH requests, commonly used for partial updates.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request
+   * @param request - Request options including body and other parameters
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async patch(e, t = {}, r) {
+    return await this.methodFetch(o.PATCH, e, t, r);
+  }
+  /**
+   * Makes a DELETE HTTP request.
+   *
+   * Convenience method for making DELETE requests, commonly used for deleting resources.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request
+   * @param request - Request options excluding method and body
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async delete(e, t = {}, r) {
+    return await this.methodFetch(o.DELETE, e, t, r);
+  }
+  /**
+   * Makes a HEAD HTTP request.
+   *
+   * Convenience method for making HEAD requests, which retrieve headers only.
+   * The request body is omitted as HEAD requests should not contain a body.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request
+   * @param request - Request options excluding method and body
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async head(e, t = {}, r) {
+    return await this.methodFetch(o.HEAD, e, t, r);
+  }
+  /**
+   * Makes an OPTIONS HTTP request.
+   *
+   * Convenience method for making OPTIONS requests, commonly used for CORS preflight.
+   * The request body is omitted as OPTIONS requests typically don't contain a body.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request
+   * @param request - Request options excluding method and body
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   */
+  async options(e, t = {}, r) {
+    return await this.methodFetch(o.OPTIONS, e, t, r);
+  }
+  /**
+   * Sends an HTTP TRACE request to the specified URL and returns the response.
+   *
+   * The TRACE method is used to echo the received request for debugging purposes.
+   * This method automatically sets the HTTP method to TRACE and omits the request body
+   * since TRACE requests must not have a body according to the HTTP specification.
+   *
+   * @param url - The target URL for the TRACE request. Must be a valid absolute or relative URL.
+   * @param request - Request configuration options excluding 'method' and 'body' properties.
+   *                  Defaults to an empty object. Common properties include headers, cache settings, etc.
+   * @param options - Optional additional request parameters for extended functionality.
+   *                  May include custom handling logic or metadata for the request pipeline.
+   * @returns A Promise resolving to the response object of type R (defaults to Response).
+   *          The response contains status, headers, and body data from the TRACE request.
+   */
+  async trace(e, t = {}, r) {
+    return await this.methodFetch(o.TRACE, e, t, r);
+  }
+}
+const g = "default";
+class he {
+  constructor() {
+    this.registrar = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a Fetcher instance with a given name
+   *
+   * @param name - The name to register the fetcher under
+   * @param fetcher - The Fetcher instance to register
+   * @example
+   * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
+   * fetcherRegistrar.register('api', fetcher);
+   */
+  register(e, t) {
+    this.registrar.set(e, t);
+  }
+  /**
+   * Unregister a Fetcher instance by name
+   *
+   * @param name - The name of the fetcher to unregister
+   * @returns boolean - True if the fetcher was successfully unregistered, false otherwise
+   * @example
+   * const success = fetcherRegistrar.unregister('api');
+   * if (success) {
+   *   console.log('Fetcher unregistered successfully');
+   * }
+   */
+  unregister(e) {
+    return this.registrar.delete(e);
+  }
+  /**
+   * Get a Fetcher instance by name
+   *
+   * @param name - The name of the fetcher to retrieve
+   * @returns Fetcher | undefined - The Fetcher instance if found, undefined otherwise
+   * @example
+   * const fetcher = fetcherRegistrar.get('api');
+   * if (fetcher) {
+   *   // Use the fetcher
+   * }
+   */
+  get(e) {
+    return this.registrar.get(e);
+  }
+  /**
+   * Get a Fetcher instance by name, throwing an error if not found
+   *
+   * @param name - The name of the fetcher to retrieve
+   * @returns Fetcher - The Fetcher instance
+   * @throws Error - If no fetcher is registered with the given name
+   * @example
+   * try {
+   *   const fetcher = fetcherRegistrar.requiredGet('api');
+   *   // Use the fetcher
+   * } catch (error) {
+   *   console.error('Fetcher not found:', error.message);
+   * }
+   */
+  requiredGet(e) {
+    const t = this.get(e);
+    if (!t)
+      throw new Error(`Fetcher ${e} not found`);
+    return t;
+  }
+  /**
+   * Get the default Fetcher instance
+   *
+   * @returns Fetcher - The default Fetcher instance
+   * @throws Error - If no default fetcher is registered
+   * @example
+   * const defaultFetcher = fetcherRegistrar.default;
+   */
+  get default() {
+    return this.requiredGet(g);
+  }
+  /**
+   * Set the default Fetcher instance
+   *
+   * @param fetcher - The Fetcher instance to set as default
+   * @example
+   * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
+   * fetcherRegistrar.default = fetcher;
+   */
+  set default(e) {
+    this.register(g, e);
+  }
+  /**
+   * Get a copy of all registered fetchers
+   *
+   * @returns Map<string, Fetcher> - A copy of the internal registrar map
+   * @example
+   * const allFetchers = fetcherRegistrar.fetchers;
+   * for (const [name, fetcher] of allFetchers) {
+   *   console.log(`Fetcher ${name}:`, fetcher);
+   * }
+   */
+  get fetchers() {
+    return new Map(this.registrar);
+  }
+}
+const le = new he();
+class de extends ue {
+  /**
+   * Create a NamedFetcher instance and automatically register it with the global fetcherRegistrar
+   *
+   * @param name - The name to register this fetcher under
+   * @param options - Fetcher configuration options (same as Fetcher constructor)
+   *
+   * @example
+   * // Create with default options
+   * const fetcher1 = new NamedFetcher('default');
+   *
+   * // Create with custom options
+   * const fetcher2 = new NamedFetcher('api', {
+   *   baseURL: 'https://api.example.com',
+   *   timeout: 5000,
+   *   headers: { 'Authorization': 'Bearer token' }
+   * });
+   */
+  constructor(e, t = N) {
+    super(t), this.name = e, le.register(e, this);
+  }
+}
+new de(g);
+class Ee {
+  /**
+   * Creates an in-memory typed event bus
+   *
+   * @param type - The event type identifier for this bus
+   */
+  constructor(e) {
+    this.type = e, this.sortedHandlers = [];
+  }
+  /**
+   * Gets a copy of all registered event handlers, sorted by order
+   */
+  get handlers() {
+    return [...this.sortedHandlers];
+  }
+  /**
+   * Emits an event to all registered handlers serially
+   *
+   * Handlers are executed in order of their priority. Once-only handlers are removed after execution.
+   * Errors in individual handlers are logged but do not stop other handlers.
+   *
+   * @param event - The event to emit
+   */
+  async emit(e) {
+    const t = [];
+    for (const r of this.sortedHandlers)
+      try {
+        await r.handle(e);
+      } catch (n) {
+        console.warn(`Event handler error for ${r.name}:`, n);
+      } finally {
+        r.once && t.push(r);
+      }
+    t.length > 0 && (this.sortedHandlers = c(
+      this.sortedHandlers.filter((r) => !t.includes(r))
+    ));
+  }
+  /**
+   * Removes an event handler by name
+   *
+   * @param name - The name of the handler to remove
+   * @returns true if a handler was removed, false otherwise
+   */
+  off(e) {
+    const t = this.sortedHandlers;
+    return t.some((r) => r.name === e) ? (this.sortedHandlers = c(t, (r) => r.name !== e), !0) : !1;
+  }
+  /**
+   * Adds an event handler if not already present
+   *
+   * Handlers are sorted by their order property after addition.
+   *
+   * @param handler - The event handler to add
+   * @returns true if the handler was added, false if a handler with the same name already exists
+   */
+  on(e) {
+    const t = this.sortedHandlers;
+    return t.some((r) => r.name === e.name) ? !1 : (this.sortedHandlers = c([...t, e]), !0);
+  }
+  destroy() {
+    this.sortedHandlers = [];
+  }
+}
+class ye {
+  /**
+   * Creates a broadcast typed event bus
+   *
+   * @param delegate - The underlying TypedEventBus for local event handling
+   * @param channel - Optional custom BroadcastChannel name; defaults to `_broadcast_:{type}`
+   */
+  constructor(e, t) {
+    this.delegate = e, this.type = e.type;
+    const r = t ?? `_broadcast_:${this.type}`;
+    this.broadcastChannel = new BroadcastChannel(r), this.broadcastChannel.onmessage = async (n) => {
+      try {
+        await this.delegate.emit(n.data);
+      } catch (a) {
+        console.warn(`Broadcast event handler error for ${this.type}:`, a);
+      }
+    };
+  }
+  /**
+   * Gets a copy of all registered event handlers from the delegate
+   */
+  get handlers() {
+    return this.delegate.handlers;
+  }
+  /**
+   * Emits an event locally and broadcasts it to other tabs/windows
+   *
+   * @param event - The event to emit
+   */
+  async emit(e) {
+    await this.delegate.emit(e), this.broadcastChannel.postMessage(e);
+  }
+  /**
+   * Removes an event handler by name from the delegate
+   *
+   * @param name - The name of the handler to remove
+   * @returns true if a handler was removed, false otherwise
+   */
+  off(e) {
+    return this.delegate.off(e);
+  }
+  /**
+   * Adds an event handler to the delegate
+   *
+   * @param handler - The event handler to add
+   * @returns true if the handler was added, false if a handler with the same name already exists
+   */
+  on(e) {
+    return this.delegate.on(e);
+  }
+  /**
+   * Cleans up resources by closing the BroadcastChannel
+   */
+  destroy() {
+    this.broadcastChannel.close();
+  }
+}
+export {
+  ye as BroadcastTypedEventBus,
+  pe as EventBus,
+  fe as ParallelTypedEventBus,
+  Ee as SerialTypedEventBus
+};
+//# sourceMappingURL=index.es.js.map