🎯 MapView v2.0 - Global Deployment Ready

✨ MAJOR FEATURES:
• Auto-zoom intelligence với smart bounds fitting
• Enhanced 3D GPS markers với pulsing effects
• Professional route display với 6-layer rendering
• Status-based parking icons với availability indicators
• Production-ready build optimizations

🗺️ AUTO-ZOOM FEATURES:
• Smart bounds fitting cho GPS + selected parking
• Adaptive padding (50px) cho visual balance
• Max zoom control (level 16) để tránh quá gần
• Dynamic centering khi không có selection

🎨 ENHANCED VISUALS:
• 3D GPS marker với multi-layer pulse effects
• Advanced parking icons với status colors
• Selection highlighting với animation
• Dimming system cho non-selected items

🛣️ ROUTE SYSTEM:
• OpenRouteService API integration
• Multi-layer route rendering (glow, shadow, main, animated)
• Real-time distance & duration calculation
• Visual route info trong popup

📱 PRODUCTION READY:
• SSR safe với dynamic imports
• Build errors resolved
• Global deployment via Vercel
• Optimized performance

🌍 DEPLOYMENT:
• Vercel: https://whatever-ctk2auuxr-phong12hexdockworks-projects.vercel.app
• Bundle size: 22.8 kB optimized
• Global CDN distribution
• HTTPS enabled

💾 VERSION CONTROL:
• MapView-v2.0.tsx backup created
• MAPVIEW_VERSIONS.md documentation
• Full version history tracking

backend/node_modules/@nestjs/config/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.tsdk": "node_modules/typescript/lib"
+}

backend/node_modules/@nestjs/config/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2022 Kamil Mysliwiec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/node_modules/@nestjs/config/README.md

@@ -0,0 +1,51 @@
+<p align="center">
+  <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo-small.svg" width="120" alt="Nest Logo" /></a>
+</p>
+
+[travis-image]: https://api.travis-ci.org/nestjs/nest.svg?branch=master
+[travis-url]: https://travis-ci.org/nestjs/nest
+[linux-image]: https://img.shields.io/travis/nestjs/nest/master.svg?label=linux
+[linux-url]: https://travis-ci.org/nestjs/nest
+
+  <p align="center">A progressive <a href="http://nodejs.org" target="blank">Node.js</a> framework for building efficient and scalable server-side applications.</p>
+    <p align="center">
+<a href="https://www.npmjs.com/~nestjscore"><img src="https://img.shields.io/npm/v/@nestjs/core.svg" alt="NPM Version" /></a>
+<a href="https://www.npmjs.com/~nestjscore"><img src="https://img.shields.io/npm/l/@nestjs/core.svg" alt="Package License" /></a>
+<a href="https://www.npmjs.com/~nestjscore"><img src="https://img.shields.io/npm/dm/@nestjs/core.svg" alt="NPM Downloads" /></a>
+<a href="https://coveralls.io/github/nestjs/nest?branch=master"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#5" alt="Coverage" /></a>
+<a href="https://discord.gg/G7Qnnhy" target="_blank"><img src="https://img.shields.io/badge/discord-online-brightgreen.svg" alt="Discord"/></a>
+<a href="https://opencollective.com/nest#backer"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
+<a href="https://opencollective.com/nest#sponsor"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>
+  <a href="https://paypal.me/kamilmysliwiec"><img src="https://img.shields.io/badge/Donate-PayPal-dc3d53.svg"/></a>
+  <a href="https://twitter.com/nestframework"><img src="https://img.shields.io/twitter/follow/nestframework.svg?style=social&label=Follow"></a>
+</p>
+  <!--[![Backers on Open Collective](https://opencollective.com/nest/backers/badge.svg)](https://opencollective.com/nest#backer)
+  [![Sponsors on Open Collective](https://opencollective.com/nest/sponsors/badge.svg)](https://opencollective.com/nest#sponsor)-->
+
+## Description
+
+Configuration module for [Nest](https://github.com/nestjs/nest) based on the [dotenv](https://github.com/motdotla/dotenv) (to load process environment variables) package.
+
+## Installation
+
+```bash
+$ npm i --save @nestjs/config
+```
+
+## Quick Start
+
+[Overview & Tutorial](https://docs.nestjs.com/techniques/configuration)
+
+## Support
+
+Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
+
+## Stay in touch
+
+- Author - [Kamil Myśliwiec](https://twitter.com/kammysliwiec)
+- Website - [https://nestjs.com](https://nestjs.com/)
+- Twitter - [@nestframework](https://twitter.com/nestframework)
+
+## License
+
+Nest is [MIT licensed](LICENSE).

backend/node_modules/@nestjs/config/dist/conditional.module.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule, ModuleMetadata } from '@nestjs/common';
+/**
+ * @publicApi
+ */
+export declare class ConditionalModule {
+    /**
+     * @publicApi
+     */
+    static registerWhen(module: Required<ModuleMetadata>['imports'][number], condition: string | ((env: NodeJS.ProcessEnv) => boolean), options?: {
+        timeout?: number;
+        debug?: boolean;
+    }): Promise<Required<Pick<DynamicModule, "module" | "imports" | "exports">>>;
+}

backend/node_modules/@nestjs/config/dist/conditional.module.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_module_1 = require("./config.module");
+/**
+ * Same logic as in `@nestjs/core` package.
+ * @param instance The instance which should get the name from
+ * @returns The name of an instance or `undefined`
+ */
+const getInstanceName = (instance) => {
+    if (instance?.forwardRef) {
+        return instance.forwardRef()?.name;
+    }
+    if (instance.module) {
+        return instance.module?.name;
+    }
+    return instance.name;
+};
+/**
+ * @publicApi
+ */
+class ConditionalModule {
+    /**
+     * @publicApi
+     */
+    static async registerWhen(module, condition, options) {
+        const { timeout = 5000, debug = true } = options ?? {};
+        const moduleName = getInstanceName(module) || module.toString();
+        const timer = setTimeout(() => {
+            throw new Error(`Nest was not able to resolve the config variables within ${timeout} milliseconds. Bause of this, the ConditionalModule was not able to determine if ${moduleName} should be registered or not`);
+        }, timeout);
+        timer.unref();
+        const returnModule = { module: ConditionalModule, imports: [], exports: [] };
+        if (typeof condition === 'string') {
+            const key = condition;
+            condition = env => {
+                return env[key]?.toLowerCase() !== 'false';
+            };
+        }
+        await config_module_1.ConfigModule.envVariablesLoaded;
+        clearTimeout(timer);
+        const evaluation = condition(process.env);
+        if (evaluation) {
+            returnModule.imports.push(module);
+            returnModule.exports.push(module);
+        }
+        else {
+            if (debug) {
+                common_1.Logger.debug(`${condition.toString()} evaluated to false. Skipping the registration of ${moduleName}`, ConditionalModule.name);
+            }
+        }
+        return returnModule;
+    }
+}
+exports.ConditionalModule = ConditionalModule;

backend/node_modules/@nestjs/config/dist/config-host.module.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @publicApi
+ */
+export declare class ConfigHostModule {
+}

backend/node_modules/@nestjs/config/dist/config-host.module.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigHostModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_constants_1 = require("./config.constants");
+const config_service_1 = require("./config.service");
+/**
+ * @publicApi
+ */
+let ConfigHostModule = class ConfigHostModule {
+};
+exports.ConfigHostModule = ConfigHostModule;
+exports.ConfigHostModule = ConfigHostModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [
+            {
+                provide: config_constants_1.CONFIGURATION_TOKEN,
+                useFactory: () => ({}),
+            },
+            {
+                provide: config_constants_1.CONFIGURATION_SERVICE_TOKEN,
+                useClass: config_service_1.ConfigService,
+            },
+        ],
+        exports: [config_constants_1.CONFIGURATION_TOKEN, config_constants_1.CONFIGURATION_SERVICE_TOKEN],
+    })
+], ConfigHostModule);

backend/node_modules/@nestjs/config/dist/config.constants.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Injection tokens
+ */
+export declare const CONFIGURATION_SERVICE_TOKEN: unique symbol;
+export declare const CONFIGURATION_TOKEN = "CONFIGURATION_TOKEN";
+export declare const CONFIGURATION_LOADER = "CONFIGURATION_LOADER";
+export declare const VALIDATED_ENV_LOADER = "VALIDATED_ENV_LOADER";
+export declare const PARTIAL_CONFIGURATION_KEY = "PARTIAL_CONFIGURATION_KEY";
+export declare const PARTIAL_CONFIGURATION_PROPNAME = "KEY";
+export declare const VALIDATED_ENV_PROPNAME = "_PROCESS_ENV_VALIDATED";
+export declare const AS_PROVIDER_METHOD_KEY = "asProvider";

backend/node_modules/@nestjs/config/dist/config.constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AS_PROVIDER_METHOD_KEY = exports.VALIDATED_ENV_PROPNAME = exports.PARTIAL_CONFIGURATION_PROPNAME = exports.PARTIAL_CONFIGURATION_KEY = exports.VALIDATED_ENV_LOADER = exports.CONFIGURATION_LOADER = exports.CONFIGURATION_TOKEN = exports.CONFIGURATION_SERVICE_TOKEN = void 0;
+/**
+ * Injection tokens
+ */
+exports.CONFIGURATION_SERVICE_TOKEN = Symbol('CONFIG_SERVICE');
+exports.CONFIGURATION_TOKEN = 'CONFIGURATION_TOKEN';
+exports.CONFIGURATION_LOADER = 'CONFIGURATION_LOADER';
+exports.VALIDATED_ENV_LOADER = 'VALIDATED_ENV_LOADER';
+exports.PARTIAL_CONFIGURATION_KEY = 'PARTIAL_CONFIGURATION_KEY';
+exports.PARTIAL_CONFIGURATION_PROPNAME = 'KEY';
+exports.VALIDATED_ENV_PROPNAME = '_PROCESS_ENV_VALIDATED';
+exports.AS_PROVIDER_METHOD_KEY = 'asProvider';

backend/node_modules/@nestjs/config/dist/config.module.d.ts

@@ -0,0 +1,30 @@
+import { DynamicModule } from '@nestjs/common';
+import { ConfigFactory, ConfigModuleOptions } from './interfaces';
+/**
+ * @publicApi
+ */
+export declare class ConfigModule {
+    /**
+     * This promise resolves when "dotenv" completes loading environment variables.
+     * When "ignoreEnvFile" is set to true, then it will resolve immediately after the
+     * "ConfigModule#forRoot" method is called.
+     */
+    static get envVariablesLoaded(): Promise<void>;
+    private static environmentVariablesLoadedSignal;
+    private static readonly _envVariablesLoaded;
+    /**
+     * Loads process environment variables depending on the "ignoreEnvFile" flag and "envFilePath" value.
+     * Also, registers custom configurations globally.
+     * @param options
+     */
+    static forRoot(options?: ConfigModuleOptions): Promise<DynamicModule>;
+    /**
+     * Registers configuration object (partial registration).
+     * @param config
+     */
+    static forFeature(config: ConfigFactory): DynamicModule;
+    private static loadEnvFile;
+    private static assignVariablesToProcess;
+    private static mergePartial;
+    private static getSchemaValidationOptions;
+}

backend/node_modules/@nestjs/config/dist/config.module.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var ConfigModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigModule = void 0;
+const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const dotenv = __importStar(require("dotenv"));
+const dotenv_expand_1 = require("dotenv-expand");
+const fs = __importStar(require("fs"));
+const path_1 = require("path");
+const config_host_module_1 = require("./config-host.module");
+const config_constants_1 = require("./config.constants");
+const config_service_1 = require("./config.service");
+const create_config_factory_util_1 = require("./utils/create-config-factory.util");
+const get_registration_token_util_1 = require("./utils/get-registration-token.util");
+const merge_configs_util_1 = require("./utils/merge-configs.util");
+/**
+ * @publicApi
+ */
+let ConfigModule = ConfigModule_1 = class ConfigModule {
+    /**
+     * This promise resolves when "dotenv" completes loading environment variables.
+     * When "ignoreEnvFile" is set to true, then it will resolve immediately after the
+     * "ConfigModule#forRoot" method is called.
+     */
+    static get envVariablesLoaded() {
+        return this._envVariablesLoaded;
+    }
+    /**
+     * Loads process environment variables depending on the "ignoreEnvFile" flag and "envFilePath" value.
+     * Also, registers custom configurations globally.
+     * @param options
+     */
+    static async forRoot(options = {}) {
+        const envFilePaths = Array.isArray(options.envFilePath)
+            ? options.envFilePath
+            : [options.envFilePath || (0, path_1.resolve)(process.cwd(), '.env')];
+        let validatedEnvConfig = undefined;
+        let config = options.ignoreEnvFile
+            ? {}
+            : this.loadEnvFile(envFilePaths, options);
+        if (!options.ignoreEnvVars) {
+            config = {
+                ...config,
+                ...process.env,
+            };
+        }
+        if (options.validate) {
+            const validatedConfig = options.validate(config);
+            validatedEnvConfig = validatedConfig;
+            this.assignVariablesToProcess(validatedConfig);
+        }
+        else if (options.validationSchema) {
+            const validationOptions = this.getSchemaValidationOptions(options);
+            const { error, value: validatedConfig } = options.validationSchema.validate(config, validationOptions);
+            if (error) {
+                throw new Error(`Config validation error: ${error.message}`);
+            }
+            validatedEnvConfig = validatedConfig;
+            this.assignVariablesToProcess(validatedConfig);
+        }
+        else {
+            this.assignVariablesToProcess(config);
+        }
+        const isConfigToLoad = options.load && options.load.length;
+        const configFactory = await Promise.all(options.load || []);
+        const providers = configFactory
+            .map(factory => (0, create_config_factory_util_1.createConfigProvider)(factory))
+            .filter(item => item);
+        const configProviderTokens = providers.map(item => item.provide);
+        const configServiceProvider = {
+            provide: config_service_1.ConfigService,
+            useFactory: (configService) => {
+                if (options.cache) {
+                    configService.isCacheEnabled = true;
+                }
+                configService.setEnvFilePaths(envFilePaths);
+                return configService;
+            },
+            inject: [config_constants_1.CONFIGURATION_SERVICE_TOKEN, ...configProviderTokens],
+        };
+        providers.push(configServiceProvider);
+        if (validatedEnvConfig) {
+            const validatedEnvConfigLoader = {
+                provide: config_constants_1.VALIDATED_ENV_LOADER,
+                useFactory: (host) => {
+                    host[config_constants_1.VALIDATED_ENV_PROPNAME] = validatedEnvConfig;
+                },
+                inject: [config_constants_1.CONFIGURATION_TOKEN],
+            };
+            providers.push(validatedEnvConfigLoader);
+        }
+        this.environmentVariablesLoadedSignal();
+        return {
+            module: ConfigModule_1,
+            global: options.isGlobal,
+            providers: isConfigToLoad
+                ? [
+                    ...providers,
+                    {
+                        provide: config_constants_1.CONFIGURATION_LOADER,
+                        useFactory: (host, ...configurations) => {
+                            configurations.forEach((item, index) => this.mergePartial(host, item, providers[index]));
+                        },
+                        inject: [config_constants_1.CONFIGURATION_TOKEN, ...configProviderTokens],
+                    },
+                ]
+                : providers,
+            exports: [config_service_1.ConfigService, ...configProviderTokens],
+        };
+    }
+    /**
+     * Registers configuration object (partial registration).
+     * @param config
+     */
+    static forFeature(config) {
+        const configProvider = (0, create_config_factory_util_1.createConfigProvider)(config);
+        const serviceProvider = {
+            provide: config_service_1.ConfigService,
+            useFactory: (configService) => configService,
+            inject: [config_constants_1.CONFIGURATION_SERVICE_TOKEN, configProvider.provide],
+        };
+        return {
+            module: ConfigModule_1,
+            providers: [
+                configProvider,
+                serviceProvider,
+                {
+                    provide: config_constants_1.CONFIGURATION_LOADER,
+                    useFactory: (host, partialConfig) => {
+                        this.mergePartial(host, partialConfig, configProvider);
+                    },
+                    inject: [config_constants_1.CONFIGURATION_TOKEN, configProvider.provide],
+                },
+            ],
+            exports: [config_service_1.ConfigService, configProvider.provide],
+        };
+    }
+    static loadEnvFile(envFilePaths, options) {
+        let config = {};
+        for (const envFilePath of envFilePaths) {
+            if (fs.existsSync(envFilePath)) {
+                config = Object.assign(dotenv.parse(fs.readFileSync(envFilePath)), config);
+                if (options.expandVariables) {
+                    const expandOptions = typeof options.expandVariables === 'object'
+                        ? options.expandVariables
+                        : {};
+                    config =
+                        (0, dotenv_expand_1.expand)({ ...expandOptions, parsed: config }).parsed || config;
+                }
+            }
+        }
+        return config;
+    }
+    static assignVariablesToProcess(config) {
+        if (!(0, shared_utils_1.isObject)(config)) {
+            return;
+        }
+        const keys = Object.keys(config).filter(key => !(key in process.env));
+        keys.forEach(key => {
+            const value = config[key];
+            if (typeof value === 'string') {
+                process.env[key] = value;
+            }
+            else if (typeof value === 'boolean' || typeof value === 'number') {
+                process.env[key] = `${value}`;
+            }
+        });
+    }
+    static mergePartial(host, item, provider) {
+        const factoryRef = provider.useFactory;
+        const token = (0, get_registration_token_util_1.getRegistrationToken)(factoryRef);
+        (0, merge_configs_util_1.mergeConfigObject)(host, item, token);
+    }
+    static getSchemaValidationOptions(options) {
+        if (options.validationOptions) {
+            if (typeof options.validationOptions.allowUnknown === 'undefined') {
+                options.validationOptions.allowUnknown = true;
+            }
+            return options.validationOptions;
+        }
+        return {
+            abortEarly: false,
+            allowUnknown: true,
+        };
+    }
+};
+exports.ConfigModule = ConfigModule;
+ConfigModule._envVariablesLoaded = new Promise(resolve => (ConfigModule_1.environmentVariablesLoadedSignal = resolve));
+exports.ConfigModule = ConfigModule = ConfigModule_1 = __decorate([
+    (0, common_1.Module)({
+        imports: [config_host_module_1.ConfigHostModule],
+        providers: [
+            {
+                provide: config_service_1.ConfigService,
+                useExisting: config_constants_1.CONFIGURATION_SERVICE_TOKEN,
+            },
+        ],
+        exports: [config_host_module_1.ConfigHostModule, config_service_1.ConfigService],
+    })
+], ConfigModule);

backend/node_modules/@nestjs/config/dist/config.service.d.ts

@@ -0,0 +1,120 @@
+import { ConfigChangeEvent } from './interfaces/config-change-event.interface';
+import { NoInferType, Path, PathValue } from './types';
+/**
+ * `ValidatedResult<WasValidated, T>
+ *
+ * If `WasValidated` is `true`, return `T`.
+ * Otherwise, constructs the type `T` with `undefined`.
+ */
+type ValidatedResult<WasValidated extends boolean, T> = WasValidated extends true ? T : T | undefined;
+/**
+ * @publicApi
+ */
+export interface ConfigGetOptions {
+    /**
+     * If present, "get" method will try to automatically
+     * infer a type of property based on the type argument
+     * specified at the "ConfigService" class-level (example: ConfigService<Configuration>).
+     */
+    infer: true;
+}
+type KeyOf<T> = keyof T extends never ? string : keyof T;
+/**
+ * @publicApi
+ */
+export declare class ConfigService<K = Record<string, unknown>, WasValidated extends boolean = false> {
+    private readonly internalConfig;
+    private set isCacheEnabled(value);
+    private get isCacheEnabled();
+    private readonly cache;
+    private readonly _changes$;
+    private _isCacheEnabled;
+    private envFilePaths;
+    constructor(internalConfig?: Record<string, any>);
+    /**
+     * Returns a stream of configuration changes.
+     * Each event contains the attribute path, the old value and the new value.
+     */
+    get changes$(): import("rxjs").Observable<ConfigChangeEvent<any, any>>;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * @param propertyPath
+     */
+    get<T = any>(propertyPath: KeyOf<K>): ValidatedResult<WasValidated, T>;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * @param propertyPath
+     * @param options
+     */
+    get<T = K, P extends Path<T> = any, R = PathValue<T, P>>(propertyPath: P, options: ConfigGetOptions): ValidatedResult<WasValidated, R>;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * It returns a default value if the key does not exist.
+     * @param propertyPath
+     * @param defaultValue
+     */
+    get<T = any>(propertyPath: KeyOf<K>, defaultValue: NoInferType<T>): T;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * It returns a default value if the key does not exist.
+     * @param propertyPath
+     * @param defaultValue
+     * @param options
+     */
+    get<T = K, P extends Path<T> = any, R = PathValue<T, P>>(propertyPath: P, defaultValue: NoInferType<R>, options: ConfigGetOptions): Exclude<R, undefined>;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * @param propertyPath
+     */
+    getOrThrow<T = any>(propertyPath: KeyOf<K>): Exclude<T, undefined>;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * @param propertyPath
+     * @param options
+     */
+    getOrThrow<T = K, P extends Path<T> = any, R = PathValue<T, P>>(propertyPath: P, options: ConfigGetOptions): Exclude<R, undefined>;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * It returns a default value if the key does not exist.
+     * If the default value is undefined an exception will be thrown.
+     * @param propertyPath
+     * @param defaultValue
+     */
+    getOrThrow<T = any>(propertyPath: KeyOf<K>, defaultValue: NoInferType<T>): Exclude<T, undefined>;
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * It returns a default value if the key does not exist.
+     * If the default value is undefined an exception will be thrown.
+     * @param propertyPath
+     * @param defaultValue
+     * @param options
+     */
+    getOrThrow<T = K, P extends Path<T> = any, R = PathValue<T, P>>(propertyPath: P, defaultValue: NoInferType<R>, options: ConfigGetOptions): Exclude<R, undefined>;
+    /**
+     * Sets a configuration value based on property path.
+     * @param propertyPath
+     * @param value
+     */
+    set<T = any>(propertyPath: KeyOf<K>, value: T): void;
+    /**
+     * Sets env file paths from `config.module.ts` to parse.
+     * @param paths
+     */
+    setEnvFilePaths(paths: string[]): void;
+    private getFromCache;
+    private getFromValidatedEnv;
+    private getFromProcessEnv;
+    private getFromInternalConfig;
+    private setInCacheIfDefined;
+    private isGetOptionsObject;
+    private updateInterpolatedEnv;
+}
+export {};

backend/node_modules/@nestjs/config/dist/config.service.js

@@ -0,0 +1,199 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const common_1 = require("@nestjs/common");
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const dotenv = __importStar(require("dotenv"));
+const fs_1 = __importDefault(require("fs"));
+const get_1 = __importDefault(require("lodash/get"));
+const has_1 = __importDefault(require("lodash/has"));
+const set_1 = __importDefault(require("lodash/set"));
+const rxjs_1 = require("rxjs");
+const config_constants_1 = require("./config.constants");
+/**
+ * @publicApi
+ */
+let ConfigService = class ConfigService {
+    set isCacheEnabled(value) {
+        this._isCacheEnabled = value;
+    }
+    get isCacheEnabled() {
+        return this._isCacheEnabled;
+    }
+    constructor(internalConfig = {}) {
+        this.internalConfig = internalConfig;
+        this.cache = {};
+        this._changes$ = new rxjs_1.Subject();
+        this._isCacheEnabled = false;
+        this.envFilePaths = [];
+    }
+    /**
+     * Returns a stream of configuration changes.
+     * Each event contains the attribute path, the old value and the new value.
+     */
+    get changes$() {
+        return this._changes$.asObservable();
+    }
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * It returns a default value if the key does not exist.
+     * @param propertyPath
+     * @param defaultValueOrOptions
+     */
+    get(propertyPath, defaultValueOrOptions, options) {
+        const validatedEnvValue = this.getFromValidatedEnv(propertyPath);
+        if (!(0, shared_utils_1.isUndefined)(validatedEnvValue)) {
+            return validatedEnvValue;
+        }
+        const defaultValue = this.isGetOptionsObject(defaultValueOrOptions) &&
+            !options
+            ? undefined
+            : defaultValueOrOptions;
+        const processEnvValue = this.getFromProcessEnv(propertyPath, defaultValue);
+        if (!(0, shared_utils_1.isUndefined)(processEnvValue)) {
+            return processEnvValue;
+        }
+        const internalValue = this.getFromInternalConfig(propertyPath);
+        if (!(0, shared_utils_1.isUndefined)(internalValue)) {
+            return internalValue;
+        }
+        return defaultValue;
+    }
+    /**
+     * Get a configuration value (either custom configuration or process environment variable)
+     * based on property path (you can use dot notation to traverse nested object, e.g. "database.host").
+     * It returns a default value if the key does not exist.
+     * If the default value is undefined an exception will be thrown.
+     * @param propertyPath
+     * @param defaultValueOrOptions
+     */
+    getOrThrow(propertyPath, defaultValueOrOptions, options) {
+        // @ts-expect-error Bypass method overloads
+        const value = this.get(propertyPath, defaultValueOrOptions, options);
+        if ((0, shared_utils_1.isUndefined)(value)) {
+            throw new TypeError(`Configuration key "${propertyPath.toString()}" does not exist`);
+        }
+        return value;
+    }
+    /**
+     * Sets a configuration value based on property path.
+     * @param propertyPath
+     * @param value
+     */
+    set(propertyPath, value) {
+        const oldValue = this.get(propertyPath);
+        (0, set_1.default)(this.internalConfig, propertyPath, value);
+        if (typeof propertyPath === 'string') {
+            process.env[propertyPath] = String(value);
+            this.updateInterpolatedEnv(propertyPath, String(value));
+        }
+        if (this.isCacheEnabled) {
+            this.setInCacheIfDefined(propertyPath, value);
+        }
+        this._changes$.next({
+            path: propertyPath,
+            oldValue,
+            newValue: value,
+        });
+    }
+    /**
+     * Sets env file paths from `config.module.ts` to parse.
+     * @param paths
+     */
+    setEnvFilePaths(paths) {
+        this.envFilePaths = paths;
+    }
+    getFromCache(propertyPath, defaultValue) {
+        const cachedValue = (0, get_1.default)(this.cache, propertyPath);
+        return (0, shared_utils_1.isUndefined)(cachedValue)
+            ? defaultValue
+            : cachedValue;
+    }
+    getFromValidatedEnv(propertyPath) {
+        const validatedEnvValue = (0, get_1.default)(this.internalConfig[config_constants_1.VALIDATED_ENV_PROPNAME], propertyPath);
+        return validatedEnvValue;
+    }
+    getFromProcessEnv(propertyPath, defaultValue) {
+        if (this.isCacheEnabled &&
+            (0, has_1.default)(this.cache, propertyPath)) {
+            const cachedValue = this.getFromCache(propertyPath, defaultValue);
+            return !(0, shared_utils_1.isUndefined)(cachedValue) ? cachedValue : defaultValue;
+        }
+        const processValue = (0, get_1.default)(process.env, propertyPath);
+        this.setInCacheIfDefined(propertyPath, processValue);
+        return processValue;
+    }
+    getFromInternalConfig(propertyPath) {
+        const internalValue = (0, get_1.default)(this.internalConfig, propertyPath);
+        return internalValue;
+    }
+    setInCacheIfDefined(propertyPath, value) {
+        if (typeof value === 'undefined') {
+            return;
+        }
+        (0, set_1.default)(this.cache, propertyPath, value);
+    }
+    isGetOptionsObject(options) {
+        return options && options?.infer && Object.keys(options).length === 1;
+    }
+    updateInterpolatedEnv(propertyPath, value) {
+        let config = {};
+        for (const envFilePath of this.envFilePaths) {
+            if (fs_1.default.existsSync(envFilePath)) {
+                config = Object.assign(dotenv.parse(fs_1.default.readFileSync(envFilePath)), config);
+            }
+        }
+        const regex = new RegExp(`\\$\\{?${propertyPath}\\}?`, 'g');
+        for (const [k, v] of Object.entries(config)) {
+            if (regex.test(v)) {
+                process.env[k] = v.replace(regex, value);
+            }
+        }
+    }
+};
+exports.ConfigService = ConfigService;
+exports.ConfigService = ConfigService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(config_constants_1.CONFIGURATION_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], ConfigService);

backend/node_modules/@nestjs/config/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './conditional.module';
+export * from './config.module';
+export * from './config.service';
+export * from './types';
+export * from './utils';
+export * from './interfaces';

backend/node_modules/@nestjs/config/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./conditional.module"), exports);
+__exportStar(require("./config.module"), exports);
+__exportStar(require("./config.service"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./interfaces"), exports);

backend/node_modules/@nestjs/config/dist/interfaces/config-change-event.interface.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents a change in the configuration object.
+ * Dispatched when one updates the configuration object through the `ConfigService#set` method.
+ * @publicApi
+ */
+export interface ConfigChangeEvent<OldValue = any, NewValue = any> {
+    path: string;
+    oldValue: OldValue;
+    newValue: NewValue;
+}

backend/node_modules/@nestjs/config/dist/interfaces/config-change-event.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/config/dist/interfaces/config-factory.interface.d.ts

@@ -0,0 +1,4 @@
+import { ConfigObject } from '../types';
+type ConfigFactoryReturnValue<T extends ConfigObject> = T | Promise<T>;
+export type ConfigFactory<T extends ConfigObject = ConfigObject> = () => ConfigFactoryReturnValue<T>;
+export {};

backend/node_modules/@nestjs/config/dist/interfaces/config-factory.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/config/dist/interfaces/config-module-options.interface.d.ts

@@ -0,0 +1,59 @@
+import { DotenvExpandOptions } from 'dotenv-expand';
+import { ConfigFactory } from './config-factory.interface';
+/**
+ * @publicApi
+ */
+export interface ConfigModuleOptions {
+    /**
+     * If "true", values from the process.env object will be cached in the memory.
+     * This improves the overall application performance.
+     * See: https://github.com/nodejs/node/issues/3104
+     */
+    cache?: boolean;
+    /**
+     * If "true", registers `ConfigModule` as a global module.
+     * See: https://docs.nestjs.com/modules#global-modules
+     */
+    isGlobal?: boolean;
+    /**
+     * If "true", environment files (`.env`) will be ignored.
+     */
+    ignoreEnvFile?: boolean;
+    /**
+     * If "true", predefined environment variables will not be validated.
+     */
+    ignoreEnvVars?: boolean;
+    /**
+     * Path to the environment file(s) to be loaded.
+     */
+    envFilePath?: string | string[];
+    /**
+     * Custom function to validate environment variables. It takes an object containing environment
+     * variables as input and outputs validated environment variables.
+     * If exception is thrown in the function it would prevent the application from bootstrapping.
+     * Also, environment variables can be edited through this function, changes
+     * will be reflected in the process.env object.
+     */
+    validate?: (config: Record<string, any>) => Record<string, any>;
+    /**
+     * Environment variables validation schema (Joi).
+     */
+    validationSchema?: any;
+    /**
+     * Schema validation options.
+     * See: https://joi.dev/api/?v=17.3.0#anyvalidatevalue-options
+     */
+    validationOptions?: Record<string, any>;
+    /**
+     * Array of custom configuration files to be loaded.
+     * See: https://docs.nestjs.com/techniques/configuration
+     */
+    load?: Array<ConfigFactory | Promise<ConfigFactory>>;
+    /**
+     * A boolean value indicating the use of expanded variables, or object
+     * containing options to pass to dotenv-expand.
+     * If .env contains expanded variables, they'll only be parsed if
+     * this property is set to true.
+     */
+    expandVariables?: boolean | DotenvExpandOptions;
+}

backend/node_modules/@nestjs/config/dist/interfaces/config-module-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/config/dist/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config-change-event.interface';
+export * from './config-factory.interface';
+export * from './config-module-options.interface';

backend/node_modules/@nestjs/config/dist/interfaces/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config-change-event.interface"), exports);
+__exportStar(require("./config-factory.interface"), exports);
+__exportStar(require("./config-module-options.interface"), exports);

backend/node_modules/@nestjs/config/dist/types/config-object.type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @publicApi
+ */
+export type ConfigObject = Record<string, any>;

backend/node_modules/@nestjs/config/dist/types/config-object.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/config/dist/types/config.type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @publicApi
+ */
+export type ConfigType<T extends (...args: any) => any> = T extends (...args: any) => infer ReturnVal ? ReturnVal extends Promise<infer AsyncReturnVal> ? AsyncReturnVal : ReturnVal : any;

backend/node_modules/@nestjs/config/dist/types/config.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/config/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './config-object.type';
+export * from './config.type';
+export * from './no-infer.type';
+export * from './path-value.type';

backend/node_modules/@nestjs/config/dist/types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config-object.type"), exports);
+__exportStar(require("./config.type"), exports);
+__exportStar(require("./no-infer.type"), exports);
+__exportStar(require("./path-value.type"), exports);

backend/node_modules/@nestjs/config/dist/types/no-infer.type.d.ts

@@ -0,0 +1 @@
+export type NoInferType<T> = [T][T extends any ? 0 : never];

backend/node_modules/@nestjs/config/dist/types/no-infer.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/config/dist/types/path-value.type.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Evaluates to `true` if `T` is `any`. `false` otherwise.
+ * (c) https://stackoverflow.com/a/68633327/5290447
+ */
+type IsAny<T> = unknown extends T ? [keyof T] extends [never] ? false : true : false;
+export type PathImpl<T, Key extends keyof T> = Key extends string ? IsAny<T[Key]> extends true ? never : T[Key] extends Record<string, any> ? `${Key}.${PathImpl<T[Key], Exclude<keyof T[Key], keyof any[]>> & string}` | `${Key}.${Exclude<keyof T[Key], keyof any[]> & string}` : never : never;
+export type PathImpl2<T> = PathImpl<T, keyof T> | keyof T;
+export type Path<T> = keyof T extends string ? PathImpl2<T> extends infer P ? P extends string | keyof T ? P : keyof T : keyof T : never;
+export type PathValue<T, P extends Path<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends Path<T[Key]> ? PathValue<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+export {};

backend/node_modules/@nestjs/config/dist/types/path-value.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/config/dist/utils/create-config-factory.util.d.ts

@@ -0,0 +1,7 @@
+import { FactoryProvider } from '@nestjs/common/interfaces';
+import { ConfigFactory } from '../interfaces';
+import { ConfigFactoryKeyHost } from './register-as.util';
+/**
+ * @publicApi
+ */
+export declare function createConfigProvider(factory: ConfigFactory & ConfigFactoryKeyHost): FactoryProvider;

backend/node_modules/@nestjs/config/dist/utils/create-config-factory.util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigProvider = createConfigProvider;
+const get_config_token_util_1 = require("./get-config-token.util");
+const crypto_1 = require("crypto");
+/**
+ * @publicApi
+ */
+function createConfigProvider(factory) {
+    return {
+        provide: factory.KEY || (0, get_config_token_util_1.getConfigToken)((0, crypto_1.randomUUID)()),
+        useFactory: factory,
+        inject: [],
+    };
+}

backend/node_modules/@nestjs/config/dist/utils/get-config-token.util.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @publicApi
+ */
+export declare function getConfigToken(token: string): string;

backend/node_modules/@nestjs/config/dist/utils/get-config-token.util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigToken = getConfigToken;
+/**
+ * @publicApi
+ */
+function getConfigToken(token) {
+    return `CONFIGURATION(${token})`;
+}

backend/node_modules/@nestjs/config/dist/utils/get-registration-token.util.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @publicApi
+ */
+export declare function getRegistrationToken(config: Record<string, any>): any;

backend/node_modules/@nestjs/config/dist/utils/get-registration-token.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRegistrationToken = getRegistrationToken;
+const config_constants_1 = require("../config.constants");
+/**
+ * @publicApi
+ */
+function getRegistrationToken(config) {
+    return config[config_constants_1.PARTIAL_CONFIGURATION_KEY];
+}

backend/node_modules/@nestjs/config/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './register-as.util';
+export * from './get-config-token.util';

backend/node_modules/@nestjs/config/dist/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./register-as.util"), exports);
+__exportStar(require("./get-config-token.util"), exports);

backend/node_modules/@nestjs/config/dist/utils/merge-configs.util.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @publicApi
+ */
+export declare function mergeConfigObject(host: Record<string, any>, partial: Record<string, any>, token?: string): Record<string, any> | undefined;

backend/node_modules/@nestjs/config/dist/utils/merge-configs.util.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeConfigObject = mergeConfigObject;
+const set_1 = __importDefault(require("lodash/set"));
+/**
+ * @publicApi
+ */
+function mergeConfigObject(host, partial, token) {
+    if (token) {
+        (0, set_1.default)(host, token, partial);
+        return partial;
+    }
+    Object.assign(host, partial);
+}

backend/node_modules/@nestjs/config/dist/utils/register-as.util.d.ts

@@ -0,0 +1,20 @@
+import { ConfigModule } from '..';
+import { ConfigFactory } from '../interfaces';
+import { ConfigObject } from '../types';
+/**
+ * @publicApi
+ */
+export interface ConfigFactoryKeyHost<T = unknown> {
+    KEY: string;
+    asProvider(): {
+        imports: [ReturnType<typeof ConfigModule.forFeature>];
+        useFactory: (config: T) => T;
+        inject: [string];
+    };
+}
+/**
+ * @publicApi
+ *
+ * Registers the configuration object behind a specified token.
+ */
+export declare function registerAs<TConfig extends ConfigObject, TFactory extends ConfigFactory = ConfigFactory<TConfig>>(token: string, configFactory: TFactory): TFactory & ConfigFactoryKeyHost<ReturnType<TFactory>>;

backend/node_modules/@nestjs/config/dist/utils/register-as.util.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAs = registerAs;
+const __1 = require("..");
+const config_constants_1 = require("../config.constants");
+const get_config_token_util_1 = require("./get-config-token.util");
+/**
+ * @publicApi
+ *
+ * Registers the configuration object behind a specified token.
+ */
+function registerAs(token, configFactory) {
+    const defineProperty = (key, value) => {
+        Object.defineProperty(configFactory, key, {
+            configurable: false,
+            enumerable: false,
+            value,
+            writable: false,
+        });
+    };
+    defineProperty(config_constants_1.PARTIAL_CONFIGURATION_KEY, token);
+    defineProperty(config_constants_1.PARTIAL_CONFIGURATION_PROPNAME, (0, get_config_token_util_1.getConfigToken)(token));
+    defineProperty(config_constants_1.AS_PROVIDER_METHOD_KEY, () => ({
+        imports: [__1.ConfigModule.forFeature(configFactory)],
+        useFactory: (config) => config,
+        inject: [(0, get_config_token_util_1.getConfigToken)(token)],
+    }));
+    return configFactory;
+}

backend/node_modules/@nestjs/config/index.d.ts

@@ -0,0 +1 @@
+export * from './dist';

backend/node_modules/@nestjs/config/index.js

@@ -0,0 +1,6 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+exports.__esModule = true;
+__export(require("./dist"));

backend/node_modules/@nestjs/config/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@nestjs/config",
+  "version": "3.3.0",
+  "description": "Nest - modern, fast, powerful node.js web framework (@config)",
+  "author": "Kamil Mysliwiec",
+  "license": "MIT",
+  "url": "https://github.com/nestjs/config#readme",
+  "scripts": {
+    "build": "rimraf -rf dist && tsc -p tsconfig.json",
+    "format": "prettier --write \"{lib,test}/**/*.ts\"",
+    "lint": "eslint 'lib/**/*.ts' --fix",
+    "prepublish:npm": "npm run build",
+    "publish:npm": "npm publish --access public",
+    "prepublish:next": "npm run build",
+    "publish:next": "npm publish --access public --tag next",
+    "test:integration": "jest --config ./tests/jest-e2e.json --runInBand",
+    "prerelease": "npm run build",
+    "release": "release-it"
+  },
+  "dependencies": {
+    "dotenv": "16.4.5",
+    "dotenv-expand": "10.0.0",
+    "lodash": "4.17.21"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "19.5.0",
+    "@commitlint/config-angular": "19.5.0",
+    "@nestjs/common": "10.4.5",
+    "@nestjs/core": "10.4.5",
+    "@nestjs/platform-express": "10.4.5",
+    "@nestjs/testing": "10.4.5",
+    "@types/jest": "29.5.13",
+    "@types/lodash": "4.17.12",
+    "@types/node": "20.16.13",
+    "@typescript-eslint/eslint-plugin": "8.10.0",
+    "@typescript-eslint/parser": "8.10.0",
+    "eslint": "9.13.0",
+    "eslint-config-prettier": "9.1.0",
+    "eslint-plugin-import": "2.31.0",
+    "husky": "9.1.6",
+    "jest": "29.7.0",
+    "joi": "17.13.3",
+    "lint-staged": "15.2.10",
+    "prettier": "3.3.3",
+    "reflect-metadata": "0.2.2",
+    "release-it": "17.10.0",
+    "rimraf": "6.0.1",
+    "rxjs": "7.8.1",
+    "ts-jest": "29.2.5",
+    "typescript": "5.6.3"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^8.0.0 || ^9.0.0 || ^10.0.0",
+    "rxjs": "^7.1.0"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -c .commitlintrc.json -E HUSKY_GIT_PARAMS",
+      "pre-commit": "lint-staged"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nestjs/config"
+  }
+}