@syntay/fastay 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Syntay
+
+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.

package/dist/app.d.ts

@@ -0,0 +1,123 @@
+import express from 'express';
+import { MiddlewareMap } from './middleware.js';
+import type { ServeStaticOptions } from 'serve-static';
+/**
+ * Express configuration options applied automatically by Fastay
+ * before internal middleware and route loading.
+ */
+export interface ExpressOptions {
+    /**
+     * Global middlewares applied to all routes.
+     * Example: [cors(), helmet()]
+     */
+    middlewares?: express.RequestHandler[];
+    /**
+     * Options passed to express.json().
+     * Useful for customizing JSON payload limits or behavior.
+     */
+    jsonOptions?: Parameters<typeof express.json>[0];
+    /**
+     * Options passed to express.urlencoded().
+     * Useful when handling form submissions or URL-encoded bodies.
+     */
+    urlencodedOptions?: Parameters<typeof express.urlencoded>[0];
+    /**
+     * Custom global error handler.
+     * If provided, Fastay will use this instead of the default one.
+     */
+    errorHandler?: express.ErrorRequestHandler;
+    /**
+     * Static file serving configuration.
+     * Example:
+     * {
+     *   path: "public",
+     *   options: { maxAge: "1d" }
+     * }
+     */
+    static?: {
+        path: string;
+        options?: ServeStaticOptions;
+    };
+    /**
+     * View engine configuration for Express.
+     * Example:
+     * {
+     *   engine: "pug",
+     *   dir: "views"
+     * }
+     */
+    views?: {
+        engine: string;
+        dir: string;
+    };
+    /**
+     * Enables or disables Express' "trust proxy" mode.
+     * Typically required when using reverse proxies (Nginx, Cloudflare, etc.).
+     */
+    trustProxy?: boolean;
+    /**
+     * Local variables available to all templates and responses.
+     * Fastay automatically injects them into `response.locals`.
+     */
+    locals?: Record<string, any>;
+}
+/**
+ * Options applied when creating a Fastay.js application.
+ */
+export type CreateAppOptions = {
+    /**
+     * Directory where API route modules are located.
+     * Default: "src/api"
+     */
+    apiDir?: string;
+    /**
+     * Base route where all API routes will be mounted.
+     * Default: "/api"
+     */
+    baseRoute?: string;
+    /**
+     * Port on which `.listen()` will run the server.
+     * Default: 3000
+     */
+    port?: number;
+    /**
+     * Express-level configuration such as middleware, body parsers,
+     * view engine, static assets, error handler, etc.
+     */
+    expressOptions?: ExpressOptions;
+    /**
+     * Internal Fastay middlewares applied after Express initialization
+     * but before route mounting.
+     */
+    middlewares?: MiddlewareMap;
+};
+/**
+ * Bootstraps and configures a Fastay application.
+ *
+ * Fastay automatically:
+ * - Discovers and registers routes defined in `apiDir`.
+ * - Applies both built-in and user-provided middlewares.
+ * - Exposes a health-check endpoint at `/_health`.
+ *
+ * @param opts - Configuration options for the Fastay application.
+ * @returns A Promise that resolves to an Express `Application` instance.
+ *
+ * @example
+ * ```ts
+ * import { createApp } from '@syntay/fastay';
+ * import cors from 'cors';
+ * import helmet from 'helmet';
+ *
+ * void (async () => {
+ *   await createApp({
+ *     apiDir: './src/api',
+ *     baseRoute: '/api',
+ *     port: 5555,
+ *     expressOptions: {
+ *       middlewares: [cors(), helmet()],
+ *     },
+ *   });
+ * })();
+ * ```
+ */
+export declare function createApp(opts?: CreateAppOptions): Promise<import("express-serve-static-core").Express>;

package/dist/app.js

@@ -0,0 +1,106 @@
+import express from 'express';
+import path from 'path';
+import { loadApiRoutes } from './router.js';
+import { loadFastayMiddlewares, createMiddleware, } from './middleware.js';
+import { logger } from './logger.js';
+import { printBanner } from './banner.js';
+/**
+ * Bootstraps and configures a Fastay application.
+ *
+ * Fastay automatically:
+ * - Discovers and registers routes defined in `apiDir`.
+ * - Applies both built-in and user-provided middlewares.
+ * - Exposes a health-check endpoint at `/_health`.
+ *
+ * @param opts - Configuration options for the Fastay application.
+ * @returns A Promise that resolves to an Express `Application` instance.
+ *
+ * @example
+ * ```ts
+ * import { createApp } from '@syntay/fastay';
+ * import cors from 'cors';
+ * import helmet from 'helmet';
+ *
+ * void (async () => {
+ *   await createApp({
+ *     apiDir: './src/api',
+ *     baseRoute: '/api',
+ *     port: 5555,
+ *     expressOptions: {
+ *       middlewares: [cors(), helmet()],
+ *     },
+ *   });
+ * })();
+ * ```
+ */
+export async function createApp(opts) {
+    const start = logger.timeStart();
+    printBanner();
+    // logger.group('Fastay');
+    logger.info('Initializing server...');
+    const apiDir = opts?.apiDir ?? path.resolve(process.cwd(), 'src', 'api');
+    const baseRoute = opts?.baseRoute ?? '/api';
+    logger.success(`API directory: ${apiDir}`);
+    logger.success(`Base route: ${baseRoute}`);
+    const app = express();
+    if (opts?.expressOptions) {
+        for (const [key, value] of Object.entries(opts.expressOptions)) {
+            // Se for array → assume middleware global
+            if (Array.isArray(value)) {
+                value.forEach((mw) => app.use(mw));
+            }
+            // Se o app tiver método com esse nome
+            else if (typeof app[key] === 'function') {
+                // TS-safe
+                app[key](value);
+            }
+            // special cases
+            else if (key === 'static' && value && typeof value === 'object') {
+                const v = value;
+                app.use(express.static(v.path, v.options));
+            }
+            else if (key === 'jsonOptions') {
+                app.use(express.json(value));
+            }
+            else if (key === 'urlencodedOptions') {
+                app.use(express.urlencoded(value));
+            }
+        }
+    }
+    app.use(express.json());
+    const defaltPort = opts?.port ? opts.port : 6000;
+    app.listen(defaltPort, () => {
+        logger.success(`Server running at http://localhost:${defaltPort}${baseRoute}`);
+    });
+    // external middlewares
+    if (opts?.expressOptions?.middlewares) {
+        logger.group('Express Middlewares');
+        for (const mw of opts.expressOptions.middlewares) {
+            logger.gear(`Loaded: ${mw.name || 'anonymous'}`);
+            app.use(mw);
+        }
+    }
+    // Fastay middlewares
+    if (opts?.middlewares) {
+        logger.group('Fastay Middlewares');
+        const apply = createMiddleware(opts.middlewares);
+        apply(app);
+    }
+    // automatic middlewares
+    // logger.group('Fastay Auto-Middlewares');
+    const isMiddleware = await loadFastayMiddlewares(app);
+    // health check
+    app.get('/_health', (_, res) => res.json({ ok: true }));
+    app.use((_req, res, next) => {
+        res.setHeader('X-Powered-By', 'Syntay Engine');
+        next();
+    });
+    // load routes
+    // logger.group('Routes Loaded');
+    const totalRoutes = await loadApiRoutes(app, baseRoute, apiDir);
+    logger.success(`Total routes loaded: ${totalRoutes}`);
+    // app.use(errorHandler);
+    const time = logger.timeEnd(start);
+    logger.success(`Boot completed in ${time}ms`);
+    return app;
+}

package/dist/banner.d.ts

@@ -0,0 +1 @@
+export declare function printBanner(): void;

package/dist/banner.js

@@ -0,0 +1,9 @@
+import { logger } from './logger.js';
+export function printBanner() {
+    const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+    const white = (s) => `\x1b[37m${s}\x1b[0m`;
+    logger.raw('');
+    logger.raw(`${cyan('⥨ Fastay.js')} ${white('1.0.0')}`);
+    logger.raw(`  ${white('- Runtime: Node.js\n')}`);
+    // logger.raw('\n');
+}

package/dist/error-handler.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare function errorHandler(err: any, req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>>;

package/dist/error-handler.js

@@ -0,0 +1,36 @@
+import { logger } from './logger';
+import fs from 'fs';
+export function errorHandler(err, req, res, next) {
+    const isSyntaxError = err.name === 'SyntaxError' || err.message?.includes('Unexpected');
+    const route = `${req.method} ${req.originalUrl}`;
+    // Tenta extrair arquivo, linha e coluna (quando stack estiver presente)
+    let fileInfo = '';
+    if (err.stack) {
+        const stackLine = err.stack.split('\n')[1]; // pega primeira linha depois do erro
+        const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
+        if (match) {
+            const [_, file, line, col] = match;
+            fileInfo = `${file}:${line}:${col}`;
+            // Tenta mostrar o trecho da linha que deu erro
+            if (fs.existsSync(file)) {
+                const codeLines = fs.readFileSync(file, 'utf-8').split('\n');
+                const codeSnippet = codeLines[parseInt(line) - 1].trim();
+                fileInfo += ` → ${codeSnippet}`;
+            }
+        }
+    }
+    logger.group(`✗ Runtime Error in route [${route}]`);
+    logger.error(`${err.name}: ${err.message}`);
+    if (fileInfo)
+        logger.error(`Location: ${fileInfo}`);
+    if (process.env.NODE_ENV === 'production') {
+        return res.status(500).json({
+            error: 'Internal server error',
+        });
+    }
+    return res.status(500).json({
+        error: err.message,
+        stack: err.stack,
+        file: fileInfo || undefined,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createApp } from './app.js';
+export { createMiddleware } from './middleware.js';
+export type { CreateAppOptions } from './app.js';
+export { Request, Response, Next } from './types';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createApp } from './app.js';
+export { createMiddleware } from './middleware.js';

package/dist/logger.d.ts

@@ -0,0 +1,12 @@
+export declare const logger: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    success: (msg: string) => void;
+    gear: (msg: string) => void;
+    space(lines?: number): void;
+    group(title: string): void;
+    raw(msg: string): void;
+    timeStart(): number;
+    timeEnd(start: number): string;
+};

package/dist/logger.js

@@ -0,0 +1,61 @@
+import pino from 'pino';
+import pretty from 'pino-pretty';
+// stream configurado para remover INFO:, timestamps e etc
+const stream = pretty({
+    colorize: true,
+    ignore: 'pid,hostname,time,level',
+    levelFirst: false,
+    // Remove "INFO: " antes da msg
+    messageKey: 'msg',
+    // Maneira correta TS-safe
+    messageFormat: (log, messageKey) => {
+        const msg = log[messageKey];
+        return typeof msg === 'string' ? msg : String(msg);
+    },
+});
+const base = pino({
+    level: 'info',
+    timestamp: false, // remove [HH:mm:ss]
+    base: undefined, // remove pid, hostname
+}, stream);
+// helpers para cores ANSI
+const colors = {
+    white: (s) => `\x1b[37m${s}\x1b[0m`,
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    gray: (s) => `\x1b[90m${s}\x1b[0m`,
+};
+// emojis Fastay
+const ICONS = {
+    info: '○',
+    success: '✓',
+    error: '✗',
+    gear: '⚙️',
+};
+export const logger = {
+    info: (msg) => base.info(` ${colors.white(ICONS.info)} ${colors.white(msg)}`),
+    warn: (msg) => base.info(` ${colors.red('⚠')} ${colors.white(msg)}`),
+    error: (msg) => base.info(` ${colors.red(ICONS.error)} ${colors.white(msg)}`),
+    success: (msg) => base.info(` ${colors.green(ICONS.success)} ${colors.white(msg)}`),
+    gear: (msg) => base.info(` ${ICONS.gear}  ${colors.white(msg)}`),
+    space(lines = 1) {
+        for (let i = 0; i < lines; i++)
+            base.info(' ');
+    },
+    group(title) {
+        this.space();
+        base.info('');
+        base.info(colors.cyan(title));
+        // this.space();
+    },
+    raw(msg) {
+        base.info(msg);
+    },
+    timeStart() {
+        return performance.now();
+    },
+    timeEnd(start) {
+        return (performance.now() - start).toFixed(1);
+    },
+};

package/dist/middleware.d.ts

@@ -0,0 +1,62 @@
+import { Application, Request, Response, NextFunction } from 'express';
+type MiddlewareFn = (req: Request, res: Response, next: NextFunction) => any;
+/**
+ * Defines a map of routes and the middleware functions that Fastay
+ * will automatically load and attach during boot.
+ *
+ * Keys represent route prefixes (e.g. `/auth`, `/admin`), and
+ * values are arrays of Fastay middleware functions.
+ *
+ * Middleware functions use Fastay’s extended `Request`, `Response`,
+ * and `Next` types — not the raw Express versions.
+ *
+ * @example
+ * ```ts
+ * // src/middleware.ts
+ * import { createMiddleware } from '@syntay/fastay';
+ * import { authMiddleware } from './auth';
+ * import { auditLogger } from './audit';
+ *
+ * export const middleware = createMiddleware({
+ *   '/auth': [authMiddleware],
+ *   '/admin': [auditLogger]
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // src/auth.ts
+ * import { Request, Response, Next } from '@syntay/fastay';
+ *
+ * export async function authMiddleware(req: Request, _res: Response, next: Next) {
+ *   // Custom logic using extended Fastay types
+ *   req.user = { id: 1, role: "admin" };
+ *   next();
+ * }
+ * ```
+ */
+export type MiddlewareMap = Record<string, MiddlewareFn[]>;
+/**
+ * Creates a Fastay middleware loader.
+ *
+ * Fastay uses this internally to attach user-defined middleware to the
+ * Express application during boot. The framework automatically discovers
+ * and loads any `middleware` exported from the project's `src/` directory.
+ *
+ * Middleware functions are wrapped so both synchronous and asynchronous
+ * handlers behave consistently.
+ *
+ * @param map - A map of route prefixes and the middleware stack for each route.
+ * @returns A function that Fastay will call to register the mapped middleware.
+ *
+ * @example
+ * ```ts
+ * export const middleware = createMiddleware({
+ *   '/auth': [authMiddleware],
+ *   '/admin': [adminGuard, auditLogger]
+ * });
+ * ```
+ */
+export declare function createMiddleware(map: Record<string, MiddlewareFn[]>): (app: Application) => void;
+export declare function loadFastayMiddlewares(app: Application): Promise<void>;
+export {};

package/dist/middleware.js

@@ -0,0 +1,59 @@
+import path from 'path';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+import { logger } from './logger.js';
+import { wrapMiddleware } from './utils/wrapMiddleware.js';
+/**
+ * Creates a Fastay middleware loader.
+ *
+ * Fastay uses this internally to attach user-defined middleware to the
+ * Express application during boot. The framework automatically discovers
+ * and loads any `middleware` exported from the project's `src/` directory.
+ *
+ * Middleware functions are wrapped so both synchronous and asynchronous
+ * handlers behave consistently.
+ *
+ * @param map - A map of route prefixes and the middleware stack for each route.
+ * @returns A function that Fastay will call to register the mapped middleware.
+ *
+ * @example
+ * ```ts
+ * export const middleware = createMiddleware({
+ *   '/auth': [authMiddleware],
+ *   '/admin': [adminGuard, auditLogger]
+ * });
+ * ```
+ */
+export function createMiddleware(map) {
+    return (app) => {
+        for (const [route, middlewares] of Object.entries(map)) {
+            for (const mw of middlewares) {
+                const wrapped = wrapMiddleware(mw);
+                app.use(route, wrapped);
+            }
+        }
+    };
+}
+export async function loadFastayMiddlewares(app) {
+    const isDev = process.env.NODE_ENV !== 'production';
+    const mwDir = path.resolve(process.cwd(), isDev ? 'src/middlewares' : 'dist/middlewares');
+    const file = path.join(mwDir, isDev ? 'middleware.ts' : 'middleware.js');
+    if (!fs.existsSync(file))
+        return;
+    const mod = await import(pathToFileURL(file).href);
+    if (!mod.middleware)
+        return;
+    logger.group('Fastay Auto-Middlewares');
+    if (typeof mod.middleware === 'function') {
+        mod.middleware(app);
+        logger.info('Loading Fastay core middleware...');
+    }
+    else {
+        const map = mod.middleware;
+        for (const [route, middlewares] of Object.entries(map)) {
+            for (const mw of middlewares) {
+                app.use(route, mw);
+            }
+        }
+    }
+}

package/dist/router.d.ts

@@ -0,0 +1,13 @@
+import { Application } from 'express';
+/**
+ * Converte caminho do arquivo em rota Express (somente arquivos route.ts)
+ */
+export declare function filePathToRoute(apiDir: string, filePath: string, baseRoute: string): string | null;
+/**
+ * Retorna todos arquivos .ts/.js recursivamente
+ */
+export declare function collectFiles(dir: string): string[];
+/**
+ * Carrega todas as rotas do diretório apiDir
+ */
+export declare function loadApiRoutes(app: Application, baseRoute: string, apiDirectory: string): Promise<number>;

package/dist/router.js

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { logger } from './logger.js';
+/**
+ * Converte caminho do arquivo em rota Express (somente arquivos route.ts)
+ */
+export function filePathToRoute(apiDir, filePath, baseRoute) {
+    const rel = path.relative(apiDir, filePath);
+    const parts = rel.split(path.sep);
+    const filename = parts.pop();
+    if (filename !== 'route.ts' && filename !== 'route.js')
+        return null;
+    const segments = parts
+        .map((s) => s.startsWith('[') && s.endsWith(']') ? `:${s.slice(1, -1)}` : s)
+        .filter(Boolean);
+    return `${baseRoute}/${segments.join('/')}`.replace(/\/+/g, '/');
+}
+/**
+ * Retorna todos arquivos .ts/.js recursivamente
+ */
+export function collectFiles(dir) {
+    let out = [];
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    for (const it of items) {
+        const full = path.join(dir, it.name);
+        if (it.isDirectory())
+            out = out.concat(collectFiles(full));
+        else if (/\.(ts|js|mts|mjs)$/.test(it.name))
+            out.push(full);
+    }
+    return out;
+}
+/**
+ * Wrapper para suportar return JSON/string/number e capturar erros runtime
+ */
+function wrapHandler(fn, routePath, filePath) {
+    return async (req, res, next) => {
+        try {
+            const result = fn.length >= 2 ? await fn(req, res) : await fn(req);
+            if (res.headersSent)
+                return;
+            if (result === undefined)
+                return;
+            if (typeof result === 'string')
+                return res.send(result);
+            if (typeof result === 'number')
+                return res.send(String(result));
+            return res.json(result);
+        }
+        catch (err) {
+            const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
+            // logger.error(
+            //   `✗ Runtime Error in route [${req.method} ${routePath}]\n` +
+            //     `  File: ${filePath}\n` +
+            //     `  ${err.name}: ${err.message || 'Unknown error'}\n` +
+            //     `  Stack: ${stack}`
+            // );
+            let fileInfo = '';
+            if (err.stack) {
+                const stackLine = err.stack.split('\n')[1]; // pega primeira linha depois do erro
+                const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
+                if (match) {
+                    const [_, file, line, col] = match;
+                    fileInfo = `${file}:${line}:${col}`;
+                    // Tenta mostrar o trecho da linha que deu erro
+                    if (fs.existsSync(file)) {
+                        const codeLines = fs.readFileSync(file, 'utf-8').split('\n');
+                        const codeSnippet = codeLines[parseInt(line) - 1].trim();
+                        fileInfo += ` → ${codeSnippet}`;
+                    }
+                }
+            }
+            // logger.group(`✗ Runtime Error in route  [${req.method} ${routePath}]`);
+            logger.error(`${err.name}: ${err.message}`);
+            if (fileInfo)
+                logger.error(`Location: ${fileInfo}`);
+            next(err);
+        }
+    };
+}
+/**
+ * Carrega todas as rotas do diretório apiDir
+ */
+export async function loadApiRoutes(app, baseRoute, apiDirectory) {
+    const isDev = process.env.NODE_ENV !== 'production';
+    const apiDir = path.join(process.cwd(), isDev ? apiDirectory : 'dist/api');
+    if (!fs.existsSync(apiDir))
+        return 0;
+    const files = collectFiles(apiDir);
+    let cont = 0;
+    logger.group('Routes Loaded');
+    for (const file of files) {
+        const route = filePathToRoute(apiDir, file, baseRoute);
+        if (!route)
+            continue;
+        try {
+            const fileUrl = pathToFileURL(file).href;
+            const mod = await import(fileUrl);
+            const httpMethods = [
+                'GET',
+                'POST',
+                'PUT',
+                'DELETE',
+                'PATCH',
+                'OPTIONS',
+                'HEAD',
+            ];
+            for (const m of httpMethods) {
+                if (typeof mod[m] === 'function') {
+                    app[m.toLowerCase()](route, wrapHandler(mod[m], route, file));
+                    cont++;
+                    logger.success(`Route: [${m}] ${route}`);
+                }
+            }
+            if (mod.default && typeof mod.default === 'function') {
+                app.get(route, wrapHandler(mod.default, route, file));
+                cont++;
+                logger.success(`Route: [GET] ${route}`);
+            }
+        }
+        catch (err) {
+            const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
+            // logger.error(
+            //   `✗ Boot Error importing ${file}\n` +
+            //     `  Message: ${err.message || 'Unknown error'}\n` +
+            //     `  Stack: ${stack}`
+            // );
+            let fileInfo = '';
+            if (err.stack) {
+                const stackLine = err.stack.split('\n')[1]; // pega primeira linha depois do erro
+                const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
+                if (match) {
+                    const [_, file, line, col] = match;
+                    fileInfo = `${file}:${line}:${col}`;
+                    // Tenta mostrar o trecho da linha que deu erro
+                    if (fs.existsSync(file)) {
+                        const codeLines = fs.readFileSync(file, 'utf-8').split('\n');
+                        const codeSnippet = codeLines[parseInt(line) - 1].trim();
+                        fileInfo += ` → ${codeSnippet}`;
+                    }
+                }
+            }
+            // logger.group(`✗ Boot Error importing ${file}`);
+            logger.error(`${err.name}: ${err.message}`);
+            if (fileInfo)
+                logger.error(`Location: ${fileInfo}`);
+        }
+    }
+    return cont;
+}