@navios/adapter-xml 0.1.0 → 0.7.1

package/lib/index.d.mts

@@ -1,29 +1,520 @@
-export { XmlNode } from './_tsup-dts-rollup.mjs';
-export { AsyncXmlNode } from './_tsup-dts-rollup.mjs';
-export { CDataNode } from './_tsup-dts-rollup.mjs';
-export { RawXmlNode } from './_tsup-dts-rollup.mjs';
-export { ClassComponentNode } from './_tsup-dts-rollup.mjs';
-export { AnyXmlNode } from './_tsup-dts-rollup.mjs';
-export { BaseXmlStreamConfig } from './_tsup-dts-rollup.mjs';
-export { XmlComponent } from './_tsup-dts-rollup.mjs';
-export { ComponentClass } from './_tsup-dts-rollup.mjs';
-export { Fragment } from './_tsup-dts-rollup.mjs';
-export { AsyncComponent } from './_tsup-dts-rollup.mjs';
-export { CDataSymbol } from './_tsup-dts-rollup.mjs';
-export { RawXmlSymbol } from './_tsup-dts-rollup.mjs';
-export { ClassComponent } from './_tsup-dts-rollup.mjs';
-export { createElement } from './_tsup-dts-rollup.mjs';
-export { CData } from './_tsup-dts-rollup.mjs';
-export { DangerouslyInsertRawXml } from './_tsup-dts-rollup.mjs';
-export { renderToXml } from './_tsup-dts-rollup.mjs';
-export { MissingContainerError } from './_tsup-dts-rollup.mjs';
-export { RenderOptions } from './_tsup-dts-rollup.mjs';
-export { defineTag } from './_tsup-dts-rollup.mjs';
-export { TagComponent } from './_tsup-dts-rollup.mjs';
-export { XmlStream } from './_tsup-dts-rollup.mjs';
-export { Component } from './_tsup-dts-rollup.mjs';
-export { isComponentClass } from './_tsup-dts-rollup.mjs';
-export { XmlStreamParams } from './_tsup-dts-rollup.mjs';
-export { declareXmlStream } from './_tsup-dts-rollup.mjs';
-export { XmlStreamAdapterService } from './_tsup-dts-rollup.mjs';
-export { defineXmlEnvironment_alias_1 as defineXmlEnvironment } from './_tsup-dts-rollup.mjs';
+import { a as CDataSymbol, c as Fragment, d as XmlNode, f as ComponentClass, i as CDataNode, l as RawXmlNode, n as AsyncComponent, o as ClassComponent, p as XmlComponent, r as AsyncXmlNode, s as ClassComponentNode, t as AnyXmlNode, u as RawXmlSymbol } from "./xml-node-BQA44ydQ.mjs";
+import { t as createElement } from "./create-element-61MP7_99.mjs";
+import { AbstractHttpHandlerAdapterInterface, AnyInjectableType, ClassType, Container, HandlerMetadata, InjectionToken, Registry, ScopedContainer } from "@navios/core";
+import { BaseStreamConfig, EndpointFunctionArgs, HttpMethod, Util_FlatObject } from "@navios/builder";
+import { ZodObject, ZodRawShape, ZodType, z } from "zod/v4";
+
+//#region src/types/config.d.mts
+
+/**
+ * Configuration interface for XML Stream endpoints.
+ *
+ * Extends the base stream configuration with XML-specific options including
+ * content type, XML declaration, and encoding settings.
+ *
+ * @template Method - The HTTP method (GET, POST, etc.).
+ * @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+ * @template QuerySchema - Optional Zod schema for query parameter validation.
+ * @template RequestSchema - Optional Zod schema for request body validation.
+ *
+ * @example
+ * ```typescript
+ * const config: BaseXmlStreamConfig = {
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   contentType: 'application/rss+xml',
+ *   xmlDeclaration: true,
+ *   encoding: 'UTF-8',
+ * }
+ * ```
+ */
+interface BaseXmlStreamConfig<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = undefined> extends BaseStreamConfig<Method, Url, QuerySchema, RequestSchema> {
+  /** Content-Type header, defaults to 'application/xml' */
+  contentType?: 'application/xml' | 'text/xml' | 'application/rss+xml' | 'application/atom+xml';
+  /** Include XML declaration (<?xml version="1.0"?>) - defaults to true */
+  xmlDeclaration?: boolean;
+  /** XML encoding, defaults to 'UTF-8' */
+  encoding?: string;
+}
+//#endregion
+//#region src/runtime/special-nodes.d.mts
+/**
+ * CDATA component - wraps content in <![CDATA[...]]>
+ * Use for text content that may contain characters like < > &
+ * that would otherwise need escaping.
+ *
+ * Note: If content contains "]]>", it will be split into multiple CDATA sections.
+ */
+declare function CData({
+  children
+}: {
+  children: string;
+}): CDataNode;
+/**
+ * DangerouslyInsertRawXml - inserts raw XML/HTML without any escaping or wrapping
+ *
+ * WARNING: This bypasses all XML escaping. Only use with trusted content!
+ * Use cases:
+ * - Pre-rendered XML fragments
+ * - HTML content in RSS/Atom feeds (in description/content:encoded)
+ * - Including XML from external sources that's already valid
+ */
+declare function DangerouslyInsertRawXml({
+  children
+}: {
+  children: string;
+}): RawXmlNode;
+//#endregion
+//#region src/runtime/render-to-xml.d.mts
+/**
+ * Options for rendering XML from JSX nodes.
+ *
+ * @example
+ * ```ts
+ * const xml = await renderToXml(<rss version="2.0">...</rss>, {
+ *   declaration: true,
+ *   encoding: 'UTF-8',
+ *   pretty: true,
+ *   container: myContainer, // Required for class components
+ * })
+ * ```
+ */
+interface RenderOptions {
+  /** Include XML declaration (<?xml version="1.0"?>) - defaults to true */
+  declaration?: boolean;
+  /** XML encoding, defaults to 'UTF-8' */
+  encoding?: string;
+  /** Pretty print with indentation */
+  pretty?: boolean;
+  /**
+   * DI container for resolving class components.
+   * Required if the tree contains any class components.
+   */
+  container?: Container | ScopedContainer;
+}
+/**
+ * Error thrown when attempting to render a class component without a container.
+ *
+ * Class components require a dependency injection container to be instantiated.
+ * This error is thrown when `renderToXml` is called with a class component in
+ * the tree but no container is provided in the options.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await renderToXml(<MyClassComponent />)
+ * } catch (error) {
+ *   if (error instanceof MissingContainerError) {
+ *     // Provide a container
+ *     await renderToXml(<MyClassComponent />, { container })
+ *   }
+ * }
+ * ```
+ */
+declare class MissingContainerError extends Error {
+  constructor(componentName: string);
+}
+/**
+ * Renders a JSX XML node tree to an XML string.
+ *
+ * This function handles:
+ * - Regular XML nodes (tags with props and children)
+ * - Async components (resolves promises in parallel)
+ * - Class components (resolves via DI container)
+ * - CDATA sections
+ * - Raw XML content
+ * - Fragments
+ * - Text content with proper escaping
+ *
+ * @param node - The root XML node (JSX element) to render.
+ * @param options - Rendering options including declaration, encoding, pretty printing, and container.
+ * @returns A promise that resolves to the XML string.
+ *
+ * @throws {MissingContainerError} If the tree contains class components but no container is provided.
+ *
+ * @example
+ * ```ts
+ * // Simple rendering
+ * const xml = await renderToXml(<rss version="2.0"><channel>...</channel></rss>)
+ *
+ * // With options
+ * const xml = await renderToXml(<feed>...</feed>, {
+ *   declaration: true,
+ *   encoding: 'UTF-8',
+ *   pretty: true,
+ * })
+ *
+ * // With class components (requires container)
+ * const container = new Container()
+ * container.beginRequest('request-id')
+ * const xml = await renderToXml(<MyClassComponent />, { container })
+ * ```
+ */
+declare function renderToXml(node: AnyXmlNode, options?: RenderOptions): Promise<string>;
+//#endregion
+//#region src/tags/define-tag.d.mts
+/**
+ * Type for XML tag components created by `defineTag`.
+ *
+ * Tag components are functions that accept props and children, and return
+ * an XML node. They also have a `tagName` property for identification.
+ *
+ * @template Props - The props type for the tag component.
+ */
+interface TagComponent<Props extends Record<string, unknown>> {
+  (props: Props & {
+    children?: AnyXmlNode | AnyXmlNode[];
+  }): XmlNode;
+  tagName: string;
+}
+/**
+ * Creates a type-safe XML tag component with optional Zod schema validation.
+ *
+ * @param name - The tag name (supports namespace prefixes like 'atom:link')
+ * @param propsSchema - Optional Zod schema for validating props
+ * @returns A component function that can be used in JSX
+ *
+ * @example
+ * ```tsx
+ * // Simple tag
+ * const item = defineTag('item')
+ * <item>Content</item>
+ *
+ * // Namespaced tag with Zod validation
+ * const atomLink = defineTag('atom:link', z.object({
+ *   href: z.string().url(),
+ *   rel: z.enum(['self', 'alternate']),
+ *   type: z.string().optional(),
+ * }))
+ * <atomLink href="https://example.com/feed" rel="self" />
+ * ```
+ */
+declare function defineTag<T extends ZodRawShape>(name: string, propsSchema?: ZodObject<T>): TagComponent<T extends ZodRawShape ? z.infer<ZodObject<T>> : Record<string, never>>;
+//#endregion
+//#region src/decorators/xml-stream.decorator.d.mts
+/**
+ * Type helper that extracts the parameter types for an XML Stream endpoint handler.
+ *
+ * This type automatically infers the correct parameter types based on the endpoint
+ * configuration, including URL parameters, query parameters, and request body.
+ *
+ * @template EndpointDeclaration - The endpoint declaration type from `declareXmlStream`.
+ * @template Url - The URL path pattern.
+ * @template QuerySchema - The query parameter schema type.
+ *
+ * @example
+ * ```typescript
+ * const getFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed/:category',
+ *   querySchema: z.object({ page: z.string() }),
+ * })
+ *
+ * // XmlStreamParams<typeof getFeed> resolves to:
+ * // { urlParams: { category: string }, query: { page: string } }
+ * ```
+ */
+type XmlStreamParams<EndpointDeclaration extends {
+  config: BaseXmlStreamConfig<any, any, any, any>;
+}, Url extends string = EndpointDeclaration['config']['url'], QuerySchema = EndpointDeclaration['config']['querySchema']> = QuerySchema extends ZodObject ? EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : EndpointDeclaration['config']['requestSchema'] extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>;
+/**
+ * Decorator for XML Stream endpoints that return JSX-based XML responses.
+ *
+ * This decorator marks controller methods that return JSX elements, which will be
+ * automatically rendered to XML and sent with the appropriate Content-Type header.
+ * The method can be async and can contain async components, class components, and
+ * regular JSX elements.
+ *
+ * @template Method - The HTTP method (GET, POST, etc.).
+ * @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+ * @template QuerySchema - Optional Zod schema for query parameter validation.
+ * @template RequestSchema - Optional Zod schema for request body validation.
+ *
+ * @param endpoint - The endpoint declaration created with `declareXmlStream`.
+ * @returns A method decorator function.
+ *
+ * @throws {Error} If used on a non-function or non-method.
+ * @throws {Error} If the endpoint URL already exists.
+ *
+ * @example
+ * ```typescript
+ * import { XmlStream, declareXmlStream } from '@navios/adapter-xml'
+ * import { Controller } from '@navios/core'
+ *
+ * const getRssFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   contentType: 'application/rss+xml',
+ * })
+ *
+ * @Controller('/api')
+ * class FeedController {
+ *   @XmlStream(getRssFeed)
+ *   async getFeed() {
+ *     return (
+ *       <rss version="2.0">
+ *         <channel>
+ *           <title>My Feed</title>
+ *         </channel>
+ *       </rss>
+ *     )
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With query parameters
+ * const getSitemap = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/sitemap.xml',
+ *   querySchema: z.object({ page: z.string().optional() }),
+ * })
+ *
+ * @Controller()
+ * class SitemapController {
+ *   @XmlStream(getSitemap)
+ *   async getSitemap(params: { query?: { page?: string } }) {
+ *     const page = params.query?.page
+ *     return <urlset>...</urlset>
+ *   }
+ * }
+ * ```
+ */
+declare function XmlStream<Method extends HttpMethod = HttpMethod, Url extends string = string, QuerySchema = undefined, RequestSchema = ZodType>(endpoint: {
+  config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+}): (target: (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>) => Promise<any>,
+// Returns XmlNode
+context: ClassMethodDecoratorContext) => (params: QuerySchema extends ZodObject ? RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>> : RequestSchema extends ZodType ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>> : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>) => Promise<any>;
+//#endregion
+//#region src/decorators/component.decorator.d.mts
+/**
+ * Decorator for class-based XML components with dependency injection support.
+ *
+ * Class components must implement the `XmlComponent` interface with a `render()` method.
+ * They can optionally accept props via constructor, validated with a Zod schema.
+ *
+ * @overload
+ * Component without props (no schema).
+ *
+ * @example
+ * ```tsx
+ * @Component()
+ * class LatestPostsComponent implements XmlComponent {
+ *   private readonly postService = inject(PostService)
+ *
+ *   async render() {
+ *     const posts = await this.postService.getLatestPosts()
+ *     return <>{posts.map(post => <item>...</item>)}</>
+ *   }
+ * }
+ * ```
+ *
+ * @overload
+ * Component with props schema for type-safe props.
+ *
+ * @param options - Configuration object with schema and optional registry.
+ * @param options.schema - Zod schema for validating and typing component props.
+ * @param options.registry - Optional custom DI registry (defaults to global registry).
+ *
+ * @example
+ * ```tsx
+ * const DescriptionSchema = z.object({
+ *   content: z.string(),
+ *   wrapInCData: z.boolean().optional(),
+ * })
+ *
+ * @Component({ schema: DescriptionSchema })
+ * class DescriptionComponent implements XmlComponent {
+ *   constructor(private props: z.output<typeof DescriptionSchema>) {}
+ *
+ *   async render() {
+ *     return <description>{this.props.wrapInCData ? <CData>{this.props.content}</CData> : this.props.content}</description>
+ *   }
+ * }
+ * ```
+ *
+ * @overload
+ * Component with custom registry only (no props).
+ *
+ * @param options - Configuration object with registry.
+ * @param options.registry - Custom DI registry to use for this component.
+ */
+declare function Component(): <T extends ComponentClass>(target: T, context?: ClassDecoratorContext) => T;
+declare function Component<Schema extends ZodObject<ZodRawShape>>(options: {
+  schema: Schema;
+  registry?: Registry;
+}): <T extends new (props: z.output<Schema>, ...args: any[]) => XmlComponent>(target: T, context?: ClassDecoratorContext) => T;
+declare function Component(options: {
+  registry: Registry;
+}): <T extends ComponentClass>(target: T, context?: ClassDecoratorContext) => T;
+/**
+ * Type guard to check if a value is a component class.
+ *
+ * Component classes are classes decorated with `@Component` that implement
+ * the `XmlComponent` interface.
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is a component class, `false` otherwise.
+ *
+ * @example
+ * ```ts
+ * if (isComponentClass(MyClass)) {
+ *   // MyClass is a component class
+ *   const instance = await container.get(MyClass)
+ * }
+ * ```
+ */
+declare function isComponentClass(value: unknown): value is ComponentClass;
+//#endregion
+//#region src/handlers/xml-stream.d.mts
+/**
+ * Declares an XML Stream endpoint configuration for use with `@XmlStream` decorator.
+ *
+ * This function creates an endpoint declaration that can be used with the `@XmlStream`
+ * decorator to mark controller methods that return JSX-based XML responses.
+ *
+ * @template Method - The HTTP method (GET, POST, etc.).
+ * @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+ * @template QuerySchema - Optional Zod schema for query parameter validation.
+ * @template RequestSchema - Optional Zod schema for request body validation.
+ *
+ * @param config - The endpoint configuration including method, URL, schemas, and XML options.
+ * @returns An endpoint declaration object to be used with `@XmlStream` decorator.
+ *
+ * @example
+ * ```typescript
+ * import { declareXmlStream } from '@navios/adapter-xml'
+ * import { z } from 'zod/v4'
+ *
+ * // Simple endpoint
+ * export const getRssFeed = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/feed.xml',
+ *   contentType: 'application/rss+xml',
+ * })
+ *
+ * // With query parameters
+ * export const getSitemap = declareXmlStream({
+ *   method: 'GET',
+ *   url: '/sitemap.xml',
+ *   querySchema: z.object({
+ *     page: z.string().optional(),
+ *   }),
+ *   contentType: 'application/xml',
+ *   xmlDeclaration: true,
+ *   encoding: 'UTF-8',
+ * })
+ * ```
+ */
+declare function declareXmlStream<Method extends HttpMethod, Url extends string, QuerySchema = undefined, RequestSchema = undefined>(config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>): {
+  config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>;
+};
+//#endregion
+//#region src/adapters/xml-stream-adapter.service.d.mts
+/**
+ * Adapter service for handling XML Stream endpoints in Navios.
+ *
+ * This service integrates with the base stream adapter (Fastify or Bun) to handle
+ * XML endpoints that return JSX-based XML responses. It automatically renders JSX
+ * nodes to XML strings and sends them with the appropriate Content-Type headers.
+ *
+ * The service supports:
+ * - Async components (resolved in parallel)
+ * - Class components (resolved via DI container)
+ * - Regular JSX elements
+ * - CDATA sections
+ * - Raw XML content
+ *
+ * @implements {AbstractHttpHandlerAdapterInterface}
+ *
+ * @example
+ * ```ts
+ * // This service is automatically registered when using defineXmlEnvironment()
+ * // and is used by endpoints decorated with @XmlStream()
+ * ```
+ */
+declare class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {
+  /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */
+  protected streamAdapter: AbstractHttpHandlerAdapterInterface;
+  /**
+   * Prepares argument getters for parsing request data.
+   *
+   * Proxies to the base stream adapter to reuse existing argument preparation logic
+   * that handles query parameters, request body, and URL parameters for both
+   * Fastify and Bun adapters.
+   *
+   * @param handlerMetadata - The handler metadata with schemas and configuration.
+   * @returns An array of getter functions that populate request arguments.
+   */
+  prepareArguments(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): ((target: Record<string, any>, request: any) => Promise<void> | void)[];
+  /**
+   * Provides schema information for the handler.
+   *
+   * Proxies to the base stream adapter to reuse existing schema generation logic.
+   * For Fastify, this enables built-in validation. For Bun, this returns an empty object.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration and schemas.
+   * @returns Schema information (Fastify route schema or empty object for Bun).
+   */
+  provideSchema(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): Record<string, any>;
+  /**
+   * Checks if the handler has any validation schemas defined.
+   *
+   * Proxies to the base stream adapter to check for query or request schemas.
+   *
+   * @param handlerMetadata - The handler metadata containing configuration.
+   * @returns `true` if the handler has any schemas (query or request).
+   */
+  hasSchema(handlerMetadata: HandlerMetadata<any>): boolean;
+  /**
+   * Creates a request handler function for XML Stream endpoints.
+   *
+   * This method generates a handler that:
+   * 1. Parses and validates request data (body, query, URL params) using the base adapter
+   * 2. Invokes the controller method with validated arguments (returns JSX)
+   * 3. Renders the JSX tree to XML string (resolves async and class components)
+   * 4. Sends the XML response with appropriate Content-Type header
+   *
+   * The handler automatically detects the environment (Fastify vs Bun) and uses the
+   * appropriate response mechanism (reply object vs Response object).
+   *
+   * @param controller - The controller class containing the handler method.
+   * @param handlerMetadata - The handler metadata with configuration and schemas.
+   * @returns A function that handles incoming requests and sends XML responses.
+   */
+  provideHandler(controller: ClassType, handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>): (context: ScopedContainer, request: any, reply: any) => Promise<any>;
+}
+//#endregion
+//#region src/define-environment.d.mts
+/**
+ * Creates the XML environment configuration to be merged with base adapter (Fastify/Bun).
+ *
+ * @example
+ * ```typescript
+ * import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+ * import { defineXmlEnvironment } from '@navios/adapter-xml'
+ * import { NaviosFactory } from '@navios/core'
+ *
+ * const fastifyEnv = defineFastifyEnvironment()
+ * const xmlEnv = defineXmlEnvironment()
+ *
+ * // Merge environments
+ * const mergedEnv = {
+ *   httpTokens: new Map([
+ *     ...fastifyEnv.httpTokens,
+ *     ...xmlEnv.httpTokens,
+ *   ]),
+ * }
+ *
+ * const app = await NaviosFactory.create(AppModule, {
+ *   adapter: mergedEnv,
+ * })
+ * ```
+ */
+declare function defineXmlEnvironment(): {
+  httpTokens: Map<InjectionToken<any, undefined, false>, AnyInjectableType>;
+};
+//#endregion
+export { type AnyXmlNode, AsyncComponent, type AsyncXmlNode, type BaseXmlStreamConfig, CData, type CDataNode, CDataSymbol, ClassComponent, type ClassComponentNode, Component, type ComponentClass, DangerouslyInsertRawXml, Fragment, MissingContainerError, type RawXmlNode, RawXmlSymbol, type RenderOptions, type TagComponent, type XmlComponent, type XmlNode, XmlStream, XmlStreamAdapterService, type XmlStreamParams, createElement, declareXmlStream, defineTag, defineXmlEnvironment, isComponentClass, renderToXml };
+//# sourceMappingURL=index.d.mts.map

package/lib/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/config.mts","../src/runtime/special-nodes.mts","../src/runtime/render-to-xml.mts","../src/tags/define-tag.mts","../src/decorators/xml-stream.decorator.mts","../src/decorators/component.decorator.mts","../src/handlers/xml-stream.mts","../src/adapters/xml-stream-adapter.service.mts","../src/define-environment.mts"],"sourcesContent":[],"mappings":"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"}