rasengan 1.0.0-beta.50 → 1.0.0-beta.52

package/bin.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+// Import `process` explicitly if needed (e.g., in certain runtime environments).
+import process from 'process';
+
+// If not already set, default `NODE_ENV=development`
+process.env.NODE_ENV = process.env.NODE_ENV ?? 'development';
+
+// Import and execute the CLI script
+import('./lib/esm/cli/index.js').catch((err) => {
+  console.error('Failed to start the Rasengan CLI:', err);
+  process.exit(1);
+});

package/lib/cjs/cli/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const execa_1 = require("execa");
+const program = new commander_1.Command();
+program
+    .name(chalk_1.default.blue('rasengan'))
+    .version('1.0.0', '-v, --version', 'Output the current version number');
+// Handle the dev command
+program
+    .command('dev')
+    .option('-p <port>')
+    .description('Start development server')
+    .action(async ({ p: port }) => {
+    const convertedPort = Number(port);
+    // Checking port
+    if (port &&
+        (isNaN(convertedPort) || convertedPort < 0 || convertedPort > 65535)) {
+        console.log('');
+        console.log(chalk_1.default.red('Please provide a valid port number between 0-65535'));
+        console.log('');
+        process.exit(1);
+    }
+    (0, execa_1.execa)('node', ['node_modules/rasengan/lib/esm/server/dev/server'], {
+        stdio: 'inherit',
+        env: {
+            ...process.env,
+            PORT: convertedPort ? convertedPort.toString() : undefined,
+        },
+    });
+});
+// Handle the build command
+program
+    .command('build')
+    .description('Build the project')
+    .action(async () => {
+    (0, execa_1.execa)('node', ['node_modules/rasengan/lib/esm/scripts/build-command'], {
+        stdio: 'inherit',
+    });
+});
+program.parse(process.argv);

package/lib/cjs/client.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderApp = void 0;
+const render_js_1 = __importDefault(require("./entries/client/render.js"));
+exports.renderApp = render_js_1.default;

package/lib/cjs/core/config/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = exports.defineConfig = void 0;
+const define_config_js_1 = require("./utils/define-config.js");
+Object.defineProperty(exports, "defineConfig", { enumerable: true, get: function () { return define_config_js_1.defineConfig; } });
+const path_js_1 = require("./utils/path.js");
+Object.defineProperty(exports, "resolvePath", { enumerable: true, get: function () { return path_js_1.resolvePath; } });

package/lib/cjs/core/config/type.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export type ConfigOptions = {
+//   mode: 'development' | 'production' | 'test';
+//   command: 'serve' | 'build';
+//   isSsrBuild?: boolean;
+// };

package/lib/cjs/core/config/utils/define-config.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+/**
+ * Function to define the config for the app
+ * It will be used by vite.config.ts and other files in other to configure the app
+ * @param {AppConfig | AppConfigFunction | AppConfigFunctionAsync} loadedConfig
+ */
+const defineConfig = async (loadedConfig) => {
+    return async () => {
+        let config;
+        // Check if the loadedConfig is a function
+        if (typeof loadedConfig === 'function') {
+            // Call the function to get the config
+            const result = loadedConfig();
+            // Check if it's a promise (asynchronous function)
+            if (result instanceof Promise) {
+                config = await result; // Await the promise result (AppConfigFunctionAsync)
+            }
+            else {
+                config = result; // Synchronous function result (AppConfigFunction)
+            }
+        }
+        else {
+            config = loadedConfig;
+        }
+        const { server, vite, redirects } = config;
+        // Define default values for vite config coming from loadedConfig.vite
+        const defaultViteConfig = {
+            ...vite,
+            resolve: {
+                symbole: vite?.resolve?.symbole || '@',
+                alias: vite?.resolve?.alias || [],
+            },
+        };
+        // Define default values for server config coming from loadedConfig.server
+        const defaultServerConfig = {
+            development: {
+                port: server?.development?.port || undefined,
+                open: server?.development?.open || false,
+            },
+        };
+        // Define default values for redirects config coming from loadedConfig.redirects
+        const defaultRedirectsConfig = redirects || (() => new Promise((resolve) => resolve([])));
+        try {
+            const config = {
+                server: defaultServerConfig,
+                vite: {
+                    ...defaultViteConfig,
+                    resolve: {
+                        alias: [
+                            {
+                                find: defaultViteConfig.resolve.symbole,
+                                replacement: './src',
+                            },
+                            ...defaultViteConfig.resolve.alias,
+                        ],
+                    },
+                },
+                redirects: defaultRedirectsConfig,
+            };
+            return config;
+        }
+        catch (error) {
+            return {
+                vite: {
+                    appType: 'custom',
+                    resolve: {
+                        alias: [
+                            {
+                                find: '@',
+                                replacement: './src',
+                            },
+                        ],
+                    },
+                },
+                redirects: () => new Promise((resolve) => resolve([])),
+            };
+        }
+    };
+};
+exports.defineConfig = defineConfig;

package/lib/cjs/core/config/utils/load-modules.js

@@ -0,0 +1,120 @@
+"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 __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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDirname = exports.findModulePath = exports.loadModuleSSR = exports.extensions = void 0;
+const path_js_1 = require("./path.js");
+const promises_1 = __importDefault(require("fs/promises"));
+exports.extensions = [
+    '.mjs',
+    '.js',
+    '.mts',
+    '.ts',
+    '.jsx',
+    '.tsx',
+    '.json',
+];
+/**
+ * Asynchronously loads a module from a file path only in the server-side environment.
+ *
+ * @param path - The path to the module.
+ * @returns The loaded module.
+ */
+const loadModuleSSR = async (path) => {
+    try {
+        let modulePath = path;
+        // Check if the module path has an extension
+        const moduleExtension = path.split('.').pop(); // eg: js or ts
+        if (!moduleExtension || !exports.extensions.includes(`.${moduleExtension}`)) {
+            const { path: newPath } = await (0, exports.findModulePath)(path);
+            modulePath = newPath;
+        }
+        const module = await Promise.resolve(`${(0, path_js_1.resolvePath)(modulePath)}`).then(s => __importStar(require(s)));
+        return module;
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+};
+exports.loadModuleSSR = loadModuleSSR;
+/**
+ * Finds the module path with the right extension.
+ *
+ * @param path - The path to the module.
+ * @returns The module path and extension.
+ */
+const findModulePath = async (path) => {
+    try {
+        let modulePath = path;
+        let rightExtension = '';
+        // Check if the module path has an extension
+        const moduleExtension = path.split('.').pop(); // eg: js or ts
+        if (!moduleExtension || !exports.extensions.includes(`.${moduleExtension}`)) {
+            for (let ext of exports.extensions) {
+                const newModulePath = `${modulePath}${ext}`;
+                try {
+                    await promises_1.default.access(newModulePath);
+                    modulePath = newModulePath;
+                    rightExtension = ext;
+                    break;
+                }
+                catch (error) {
+                    continue;
+                }
+            }
+            if (modulePath === path) {
+                throw new Error(`Module "${path}" not found`);
+            }
+        }
+        return {
+            path: modulePath,
+            extension: rightExtension,
+        };
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+};
+exports.findModulePath = findModulePath;
+const getDirname = async (url) => {
+    // Load the dirname function from the path module
+    // and return the dirname of the file URL
+    const { dirname } = await Promise.resolve().then(() => __importStar(require('node:path')));
+    const { fileURLToPath } = await Promise.resolve().then(() => __importStar(require('node:url')));
+    return dirname(fileURLToPath(url));
+};
+exports.getDirname = getDirname;

package/lib/cjs/core/config/utils/path.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePath = void 0;
+/**
+ * Adapts the provided file path to a valid URL format based on the operating system.
+ *
+ * @param path - The file path to be adapted.
+ * @returns The adapted file path in a valid URL format.
+ */
+const resolvePath = (path) => {
+    // Check the OS
+    const isWindows = process.platform === 'win32';
+    // Adapt the path
+    if (isWindows) {
+        return `file:///${path}`;
+    }
+    return path;
+};
+exports.resolvePath = resolvePath;

package/lib/cjs/core/config/vite/defaults.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultViteConfig = void 0;
+// core/config/defaults.ts
+const node_path_1 = require("node:path");
+// Define core external packages
+const CORE_EXTERNALS = [
+// '@rasenganjs/mdx',
+// '@rasenganjs/vercel',
+// '@rasenganjs/netlify',
+];
+const createDefaultViteConfig = (rootPath, __dirname, mode, config) => {
+    // Combine core externals with user-defined externals
+    const externals = [
+        ...CORE_EXTERNALS,
+        ...(Array.isArray(config.vite?.build?.external)
+            ? config.vite.build.external
+            : []),
+    ];
+    return {
+        ...config.vite,
+        root: rootPath,
+        build: {
+            sourcemap: mode === 'development',
+            rollupOptions: {
+                external: externals,
+                input: './src/index',
+                output: {
+                    manualChunks(id) {
+                        if (id.includes('node_modules'))
+                            return 'vendor';
+                        if (id.includes('src/components'))
+                            return 'shared-components';
+                        if (id.includes('src/app') && id.includes('.page.')) {
+                            const parts = id.split('src/app')[1]?.split('/');
+                            if (parts?.length) {
+                                const pageName = parts.pop()?.split('.')[0];
+                                return pageName ? `page-${pageName}` : undefined;
+                            }
+                        }
+                        return undefined;
+                    },
+                },
+            },
+            outDir: 'dist',
+            chunkSizeWarningLimit: 1000,
+        },
+        environments: {
+            client: {
+                build: {
+                    manifest: true,
+                    outDir: 'dist/client',
+                    rollupOptions: {
+                        input: './src/index',
+                    },
+                },
+            },
+            ssr: {
+                build: {
+                    outDir: 'dist/server',
+                    rollupOptions: {
+                        input: {
+                            'entry.server': (0, node_path_1.join)(__dirname, './lib/esm/entries/server/entry.server.js'),
+                            'app.router': './src/app/app.router',
+                            main: './src/main',
+                            template: './src/template',
+                            config: './rasengan.config.js',
+                        },
+                    },
+                    ssrEmitAssets: false,
+                },
+            },
+        },
+        resolve: {
+            alias: Array.isArray(config.vite?.resolve?.alias)
+                ? config.vite.resolve.alias.map(({ find, replacement }) => ({
+                    find,
+                    replacement: (0, node_path_1.join)(rootPath, replacement),
+                }))
+                : [],
+        },
+        builder: {
+            buildApp: async (builder) => {
+                await builder.build(builder.environments.ssr);
+                await builder.build(builder.environments.client);
+            },
+        },
+        cacheDir: '.rasengan/',
+        envPrefix: 'RASENGAN_',
+        appType: 'custom',
+    };
+};
+exports.createDefaultViteConfig = createDefaultViteConfig;

package/lib/cjs/core/dynamic/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicLoad = dynamicLoad;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+/**
+ * It allows you to defer loading of Client Components,
+ * and only include them in the client bundle when they're needed
+ * @param load
+ * @param fallback
+ * @returns
+ */
+function dynamicLoad(load, fallback = (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, {}) // Default pending UI element
+) {
+    try {
+        const LazyComponent = (0, react_1.lazy)(load);
+        // Return a functional component preserving the exact props type
+        const WrappedComponent = (props) => ((0, jsx_runtime_1.jsx)(react_1.Suspense, { fallback: fallback, children: (0, jsx_runtime_1.jsx)(LazyComponent, { ...props }) }));
+        return WrappedComponent;
+    }
+    catch (error) {
+        throw new Error(error);
+    }
+}

package/lib/cjs/core/index.js

@@ -0,0 +1,3 @@
+"use strict";
+// export { defineConfig, resolvePath } from "./config/index.js";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/core/middlewares/index.js

@@ -0,0 +1,17 @@
+"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("./logger.js"), exports);

package/lib/cjs/core/middlewares/logger.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerMiddleware = void 0;
+const log_js_1 = require("../utils/log.js");
+const loggerMiddleware = (req, _, next) => {
+    const url = req.originalUrl;
+    (0, log_js_1.logGetRequest)(url);
+    next();
+};
+exports.loggerMiddleware = loggerMiddleware;

package/lib/cjs/core/plugins/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugins = exports.Adapters = void 0;
+exports.rasengan = rasengan;
+const path_1 = require("path");
+const fs_1 = __importDefault(require("fs"));
+const load_modules_js_1 = require("../config/utils/load-modules.js");
+function loadRasenganConfig() {
+    return {
+        name: 'vite-plugin-rasengan-config',
+        async config(_, { command }) {
+            if (command !== 'build')
+                return;
+            const configPath = (0, path_1.resolve)(process.cwd(), 'rasengan.config.js');
+            if (!fs_1.default.existsSync(configPath)) {
+                throw new Error(`Configuration file not found at: ${configPath}`);
+            }
+            const rasenganConfig = await (await (0, load_modules_js_1.loadModuleSSR)(configPath)).default;
+            const partialConfig = {
+                server: rasenganConfig.server ?? {},
+                redirects: rasenganConfig.redirects
+                    ? await rasenganConfig.redirects()
+                    : [],
+            };
+            // Inject the configuration as a global constant
+            return {
+                define: {
+                    ['__RASENGAN_CONFIG__']: JSON.stringify(partialConfig),
+                },
+            };
+        },
+    };
+}
+function rasenganConfigPlugin() {
+    const virtualModuleId = 'virtual:rasengan-config';
+    const resolvedVirtualModuleId = '\0' + virtualModuleId;
+    return {
+        name: 'vite-plugin-rasengan-config',
+        resolveId(id) {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId;
+            }
+        },
+        async load(id) {
+            if (id === resolvedVirtualModuleId) {
+                // if (command !== "build") return;
+                const configPath = (0, path_1.resolve)(process.cwd(), 'rasengan.config.js');
+                if (!fs_1.default.existsSync(configPath)) {
+                    throw new Error(`Configuration file not found at: ${configPath}`);
+                }
+                const rasenganConfig = await (await (0, load_modules_js_1.loadModuleSSR)(configPath)).default;
+                const partialConfig = {
+                    server: rasenganConfig.server ?? {},
+                    redirects: rasenganConfig.redirects
+                        ? await rasenganConfig.redirects()
+                        : [],
+                };
+                return `
+          export const __RASENGAN_CONFIG__ = ${JSON.stringify(partialConfig)};
+        `;
+            }
+        },
+    };
+}
+function buildOutputInformation() {
+    const virtualModuleId = 'virtual:rasengan-build-info';
+    const resolvedVirtualModuleId = '\0' + virtualModuleId;
+    return {
+        name: 'vite-plugin-rasengan-build-info',
+        resolveId(id) {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId;
+            }
+        },
+        async load(id) {
+            if (id === resolvedVirtualModuleId) {
+                return `
+          export const resolveBuildOptions = (buildPath) => {
+            return {
+              buildDirectory: buildPath,
+              manifestPathDirectory: 'client/.vite',
+              assetPathDirectory: 'client/assets',
+              entryServerPath: 'server/entry.server.js',
+            };
+          };
+        `;
+            }
+        },
+    };
+}
+exports.Adapters = {
+    VERCEL: 'vercel',
+    DEFAULT: '',
+};
+function rasengan({ adapter = { name: exports.Adapters.DEFAULT, prepare: async () => { } }, }) {
+    let config = {};
+    return {
+        name: 'vite-plugin-rasengan',
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
+        async closeBundle() {
+            // We check here if the environment is client has been built because it's the
+            // last environment to be built in the Vite build process
+            if (this.environment.name === 'client') {
+                // Preparing app for deployment
+                switch (adapter.name) {
+                    case exports.Adapters.VERCEL: {
+                        console.log('Preparing app for deployment to Vercel');
+                        await adapter.prepare();
+                        break;
+                    }
+                    default:
+                        break;
+                }
+            }
+        },
+    };
+}
+exports.plugins = [];

package/lib/cjs/core/types.js

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

package/lib/cjs/core/utils/log.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.logGetRequest = exports.logRedirection = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const logRedirection = (source, destination) => {
+    const time = new Date().toLocaleTimeString();
+    console.log(`${chalk_1.default.grey(time)} ${chalk_1.default.blue('[Rasengan]')} ${chalk_1.default.green('REDIRECT')}: ${chalk_1.default.grey(source)} ${chalk_1.default.green('->')} ${chalk_1.default.grey(destination)}`);
+};
+exports.logRedirection = logRedirection;
+const logGetRequest = (url) => {
+    const time = new Date().toLocaleTimeString();
+    console.log(`${chalk_1.default.grey(time)} ${chalk_1.default.blue('[Rasengan]')} ${chalk_1.default.green('GET')}: ${chalk_1.default.grey(url)}`);
+};
+exports.logGetRequest = logGetRequest;

package/lib/cjs/entries/client/render.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = renderApp;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const client_1 = require("react-dom/client");
+const react_1 = require("react");
+const template_js_1 = require("../../routing/components/template.js");
+function renderApp(App, options) {
+    const root = document.getElementById('root');
+    if (!root) {
+        throw new Error('Root element not found');
+    }
+    if (options.reactStrictMode) {
+        (0, client_1.hydrateRoot)(root, (0, jsx_runtime_1.jsx)(react_1.StrictMode, { children: (0, jsx_runtime_1.jsx)(App, { Component: template_js_1.RootComponent }) }));
+    }
+    else {
+        (0, client_1.hydrateRoot)(root, (0, jsx_runtime_1.jsx)(App, { Component: template_js_1.RootComponent }));
+    }
+}

package/lib/cjs/entries/server/entry.server.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const load_modules_js_1 = require("../../core/config/utils/load-modules.js");
+const index_js_1 = require("./index.js");
+const posix_1 = require("path/posix");
+const rendering_js_1 = require("../../server/node/rendering.js");
+/**
+ * Render the app to a stream
+ * @param StaticRouterComponent
+ * @param helmetContext
+ * @param res
+ * @returns
+ */
+const render = async (StaticRouterComponent, res, options) => {
+    const { metadata, assets, buildOptions } = options;
+    // Root path
+    const rootPath = process.cwd();
+    let App;
+    let Template;
+    if (buildOptions) {
+        App = (await (0, load_modules_js_1.loadModuleSSR)(posix_1.posix.join(buildOptions.buildDirectory, buildOptions.serverPathDirectory, 'main.js'))).default;
+        Template = (await (0, load_modules_js_1.loadModuleSSR)((0, posix_1.join)(buildOptions.buildDirectory, buildOptions.serverPathDirectory, 'template.js'))).default;
+    }
+    else {
+        // Import Main App Component
+        App = (await (0, load_modules_js_1.loadModuleSSR)(`${rootPath}/src/main`)).default;
+        // Import Template
+        Template = (await (0, load_modules_js_1.loadModuleSSR)(`${rootPath}/src/template`)).default;
+    }
+    await (0, rendering_js_1.renderToStream)((0, jsx_runtime_1.jsx)(index_js_1.TemplateLayout, { StaticRouterComponent: StaticRouterComponent, metadata: metadata, assets: assets, App: App, Template: Template }), res);
+};
+exports.render = render;