stratal 0.0.17 → 0.0.18

package/dist/module-C3YZ-kZN.mjs

@@ -0,0 +1,719 @@
+import { A as Scope, H as ApplicationError, S as HttpException, k as ERROR_CODES } from "./errors--RBIvDXr.mjs";
+import { a as isListener } from "./events-UTJliZhl.mjs";
+import { t as isCommand } from "./is-command-PvULqiTa.mjs";
+import { t as isSeeder } from "./is-seeder-BN9Ej1r7.mjs";
+import { injectable, instancePerContainerCachingFactory, registry } from "tsyringe";
+//#region src/module/errors/invalid-module-provider.error.ts
+/**
+* InvalidModuleProviderError
+*
+* Thrown when a module provider configuration is invalid.
+* This indicates a misconfiguration in the @Module decorator providers array.
+*/
+var InvalidModuleProviderError = class extends ApplicationError {
+	constructor(provider) {
+		super("errors.invalidModuleProvider", ERROR_CODES.SYSTEM.INVALID_MODULE_PROVIDER, { provider: JSON.stringify(provider) });
+	}
+};
+//#endregion
+//#region src/module/module.decorator.ts
+const MODULE_OPTIONS_KEY = Symbol.for("stratal:module:options");
+/**
+* `@Module` decorator - defines a module with imports, providers, controllers, consumers, jobs
+*
+* Uses tsyringe's `@registry` internally to auto-register providers when module is imported.
+*
+* @example
+* ```typescript
+* @Module({
+*   imports: [OtherModule],
+*   providers: [MyService, MyRepository],
+*   controllers: [MyController],
+* })
+* export class MyModule {}
+* ```
+*/
+function Module(options) {
+	return (target) => {
+		Reflect.defineMetadata(MODULE_OPTIONS_KEY, options, target);
+		const registryEntries = buildRegistryEntries(options.providers ?? []);
+		if (registryEntries.length > 0) registry(registryEntries)(target);
+		return target;
+	};
+}
+/**
+* Get module options from decorated class
+*/
+function getModuleOptions(target) {
+	return Reflect.getMetadata(MODULE_OPTIONS_KEY, target);
+}
+/**
+* Check if a class is decorated with `@Module`
+*/
+function isModuleClass(target) {
+	return typeof target === "function" && Reflect.hasMetadata(MODULE_OPTIONS_KEY, target);
+}
+/**
+* Convert our Provider types to tsyringe registry format
+*
+* Maps provider scope to tsyringe's lifecycle option.
+* Scope enum values map directly to Lifecycle enum values.
+*/
+function buildRegistryEntries(providers) {
+	return providers.map((provider) => {
+		if (typeof provider === "function") return {
+			token: provider,
+			useClass: provider
+		};
+		if ("useClass" in provider) return {
+			token: provider.provide,
+			useClass: provider.useClass,
+			options: provider.scope !== void 0 ? { lifecycle: provider.scope } : void 0
+		};
+		if ("useValue" in provider) return {
+			token: provider.provide,
+			useValue: provider.useValue
+		};
+		if ("useFactory" in provider) {
+			const { provide, useFactory, inject = [] } = provider;
+			return {
+				token: provide,
+				useFactory: instancePerContainerCachingFactory((dependencyContainer) => {
+					return useFactory(...inject.map((token) => dependencyContainer.resolve(token)));
+				})
+			};
+		}
+		if ("useExisting" in provider) return {
+			token: provider.provide,
+			useToken: provider.useExisting
+		};
+		throw new InvalidModuleProviderError(provider);
+	});
+}
+//#endregion
+//#region src/router/errors/controller-method-not-found.error.ts
+/**
+* ControllerMethodNotFoundError
+*
+* Thrown when a controller method is registered but doesn't exist on the controller instance.
+* This typically indicates a mismatch between route registration and controller implementation.
+*/
+var ControllerMethodNotFoundError = class extends ApplicationError {
+	constructor(methodName, controllerName) {
+		super("errors.controllerMethodNotFound", ERROR_CODES.ROUTER.CONTROLLER_METHOD_NOT_FOUND, {
+			methodName,
+			controllerName
+		});
+	}
+};
+//#endregion
+//#region src/router/errors/controller-registration.error.ts
+/**
+* Error thrown when a controller fails to register
+*
+* This typically happens when:
+* - Controller is missing the `@Controller` decorator
+* - Controller route metadata is not set
+* - Controller class name is invalid
+*
+* Error Code: 9005
+*/
+var ControllerRegistrationError = class extends ApplicationError {
+	constructor(controllerName, reason) {
+		super("errors.controllerRegistration", ERROR_CODES.ROUTER.CONTROLLER_REGISTRATION_ERROR, {
+			controllerName,
+			reason
+		});
+	}
+};
+//#endregion
+//#region src/router/errors/hono-app-already-configured.error.ts
+/**
+* Error thrown when HonoApp.configure() is called more than once.
+*
+* HonoApp can only be configured a single time during application bootstrap.
+*/
+var HonoAppAlreadyConfiguredError = class extends ApplicationError {
+	constructor() {
+		super("errors.honoAppAlreadyConfigured", ERROR_CODES.SYSTEM.CONFIGURATION_ERROR);
+	}
+};
+//#endregion
+//#region src/router/errors/openapi-route-registration.error.ts
+/**
+* OpenAPIRouteRegistrationError
+*
+* Thrown when an OpenAPI route fails to register properly
+* This indicates a configuration issue with route decorators or metadata
+* Uses i18n key for localized error messages
+*
+* @example
+* ```typescript
+* throw new OpenAPIRouteRegistrationError('/api/v1/users', 'Missing response schema')
+* ```
+*/
+var OpenAPIRouteRegistrationError = class extends ApplicationError {
+	constructor(path, reason) {
+		super("errors.openapiRouteRegistration", ERROR_CODES.ROUTER.OPENAPI_ROUTE_REGISTRATION, {
+			path,
+			reason
+		});
+	}
+};
+//#endregion
+//#region src/router/errors/openapi-validation.error.ts
+/**
+* OpenAPIValidationError
+*
+* Thrown when OpenAPI request/response validation fails
+* Uses i18n key for localized error messages
+*
+* HTTP Status: 400 Bad Request
+* Error Code: 1004
+*
+* @example
+* ```typescript
+* throw new OpenAPIValidationError('Request body missing required field: email')
+* ```
+*/
+var OpenAPIValidationError = class extends ApplicationError {
+	constructor(details) {
+		super("errors.openapiValidation", ERROR_CODES.VALIDATION.REQUEST_VALIDATION, { details });
+	}
+};
+//#endregion
+//#region src/router/errors/route-not-found.error.ts
+/**
+* Error thrown when a requested route is not found
+*
+* HTTP Status: 404 Not Found
+* Error Code: 4004
+*/
+var RouteNotFoundError = class extends ApplicationError {
+	constructor(path, method) {
+		super("errors.routeNotFound", ERROR_CODES.RESOURCE.ROUTE_NOT_FOUND, {
+			path,
+			method
+		});
+	}
+};
+//#endregion
+//#region src/router/errors/schema-validation.error.ts
+/**
+* SchemaValidationError
+*
+* Thrown when Zod schema validation fails
+*/
+var SchemaValidationError = class extends ApplicationError {
+	constructor(zodError) {
+		const issues = zodError.issues.map((err) => ({
+			path: err.path.join("."),
+			message: err.message,
+			code: err.code
+		}));
+		super("errors.schemaValidation", ERROR_CODES.VALIDATION.SCHEMA_VALIDATION, { issues });
+	}
+};
+//#endregion
+//#region src/router/errors/index.ts
+/**
+* Error thrown when a request's host header does not match the expected domain pattern.
+*
+* HTTP Status: 404 Not Found
+*/
+var DomainMismatchError = class extends HttpException {
+	constructor() {
+		super(404, "errors.domainMismatch");
+	}
+};
+/**
+* Thrown when registering a named route that conflicts with an existing route name.
+*
+* Error Code: 9010
+*/
+var DuplicateRouteNameError = class extends ApplicationError {
+	constructor(name, existingHandler, newHandler) {
+		super("errors.duplicateRouteName", ERROR_CODES.ROUTER.DUPLICATE_ROUTE_NAME, {
+			name,
+			existingHandler,
+			newHandler
+		});
+	}
+};
+/**
+* Error thrown when a signed URL has an invalid or expired signature.
+*
+* HTTP Status: 403 Forbidden
+*/
+var InvalidSignatureError = class extends HttpException {
+	constructor() {
+		super(403, "errors.invalidSignature");
+	}
+};
+/**
+* Thrown when a required environment variable is not set.
+*
+* Maps to HTTP 500 via error code range (9xxx → 500).
+*/
+var MissingEnvironmentVariableError = class extends ApplicationError {
+	constructor(variable) {
+		super("errors.missingEnvironmentVariable", ERROR_CODES.SYSTEM.MISSING_ENVIRONMENT_VARIABLE, { variable });
+	}
+};
+/**
+* Thrown when a required path or domain parameter is missing during URL generation.
+*
+* Error Code: 9012
+*/
+var MissingRouteParamError = class extends ApplicationError {
+	constructor(param, name, path) {
+		super("errors.missingRouteParam", ERROR_CODES.ROUTER.MISSING_ROUTE_PARAM, {
+			param,
+			name,
+			path
+		});
+	}
+};
+/**
+* ResponseValidationError
+*
+* Thrown when a controller's response body does not match the declared Zod response schema.
+* Indicates a server-side schema mismatch — the controller is returning data that
+* violates its own API contract.
+*/
+var ResponseValidationError = class extends ApplicationError {
+	constructor(zodError) {
+		const issues = zodError.issues.map((err) => ({
+			path: err.path.join("."),
+			message: err.message,
+			code: err.code
+		}));
+		super("errors.responseValidation", ERROR_CODES.VALIDATION.RESPONSE_VALIDATION, { issues });
+	}
+};
+/**
+* Thrown when attempting to generate a URL for a route name that doesn't exist in the registry.
+*
+* Error Code: 9011
+*/
+var RouteNameNotFoundError = class extends ApplicationError {
+	constructor(name) {
+		super("errors.routeNameNotFound", ERROR_CODES.ROUTER.ROUTE_NAME_NOT_FOUND, { name });
+	}
+};
+/**
+* Thrown when `router.use()` is called inside a `group()` callback.
+* `use()` registers global middleware and is only allowed on the root Router.
+*
+* Error Code: 9013
+*/
+var RouterUseScopeError = class extends ApplicationError {
+	constructor() {
+		super("errors.routerUseScopeViolation", ERROR_CODES.ROUTER.USE_SCOPE_VIOLATION);
+	}
+};
+//#endregion
+//#region src/router/router.internals.ts
+/**
+* Symbol keys for Router internal accessors.
+*
+* These symbols are NOT exported from the public `stratal/router` barrel.
+* Only internal modules (RouterResolver) import them, keeping the Router's
+* public API clean — users never see these methods.
+*
+* Declared as individual unique symbols so TypeScript can distinguish
+* their return types in computed property access.
+*
+* @internal
+*/
+/** @internal */
+const getDefaultEntry = Symbol("Router.getDefaultEntry");
+/** @internal */
+const getGroups = Symbol("Router.getGroups");
+/** @internal */
+const getGlobalMiddleware = Symbol("Router.getGlobalMiddleware");
+//#endregion
+//#region src/router/router.ts
+/**
+* Fluent builder for route and middleware configuration.
+*
+* Scoped methods (`middleware()`, `prefix()`, `domain()`, `name()`, `version()`, `hideFromDocs()`)
+* apply only to this module's controllers or the sub-group's controllers.
+*
+* `use()` registers global middleware (all routes in the entire app).
+* Only callable on the root Router — throws inside `group()` callbacks.
+*
+* `group()` creates sub-groups for specific controllers with a callback.
+* Controllers in a sub-group are excluded from the parent scope.
+*/
+var Router = class Router {
+	_isChild;
+	_defaultEntry = { middleware: [] };
+	_groups = [];
+	_globalMiddleware = [];
+	constructor(isChild = false) {
+		this._isChild = isChild;
+	}
+	/** Dynamic path prefix. For shared segments like `/:companyId` */
+	prefix(path, params) {
+		this._defaultEntry.prefix = path;
+		this._defaultEntry.params = params;
+		return this;
+	}
+	/** Domain pattern for controllers in this scope */
+	domain(pattern) {
+		this._defaultEntry.domain = pattern;
+		return this;
+	}
+	/** Name prefix for routes in this scope */
+	name(prefix) {
+		this._defaultEntry.name = prefix;
+		return this;
+	}
+	/** Middleware applied to controllers in this scope */
+	middleware(...middlewares) {
+		this._defaultEntry.middleware.push(...middlewares);
+		return this;
+	}
+	/** API version for controllers in this scope */
+	version(version) {
+		this._defaultEntry.version = version;
+		return this;
+	}
+	/** Hide/show routes in this scope from OpenAPI docs */
+	hideFromDocs(hide = true) {
+		this._defaultEntry.hideFromDocs = hide;
+		return this;
+	}
+	/**
+	* Global middleware — applied to ALL routes in the entire app.
+	* Only callable on the root Router. Throws if called inside `group()`.
+	*/
+	use(...middlewares) {
+		if (this._isChild) throw new RouterUseScopeError();
+		this._globalMiddleware.push(...middlewares);
+		return this;
+	}
+	/**
+	* Create a sub-group for specific controllers/gateways.
+	* Controllers in a sub-group are excluded from the parent (default) scope.
+	* The callback receives a new Router (without `use()`) for fluent configuration.
+	*/
+	group(controllers, callback) {
+		const childRouter = new Router(true);
+		callback(childRouter);
+		this._groups.push({
+			...childRouter._defaultEntry,
+			controllers
+		});
+		return this;
+	}
+	[getDefaultEntry]() {
+		return this._defaultEntry;
+	}
+	[getGroups]() {
+		return this._groups;
+	}
+	[getGlobalMiddleware]() {
+		return this._globalMiddleware;
+	}
+};
+//#endregion
+//#region src/module/module-registry.ts
+/**
+* Module Registry
+*
+* Manages module lifecycle for the @Module decorator pattern.
+* Simplified for tsyringe's flat container model:
+* - Imports are traversed for registration (organization only)
+* - Modules registered in declaration order
+* - Lifecycle hooks: onInitialize, onShutdown
+*/
+/**
+* ModuleRegistry - manages module lifecycle
+*
+* @example
+* ```typescript
+* const registry = new ModuleRegistry(container, logger)
+* registry.register(AppModule)  // Traverses imports recursively
+* await registry.initialize()
+* // ... application running ...
+* await registry.shutdown()
+* ```
+*/
+var ModuleRegistry = class {
+	modules = [];
+	registeredClasses = /* @__PURE__ */ new Set();
+	initialized = false;
+	allControllers = [];
+	allConsumers = [];
+	allJobs = [];
+	allListeners = [];
+	allCommands = [];
+	allSeeders = [];
+	allRouterConfigs = [];
+	constructor(container, logger) {
+		this.container = container;
+		this.logger = logger;
+	}
+	/**
+	* Register a module (static or dynamic)
+	*
+	* @param moduleOrDynamic - Module class decorated with `@Module` or DynamicModule from configure()
+	*/
+	register(moduleOrDynamic) {
+		const { moduleClass, options } = this.resolveModule(moduleOrDynamic);
+		const isDynamic = this.isDynamicModule(moduleOrDynamic);
+		if (this.registeredClasses.has(moduleClass)) {
+			if (isDynamic) {
+				this.logger.debug(`Module ${moduleClass.name} already registered, registering DynamicModule providers`);
+				const { module: _, ...dynamicRest } = moduleOrDynamic;
+				for (const provider of dynamicRest.providers ?? []) this.registerProvider(provider);
+			} else this.logger.debug(`Module ${moduleClass.name} already registered, skipping`);
+			return;
+		}
+		this.registeredClasses.add(moduleClass);
+		this.logger.info(`Registering module: ${moduleClass.name}`);
+		for (const ImportedModule of options.imports ?? []) this.register(ImportedModule);
+		for (const provider of options.providers ?? []) this.registerProvider(provider);
+		for (const controller of options.controllers ?? []) {
+			this.container.register(controller);
+			this.allControllers.push(controller);
+		}
+		for (const consumer of options.consumers ?? []) {
+			this.container.register(consumer, Scope.Singleton);
+			this.allConsumers.push(consumer);
+			this.logger.info(`Collected consumer: ${consumer.name}`, { queueCount: this.allConsumers.length });
+		}
+		for (const job of options.jobs ?? []) {
+			this.container.register(job, Scope.Singleton);
+			this.allJobs.push(job);
+		}
+		this.modules.push({
+			moduleClass,
+			options,
+			instance: null
+		});
+	}
+	/**
+	* Register multiple modules in order
+	*/
+	registerAll(modules) {
+		for (const module of modules) this.register(module);
+	}
+	/**
+	* Initialize all modules (call configure and onInitialize hooks)
+	*/
+	async initialize() {
+		if (this.initialized) return;
+		this.logger.info("Initializing modules...");
+		const context = {
+			container: this.container,
+			logger: this.logger
+		};
+		for (const registered of this.modules) {
+			const instance = new registered.moduleClass();
+			registered.instance = instance;
+			if (this.hasRouteConfigurable(instance)) {
+				this.logger.debug(`Configuring routes for: ${registered.moduleClass.name}`);
+				const router = new Router();
+				instance.configureRoutes(router);
+				const moduleControllers = registered.options.controllers ?? [];
+				this.allRouterConfigs.push({
+					router,
+					controllers: moduleControllers
+				});
+				this.logger.debug(`Collected route config from ${registered.moduleClass.name} (${moduleControllers.length} controllers)`);
+			}
+			if (this.hasOnInitialize(instance)) {
+				this.logger.info(`Initializing: ${registered.moduleClass.name}`);
+				await instance.onInitialize(context);
+			}
+		}
+		this.initialized = true;
+		this.logger.info("All modules initialized");
+	}
+	/**
+	* Get all controllers registered from all modules
+	*/
+	getAllControllers() {
+		return this.allControllers;
+	}
+	/**
+	* Get all consumers registered from all modules
+	*/
+	getAllConsumers() {
+		return this.allConsumers;
+	}
+	/**
+	* Get all jobs registered from all modules
+	*/
+	getAllJobs() {
+		return this.allJobs;
+	}
+	/**
+	* Get all listeners registered from all modules
+	*/
+	getAllListeners() {
+		return this.allListeners;
+	}
+	/**
+	* Get all commands registered from all modules
+	*/
+	getAllCommands() {
+		return this.allCommands;
+	}
+	/**
+	* Get all seeders registered from all modules
+	*/
+	getAllSeeders() {
+		return this.allSeeders;
+	}
+	/**
+	* Get all Router configurations from modules implementing RouteConfigurable
+	*/
+	getAllRouterConfigs() {
+		return this.allRouterConfigs;
+	}
+	/**
+	* Call `onException()` on all modules that implement the OnException interface.
+	* Invoked by Application after the ExceptionHandler is resolved and `register()` is called.
+	*
+	* @param handler - The resolved ExceptionHandler instance
+	*/
+	configureExceptionHandlers(handler) {
+		for (const { moduleClass, instance } of this.modules) if (instance && this.hasOnException(instance)) {
+			this.logger.debug(`Configuring exception handlers for: ${moduleClass.name}`);
+			instance.onException(handler);
+		}
+	}
+	/**
+	* Shutdown all modules (call onShutdown hooks in reverse order)
+	*/
+	async shutdown() {
+		this.logger.info("Shutting down modules...");
+		const context = {
+			container: this.container,
+			logger: this.logger
+		};
+		const reversed = [...this.modules].reverse();
+		for (const { moduleClass, instance } of reversed) if (instance && this.hasOnShutdown(instance)) try {
+			await instance.onShutdown(context);
+		} catch (error) {
+			this.logger.error(`Error shutting down ${moduleClass.name}:`, error);
+		}
+		this.logger.info("All modules shut down");
+	}
+	/**
+	* Type guard for RouteConfigurable
+	*/
+	hasRouteConfigurable(instance) {
+		return typeof instance === "object" && instance !== null && "configureRoutes" in instance && typeof instance.configureRoutes === "function";
+	}
+	/**
+	* Type guard for OnInitialize
+	*/
+	hasOnInitialize(instance) {
+		return typeof instance === "object" && instance !== null && "onInitialize" in instance && typeof instance.onInitialize === "function";
+	}
+	/**
+	* Type guard for OnShutdown
+	*/
+	hasOnShutdown(instance) {
+		return typeof instance === "object" && instance !== null && "onShutdown" in instance && typeof instance.onShutdown === "function";
+	}
+	/**
+	* Type guard for OnException
+	*/
+	hasOnException(instance) {
+		return typeof instance === "object" && instance !== null && "onException" in instance && typeof instance.onException === "function";
+	}
+	/**
+	* Resolve module class and options from static or dynamic module
+	*
+	* For DynamicModules, merges the decorator metadata (consumers, controllers, jobs)
+	* with the DynamicModule options (providers, imports). This ensures modules using
+	* forRoot/forRootAsync patterns still have their decorator-defined consumers registered.
+	*/
+	resolveModule(moduleOrDynamic) {
+		if (this.isDynamicModule(moduleOrDynamic)) {
+			const { module: moduleClass, ...dynamicRest } = moduleOrDynamic;
+			const decoratorOptions = getModuleOptions(moduleClass) ?? {};
+			return {
+				moduleClass,
+				options: {
+					...decoratorOptions,
+					...dynamicRest,
+					providers: [...decoratorOptions.providers ?? [], ...dynamicRest.providers ?? []],
+					imports: [...decoratorOptions.imports ?? []]
+				}
+			};
+		}
+		const moduleClass = moduleOrDynamic;
+		return {
+			moduleClass,
+			options: getModuleOptions(moduleClass) ?? {}
+		};
+	}
+	/**
+	* Type guard for DynamicModule
+	*/
+	isDynamicModule(value) {
+		return typeof value === "object" && value !== null && "module" in value && typeof value.module === "function";
+	}
+	/**
+	* Register a single provider in the container
+	*/
+	registerProvider(provider) {
+		if (typeof provider === "function") {
+			this.container.register(provider);
+			this.collectIfListener(provider);
+			this.collectIfCommand(provider);
+			this.collectIfSeeder(provider);
+		} else if ("useClass" in provider) {
+			this.container.register(provider.provide, provider.useClass, provider.scope);
+			this.collectIfListener(provider.useClass);
+			this.collectIfCommand(provider.useClass);
+			this.collectIfSeeder(provider.useClass);
+		} else if ("useValue" in provider) this.container.registerValue(provider.provide, provider.useValue);
+		else if ("useFactory" in provider) {
+			const { provide, useFactory, inject = [] } = provider;
+			this.container.getTsyringeContainer().register(provide, { useFactory: instancePerContainerCachingFactory((dependencyContainer) => {
+				return useFactory(...inject.map((token) => dependencyContainer.resolve(token)));
+			}) });
+		} else if ("useExisting" in provider) this.container.registerExisting(provider.provide, provider.useExisting);
+	}
+	/**
+	* Check if a class is a `Command` and collect it for auto-wiring
+	*/
+	collectIfCommand(providerClass) {
+		if (isCommand(providerClass) && !this.allCommands.includes(providerClass)) {
+			injectable()(providerClass);
+			this.allCommands.push(providerClass);
+			this.logger.debug(`Collected command: ${providerClass.name}`);
+		}
+	}
+	/**
+	* Check if a class is a `Seeder` and collect it for auto-wiring
+	*/
+	collectIfSeeder(providerClass) {
+		if (isSeeder(providerClass) && !this.allSeeders.includes(providerClass)) {
+			this.allSeeders.push(providerClass);
+			this.logger.debug(`Collected seeder: ${providerClass.name}`);
+		}
+	}
+	/**
+	* Check if a class is a `@Listener()` and collect it for auto-wiring
+	*/
+	collectIfListener(providerClass) {
+		if (isListener(providerClass)) {
+			this.container.register(providerClass, providerClass, Scope.Singleton);
+			this.allListeners.push(providerClass);
+			this.logger.debug(`Collected listener: ${providerClass.name}`);
+		}
+	}
+};
+//#endregion
+export { getModuleOptions as C, Module as S, OpenAPIRouteRegistrationError as _, getGroups as a, ControllerMethodNotFoundError as b, InvalidSignatureError as c, ResponseValidationError as d, RouteNameNotFoundError as f, OpenAPIValidationError as g, RouteNotFoundError as h, getGlobalMiddleware as i, MissingEnvironmentVariableError as l, SchemaValidationError as m, Router as n, DomainMismatchError as o, RouterUseScopeError as p, getDefaultEntry as r, DuplicateRouteNameError as s, ModuleRegistry as t, MissingRouteParamError as u, HonoAppAlreadyConfiguredError as v, isModuleClass as w, MODULE_OPTIONS_KEY as x, ControllerRegistrationError as y };
+
+//# sourceMappingURL=module-C3YZ-kZN.mjs.map