Initial commit - Event Planner application

node_modules/@nestjs/serve-static/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './interfaces/serve-static-options.interface';
+export * from './loaders/abstract.loader';
+export * from './loaders/express.loader';
+export * from './loaders/fastify.loader';
+export * from './loaders/noop.loader';
+export * from './serve-static.constants';
+export * from './serve-static.module';
+export * from './serve-static.providers';

node_modules/@nestjs/serve-static/dist/index.js

@@ -0,0 +1,24 @@
+"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("./interfaces/serve-static-options.interface"), exports);
+__exportStar(require("./loaders/abstract.loader"), exports);
+__exportStar(require("./loaders/express.loader"), exports);
+__exportStar(require("./loaders/fastify.loader"), exports);
+__exportStar(require("./loaders/noop.loader"), exports);
+__exportStar(require("./serve-static.constants"), exports);
+__exportStar(require("./serve-static.module"), exports);
+__exportStar(require("./serve-static.providers"), exports);

node_modules/@nestjs/serve-static/dist/interfaces/serve-static-options.interface.d.ts

@@ -0,0 +1,36 @@
+import { Provider, Type } from '@nestjs/common';
+import { ModuleMetadata } from '@nestjs/common/interfaces';
+export interface ServeStaticModuleOptions {
+    rootPath?: string;
+    renderPath?: string | RegExp;
+    useGlobalPrefix?: boolean;
+    serveRoot?: string;
+    exclude?: string[];
+    serveStaticOptions?: {
+        acceptRanges?: boolean;
+        cacheControl?: boolean;
+        dotfiles?: string;
+        etag?: boolean;
+        fallthrough?: boolean;
+        extensions?: string[];
+        immutable?: boolean;
+        index?: boolean | string | string[];
+        lastModified?: boolean;
+        maxAge?: number | string;
+        redirect?: boolean;
+        setHeaders?: (res: any, path: string, stat: any) => any;
+        preCompressed?: boolean;
+        decorateReply?: boolean;
+    };
+}
+export interface ServeStaticModuleOptionsFactory {
+    createLoggerOptions(): Promise<ServeStaticModuleOptions[]> | ServeStaticModuleOptions[];
+}
+export interface ServeStaticModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    isGlobal?: boolean;
+    useExisting?: Type<ServeStaticModuleOptionsFactory>;
+    useClass?: Type<ServeStaticModuleOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<ServeStaticModuleOptions[]> | ServeStaticModuleOptions[];
+    inject?: any[];
+    extraProviders?: Provider[];
+}

node_modules/@nestjs/serve-static/dist/interfaces/serve-static-options.interface.js

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

node_modules/@nestjs/serve-static/dist/loaders/abstract.loader.d.ts

@@ -0,0 +1,6 @@
+import { AbstractHttpAdapter, ApplicationConfig } from '@nestjs/core';
+import { ServeStaticModuleOptions } from '../interfaces/serve-static-options.interface';
+export declare abstract class AbstractLoader {
+    abstract register(httpAdapter: AbstractHttpAdapter, config: ApplicationConfig, options: ServeStaticModuleOptions[]): any;
+    getIndexFilePath(clientPath: string): string;
+}

node_modules/@nestjs/serve-static/dist/loaders/abstract.loader.js

@@ -0,0 +1,20 @@
+"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.AbstractLoader = void 0;
+const common_1 = require("@nestjs/common");
+const path_1 = require("path");
+let AbstractLoader = class AbstractLoader {
+    getIndexFilePath(clientPath) {
+        return (0, path_1.join)(clientPath, 'index.html');
+    }
+};
+exports.AbstractLoader = AbstractLoader;
+exports.AbstractLoader = AbstractLoader = __decorate([
+    (0, common_1.Injectable)()
+], AbstractLoader);

node_modules/@nestjs/serve-static/dist/loaders/express.loader.d.ts

@@ -0,0 +1,6 @@
+import { AbstractHttpAdapter, ApplicationConfig } from '@nestjs/core';
+import { ServeStaticModuleOptions } from '../interfaces/serve-static-options.interface';
+import { AbstractLoader } from './abstract.loader';
+export declare class ExpressLoader extends AbstractLoader {
+    register(httpAdapter: AbstractHttpAdapter, config: ApplicationConfig, optionsArr: ServeStaticModuleOptions[]): void;
+}

node_modules/@nestjs/serve-static/dist/loaders/express.loader.js

@@ -0,0 +1,118 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressLoader = void 0;
+const common_1 = require("@nestjs/common");
+const load_package_util_1 = require("@nestjs/common/utils/load-package.util");
+const fs = __importStar(require("fs"));
+const serve_static_constants_1 = require("../serve-static.constants");
+const is_route_excluded_util_1 = require("../utils/is-route-excluded.util");
+const validate_global_prefix_util_1 = require("../utils/validate-global-prefix.util");
+const validate_path_util_1 = require("../utils/validate-path.util");
+const abstract_loader_1 = require("./abstract.loader");
+let ExpressLoader = class ExpressLoader extends abstract_loader_1.AbstractLoader {
+    register(httpAdapter, config, optionsArr) {
+        const app = httpAdapter.getInstance();
+        const globalPrefix = config.getGlobalPrefix();
+        const express = (0, load_package_util_1.loadPackage)('express', 'ServeStaticModule', () => require('express'));
+        optionsArr.forEach((options) => {
+            options.renderPath = options.renderPath ?? serve_static_constants_1.DEFAULT_EXPRESS_RENDER_PATH;
+            const clientPath = options.rootPath ?? serve_static_constants_1.DEFAULT_ROOT_PATH;
+            const indexFilePath = this.getIndexFilePath(clientPath);
+            const renderFn = (req, res, next) => {
+                if (!(0, is_route_excluded_util_1.isRouteExcluded)(req, options.exclude)) {
+                    if (options.serveStaticOptions?.setHeaders) {
+                        const stat = fs.statSync(indexFilePath);
+                        options.serveStaticOptions.setHeaders(res, indexFilePath, stat);
+                    }
+                    res.sendFile(indexFilePath, null, (err) => {
+                        if (err) {
+                            const error = new common_1.NotFoundException(err.message);
+                            res.status(error.getStatus()).send(error.getResponse());
+                        }
+                    });
+                }
+                else {
+                    next();
+                }
+            };
+            if (globalPrefix &&
+                options.useGlobalPrefix &&
+                (0, validate_global_prefix_util_1.validateGlobalPrefix)(globalPrefix)) {
+                options.serveRoot = `/${globalPrefix}${options.serveRoot || ''}`;
+            }
+            if (options.serveRoot) {
+                app.use(options.serveRoot, express.static(clientPath, options.serveStaticOptions));
+                const renderPath = typeof options.serveRoot === 'string'
+                    ? options.serveRoot + (0, validate_path_util_1.validatePath)(options.renderPath)
+                    : options.serveRoot;
+                app.get(renderPath, renderFn);
+            }
+            else {
+                app.use(express.static(clientPath, options.serveStaticOptions));
+                app.get(options.renderPath, renderFn);
+            }
+            app.use((err, req, _res, next) => {
+                if ((0, is_route_excluded_util_1.isRouteExcluded)(req, options.exclude)) {
+                    const method = httpAdapter.getRequestMethod(req);
+                    const url = httpAdapter.getRequestUrl(req);
+                    return next(new common_1.NotFoundException(`Cannot ${method} ${url}`));
+                }
+                if (err instanceof common_1.HttpException) {
+                    throw err;
+                }
+                else if (err?.message?.includes('ENOENT')) {
+                    throw new common_1.NotFoundException(err.message);
+                }
+                else if (err?.code === 'ENOENT') {
+                    throw new common_1.NotFoundException(`ENOENT: ${err.message}`);
+                }
+                else {
+                    next(err);
+                }
+            });
+        });
+    }
+};
+exports.ExpressLoader = ExpressLoader;
+exports.ExpressLoader = ExpressLoader = __decorate([
+    (0, common_1.Injectable)()
+], ExpressLoader);

node_modules/@nestjs/serve-static/dist/loaders/fastify.loader.d.ts

@@ -0,0 +1,6 @@
+import { AbstractHttpAdapter, ApplicationConfig } from '@nestjs/core';
+import { ServeStaticModuleOptions } from '../interfaces/serve-static-options.interface';
+import { AbstractLoader } from './abstract.loader';
+export declare class FastifyLoader extends AbstractLoader {
+    register(httpAdapter: AbstractHttpAdapter, config: ApplicationConfig, optionsArr: ServeStaticModuleOptions[]): void;
+}

node_modules/@nestjs/serve-static/dist/loaders/fastify.loader.js

@@ -0,0 +1,109 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyLoader = void 0;
+const common_1 = require("@nestjs/common");
+const load_package_util_1 = require("@nestjs/common/utils/load-package.util");
+const fs = __importStar(require("fs"));
+const serve_static_constants_1 = require("../serve-static.constants");
+const validate_global_prefix_util_1 = require("../utils/validate-global-prefix.util");
+const validate_path_util_1 = require("../utils/validate-path.util");
+const abstract_loader_1 = require("./abstract.loader");
+let FastifyLoader = class FastifyLoader extends abstract_loader_1.AbstractLoader {
+    register(httpAdapter, config, optionsArr) {
+        const app = httpAdapter.getInstance();
+        const globalPrefix = config.getGlobalPrefix();
+        const fastifyStatic = (0, load_package_util_1.loadPackage)('@fastify/static', 'ServeStaticModule', () => require('@fastify/static'));
+        optionsArr.forEach((options) => {
+            options.renderPath = options.renderPath ?? serve_static_constants_1.DEFAULT_FASTIFY_RENDER_PATH;
+            const clientPath = options.rootPath ?? serve_static_constants_1.DEFAULT_ROOT_PATH;
+            const indexFilePath = this.getIndexFilePath(clientPath);
+            if (globalPrefix &&
+                options.useGlobalPrefix &&
+                (0, validate_global_prefix_util_1.validateGlobalPrefix)(globalPrefix)) {
+                options.serveRoot = `/${globalPrefix}${options.serveRoot || ''}`;
+            }
+            const renderFn = (req, res) => {
+                if (!options.serveStaticOptions?.fallthrough) {
+                    const error = new common_1.NotFoundException();
+                    res.status(error.getStatus()).send(error.getResponse());
+                    return;
+                }
+                fs.stat(indexFilePath, (err, stat) => {
+                    if (err) {
+                        const error = new common_1.NotFoundException();
+                        res.status(error.getStatus()).send(error.getResponse());
+                        return;
+                    }
+                    const stream = fs.createReadStream(indexFilePath);
+                    if (options.serveStaticOptions?.setHeaders) {
+                        options.serveStaticOptions.setHeaders(res, indexFilePath, stat);
+                    }
+                    res.type('text/html').send(stream);
+                });
+            };
+            if (options.serveRoot) {
+                app.register(fastifyStatic, {
+                    root: clientPath,
+                    ...(options.serveStaticOptions || {}),
+                    wildcard: false,
+                    prefix: options.serveRoot
+                });
+                const renderPath = typeof options.serveRoot === 'string'
+                    ? options.serveRoot + (0, validate_path_util_1.validatePath)(options.renderPath)
+                    : options.serveRoot;
+                app.get(renderPath, renderFn);
+            }
+            else {
+                app.register(fastifyStatic, {
+                    root: clientPath,
+                    ...(options.serveStaticOptions || {}),
+                    wildcard: false
+                });
+                app.get(options.renderPath, renderFn);
+            }
+        });
+    }
+};
+exports.FastifyLoader = FastifyLoader;
+exports.FastifyLoader = FastifyLoader = __decorate([
+    (0, common_1.Injectable)()
+], FastifyLoader);

node_modules/@nestjs/serve-static/dist/loaders/noop.loader.d.ts

@@ -0,0 +1,6 @@
+import { AbstractHttpAdapter, ApplicationConfig } from '@nestjs/core';
+import { ServeStaticModuleOptions } from '../interfaces/serve-static-options.interface';
+import { AbstractLoader } from './abstract.loader';
+export declare class NoopLoader extends AbstractLoader {
+    register(httpAdapter: AbstractHttpAdapter, config: ApplicationConfig, options: ServeStaticModuleOptions[]): void;
+}

node_modules/@nestjs/serve-static/dist/loaders/noop.loader.js

@@ -0,0 +1,18 @@
+"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.NoopLoader = void 0;
+const common_1 = require("@nestjs/common");
+const abstract_loader_1 = require("./abstract.loader");
+let NoopLoader = class NoopLoader extends abstract_loader_1.AbstractLoader {
+    register(httpAdapter, config, options) { }
+};
+exports.NoopLoader = NoopLoader;
+exports.NoopLoader = NoopLoader = __decorate([
+    (0, common_1.Injectable)()
+], NoopLoader);

node_modules/@nestjs/serve-static/dist/serve-static.constants.d.ts

@@ -0,0 +1,4 @@
+export declare const SERVE_STATIC_MODULE_OPTIONS = "SERVE_STATIC_MODULE_OPTIONS";
+export declare const DEFAULT_ROOT_PATH = "client";
+export declare const DEFAULT_EXPRESS_RENDER_PATH = "{*any}";
+export declare const DEFAULT_FASTIFY_RENDER_PATH = "*";

node_modules/@nestjs/serve-static/dist/serve-static.constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FASTIFY_RENDER_PATH = exports.DEFAULT_EXPRESS_RENDER_PATH = exports.DEFAULT_ROOT_PATH = exports.SERVE_STATIC_MODULE_OPTIONS = void 0;
+exports.SERVE_STATIC_MODULE_OPTIONS = 'SERVE_STATIC_MODULE_OPTIONS';
+exports.DEFAULT_ROOT_PATH = 'client';
+exports.DEFAULT_EXPRESS_RENDER_PATH = '{*any}';
+exports.DEFAULT_FASTIFY_RENDER_PATH = '*';

node_modules/@nestjs/serve-static/dist/serve-static.module.d.ts

@@ -0,0 +1,16 @@
+import { DynamicModule, OnModuleInit } from '@nestjs/common';
+import { ApplicationConfig, HttpAdapterHost } from '@nestjs/core';
+import { ServeStaticModuleAsyncOptions, ServeStaticModuleOptions } from './interfaces/serve-static-options.interface';
+import { AbstractLoader } from './loaders/abstract.loader';
+export declare class ServeStaticModule implements OnModuleInit {
+    private readonly moduleOptions;
+    private readonly loader;
+    private readonly config;
+    private readonly httpAdapterHost;
+    constructor(moduleOptions: ServeStaticModuleOptions[], loader: AbstractLoader, config: ApplicationConfig, httpAdapterHost: HttpAdapterHost);
+    static forRoot(...options: ServeStaticModuleOptions[]): DynamicModule;
+    static forRootAsync(options: ServeStaticModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+    onModuleInit(): void;
+}

node_modules/@nestjs/serve-static/dist/serve-static.module.js

@@ -0,0 +1,91 @@
+"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;
+};
+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 ServeStaticModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServeStaticModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const abstract_loader_1 = require("./loaders/abstract.loader");
+const serve_static_constants_1 = require("./serve-static.constants");
+const serve_static_providers_1 = require("./serve-static.providers");
+let ServeStaticModule = ServeStaticModule_1 = class ServeStaticModule {
+    constructor(moduleOptions, loader, config, httpAdapterHost) {
+        this.moduleOptions = moduleOptions;
+        this.loader = loader;
+        this.config = config;
+        this.httpAdapterHost = httpAdapterHost;
+    }
+    static forRoot(...options) {
+        return {
+            module: ServeStaticModule_1,
+            providers: [
+                {
+                    provide: serve_static_constants_1.SERVE_STATIC_MODULE_OPTIONS,
+                    useValue: options
+                }
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: ServeStaticModule_1,
+            imports: options.imports,
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...(options.extraProviders || [])
+            ],
+            exports: [serve_static_constants_1.SERVE_STATIC_MODULE_OPTIONS]
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass
+            }
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: serve_static_constants_1.SERVE_STATIC_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || []
+            };
+        }
+        return {
+            provide: serve_static_constants_1.SERVE_STATIC_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => optionsFactory.createLoggerOptions(),
+            inject: [options.useExisting || options.useClass]
+        };
+    }
+    onModuleInit() {
+        const httpAdapter = this.httpAdapterHost.httpAdapter;
+        this.loader.register(httpAdapter, this.config, this.moduleOptions);
+    }
+};
+exports.ServeStaticModule = ServeStaticModule;
+exports.ServeStaticModule = ServeStaticModule = ServeStaticModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [...serve_static_providers_1.serveStaticProviders]
+    }),
+    __param(0, (0, common_1.Inject)(serve_static_constants_1.SERVE_STATIC_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Array, abstract_loader_1.AbstractLoader,
+        core_1.ApplicationConfig,
+        core_1.HttpAdapterHost])
+], ServeStaticModule);

node_modules/@nestjs/serve-static/dist/serve-static.providers.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '@nestjs/common';
+export declare const serveStaticProviders: Provider[];

node_modules/@nestjs/serve-static/dist/serve-static.providers.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveStaticProviders = void 0;
+const core_1 = require("@nestjs/core");
+const abstract_loader_1 = require("./loaders/abstract.loader");
+const express_loader_1 = require("./loaders/express.loader");
+const fastify_loader_1 = require("./loaders/fastify.loader");
+const noop_loader_1 = require("./loaders/noop.loader");
+exports.serveStaticProviders = [
+    {
+        provide: abstract_loader_1.AbstractLoader,
+        useFactory: (httpAdapterHost) => {
+            if (!httpAdapterHost || !httpAdapterHost.httpAdapter) {
+                return new noop_loader_1.NoopLoader();
+            }
+            const httpAdapter = httpAdapterHost.httpAdapter;
+            if (httpAdapter &&
+                httpAdapter.constructor &&
+                httpAdapter.constructor.name === 'FastifyAdapter') {
+                return new fastify_loader_1.FastifyLoader();
+            }
+            return new express_loader_1.ExpressLoader();
+        },
+        inject: [core_1.HttpAdapterHost]
+    }
+];

node_modules/@nestjs/serve-static/dist/utils/is-route-excluded.util.d.ts

@@ -0,0 +1 @@
+export declare const isRouteExcluded: (req: any, paths?: string[]) => boolean;

node_modules/@nestjs/serve-static/dist/utils/is-route-excluded.util.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRouteExcluded = void 0;
+const path_to_regexp_1 = require("path-to-regexp");
+const isRouteExcluded = (req, paths = []) => {
+    return paths.some((path) => {
+        const { regexp } = (0, path_to_regexp_1.pathToRegexp)(path);
+        const queryParamsIndex = req.originalUrl.indexOf('?');
+        const pathname = queryParamsIndex >= 0
+            ? req.originalUrl.slice(0, queryParamsIndex)
+            : req.originalUrl;
+        if (!regexp.exec(pathname + '/')) {
+            return false;
+        }
+        return true;
+    });
+};
+exports.isRouteExcluded = isRouteExcluded;

node_modules/@nestjs/serve-static/dist/utils/service-static.utils.d.ts

@@ -0,0 +1,5 @@
+export declare function loadPackage<T = any>(
+  packageName: string,
+  context: string,
+  loaderFn?: () => T
+): T;

node_modules/@nestjs/serve-static/dist/utils/service-static.utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("@nestjs/common");
+const MISSING_REQUIRED_DEPENDENCY = (name, reason) => `The "${name}" package is missing. Please, make sure to install this library ($ npm install ${name}) to take advantage of ${reason}.`;
+const logger = new common_1.Logger('PackageLoader');
+function loadPackage(packageName, context, loaderFn) {
+    try {
+        return loaderFn ? loaderFn() : require(packageName);
+    }
+    catch (e) {
+        logger.error(MISSING_REQUIRED_DEPENDENCY(packageName, context));
+        process.exit(1);
+    }
+}
+exports.loadPackage = loadPackage;

node_modules/@nestjs/serve-static/dist/utils/validate-global-prefix.util.d.ts

@@ -0,0 +1 @@
+export declare const validateGlobalPrefix: (globalPrefix: string) => boolean;

node_modules/@nestjs/serve-static/dist/utils/validate-global-prefix.util.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGlobalPrefix = void 0;
+const validateGlobalPrefix = (globalPrefix) => !globalPrefix.match(/^(\/?)$/);
+exports.validateGlobalPrefix = validateGlobalPrefix;

node_modules/@nestjs/serve-static/dist/utils/validate-path.util.d.ts

@@ -0,0 +1 @@
+export declare const validatePath: (path: string) => string;

node_modules/@nestjs/serve-static/dist/utils/validate-path.util.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePath = void 0;
+const validatePath = (path) => path && path.charAt(0) !== '/' ? `/${path}` : path;
+exports.validatePath = validatePath;