zuby 1.0.38 → 1.0.40

package/branding.js

@@ -5,5 +5,5 @@ export const getBrand = () => {
     return name.charAt(0).toUpperCase() + name.slice(1) + '.js';
 };
 export const getTitle = (title) => {
-    return `${chalk.bgYellow.bold.whiteBright(` ${getBrand()} `)}${chalk.yellowBright.bgWhite(` v${version} `)} ${title}`;
+    return `${chalk.bgYellow.bold.whiteBright(` ${getBrand()} `)}${chalk.yellowBright.bgBlackBright(` v${version} `)} ${title}`;
 };

package/config.d.ts

@@ -30,4 +30,4 @@ export declare const mergeDefaultConfig: (config: ZubyConfig) => Promise<ZubyInt
  * Check which framework components are relying on each plugin
  * before removing any of them.
  */
-export declare const getBuiltInPlugins: () => import("vite").PluginOption[];
+export declare const getBuiltInPlugins: () => (false | import("vite").Plugin<any> | import("vite").PluginOption[] | Promise<false | import("vite").Plugin<any> | import("vite").PluginOption[] | null | undefined> | null | undefined)[];

package/config.js

@@ -1,4 +1,4 @@
-import { ZUBY_CONFIG_FILE } from './constants.js';
+import { ZUBY_BUILD_CHUNKS_MANIFEST, ZUBY_CONFIG_FILE } from './constants.js';
 import { existsSync } from 'fs';
 import { bundleRequire } from 'bundle-require';
 import { createLogger } from './logger/index.js';
@@ -7,6 +7,7 @@ import contextPlugin from './plugins/contextPlugin/index.js';
 import compileTimePlugin from './plugins/compileTimePlugin/index.js';
 import chunkNamingPlugin from './plugins/chunkNamingPlugin/index.js';
 import prerenderPlugin from './plugins/prerenderPlugin/index.js';
+import manifestPlugin from './plugins/manifestPlugin/index.js';
 let zubyInternalConfig;
 /**
  * Returns the path to the ZubyConfig file.
@@ -111,8 +112,9 @@ export const mergeDefaultConfig = async (config) => {
     config.vite.customLogger = config.vite.customLogger ?? config.customLogger;
     config.vite.server = config.vite.server ?? config.server;
     config.vite.publicDir = config.vite.publicDir ?? config.publicDir;
-    config.vite.build.ssrManifest = config.vite.build.ssrManifest ?? 'chunks-manifest.json';
+    config.vite.build.ssrManifest = ZUBY_BUILD_CHUNKS_MANIFEST;
     config.vite.build.ssrEmitAssets = config.vite.build.ssrEmitAssets ?? true;
+    config.vite.build.modulePreload = { polyfill: false };
     config.vite.optimizeDeps = config.vite.optimizeDeps ?? {};
     // Merge built-in plugins with user plugins
     config.vite.plugins = [
@@ -131,5 +133,5 @@ export const mergeDefaultConfig = async (config) => {
  * before removing any of them.
  */
 export const getBuiltInPlugins = () => {
-    return [contextPlugin(), compileTimePlugin(), chunkNamingPlugin(), prerenderPlugin()];
+    return [contextPlugin(), compileTimePlugin(), chunkNamingPlugin(), manifestPlugin(), prerenderPlugin()];
 };

package/constants.d.ts

@@ -1 +1,5 @@
 export declare const ZUBY_CONFIG_FILE = "zuby.config.mjs";
+export declare const ZUBY_BUILD_CHUNKS_MANIFEST = "chunks-manifest.json";
+export declare const ZUBY_CLIENT_CHUNKS_MANIFEST = "client-chunks-manifest.json";
+export declare const ZUBY_SERVER_CHUNKS_MANIFEST = "server-chunks-manifest.json";
+export declare const ZUBY_PAGES_MANIFEST = "pages-manifest.json";

package/constants.js

@@ -1 +1,5 @@
 export const ZUBY_CONFIG_FILE = 'zuby.config.mjs';
+export const ZUBY_BUILD_CHUNKS_MANIFEST = 'chunks-manifest.json';
+export const ZUBY_CLIENT_CHUNKS_MANIFEST = 'client-chunks-manifest.json';
+export const ZUBY_SERVER_CHUNKS_MANIFEST = 'server-chunks-manifest.json';
+export const ZUBY_PAGES_MANIFEST = 'pages-manifest.json';

package/logger/index.js

@@ -37,16 +37,13 @@ export function createLogger(level = 'info', options = {}) {
         if (thresh >= LogLevels[type]) {
             const method = type === 'info' ? 'log' : type;
             const format = () => {
-                const tag = type === 'info'
-                    ? chalk.cyan(chalk.bold(prefix))
-                    : type === 'warn'
-                        ? chalk.yellow(chalk.bold(prefix))
-                        : chalk.red(chalk.bold(prefix));
+                const tag = chalk.bold(prefix);
+                const fmsg = type === 'warn' ? chalk.yellow(msg) : type === 'error' ? chalk.red(msg) : msg;
                 if (options.timestamp) {
-                    return `${chalk.dim(timeFormatter.format(new Date()))} ${tag} ${msg}`;
+                    return `${chalk.dim(timeFormatter.format(new Date()))} ${tag} ${fmsg}`;
                 }
                 else {
-                    return `${msg}`;
+                    return `${fmsg}`;
                 }
             };
             if (options.error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zuby",
-  "version": "1.0.38",
+  "version": "1.0.40",
   "description": "Zuby.js is framework for building SPA apps using Vite",
   "type": "module",
   "main": "index.js",
@@ -17,21 +17,20 @@
     "linkDirectory": true
   },
   "dependencies": {
-    "@vercel/nft": "^0.24.3",
+    "@vercel/nft": "^0.26.2",
     "bundle-require": "^4.0.2",
     "chalk": "^5.3.0",
     "commander": "^11.0.0",
     "devalue": "^4.3.2",
-    "esbuild": "^0.19.5",
+    "esbuild": "^0.19.11",
     "glob": "^10.3.10",
-    "inquirer": "^9.2.11",
-    "jest": "^29.7.0",
+    "inquirer": "^9.2.12",
     "magic-string": "^0.30.5",
-    "rollup": "^4.0.2",
-    "vite": "^4.4.11"
+    "rollup": "^4.9.5",
+    "vite": "^5.0.11"
   },
   "devDependencies": {
-    "@types/inquirer": "^9.0.6"
+    "@types/inquirer": "^9.0.7"
   },
   "bin": {
     "zuby": "./commands/index.js"

package/plugins/manifestPlugin/index.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+/**
+ * This is internal plugin
+ * which generated and moves required manifest files.
+ */
+export default function manifestPlugin(): Plugin;

package/plugins/manifestPlugin/index.js

@@ -0,0 +1,28 @@
+import { renameSync } from 'fs';
+import { normalizePath } from '../../utils/pathUtils.js';
+import { join } from 'path';
+import { ZUBY_BUILD_CHUNKS_MANIFEST, ZUBY_CLIENT_CHUNKS_MANIFEST, ZUBY_SERVER_CHUNKS_MANIFEST, } from '../../constants.js';
+/**
+ * This is internal plugin
+ * which generated and moves required manifest files.
+ */
+export default function manifestPlugin() {
+    let viteConfig;
+    return {
+        name: 'zuby-manifest-plugin',
+        apply: 'build',
+        enforce: 'post',
+        async configResolved(config) {
+            viteConfig = config;
+        },
+        async closeBundle() {
+            // If the build is not for SSR, then skip the plugin
+            if (!viteConfig?.build.ssr) {
+                return;
+            }
+            // Move chunks manifest files
+            renameSync(normalizePath(join(viteConfig.build.outDir, '..', 'client', ZUBY_BUILD_CHUNKS_MANIFEST)), normalizePath(join(viteConfig.build.outDir, '..', ZUBY_CLIENT_CHUNKS_MANIFEST)));
+            renameSync(normalizePath(join(viteConfig.build.outDir, '..', 'server', ZUBY_BUILD_CHUNKS_MANIFEST)), normalizePath(join(viteConfig.build.outDir, '..', ZUBY_SERVER_CHUNKS_MANIFEST)));
+        }
+    };
+}

package/plugins/prerenderPlugin/index.js

@@ -1,10 +1,16 @@
-import { existsSync, mkdirSync } from 'fs';
-import { dirname, join } from 'path';
+import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { dirname, join, relative, resolve } from 'path';
 import { getZubyInternalConfig } from '../../config.js';
 import chalk from 'chalk';
 import { performance } from 'node:perf_hooks';
 import ZubyRenderer from '../../server/zubyRenderer.js';
 import { writeFile } from 'fs/promises';
+import { getPages } from '../../templates/index.js';
+import { OUTPUTS } from '../../types.js';
+import { PATH_TYPES } from '../../templates/types.js';
+import { substitutePathParams } from '../../templates/pathUtils.js';
+import { normalizePath } from '../../utils/pathUtils.js';
+import { ZUBY_SERVER_CHUNKS_MANIFEST } from '../../constants.js';
 /**
  * This is internal plugin
  * that pre-renders the pages during the build.
@@ -24,7 +30,60 @@ export default function prerenderPlugin() {
                 return;
             }
             const startTime = performance.now();
-            const { outDir, customLogger, prerenderPaths, site } = await getZubyInternalConfig();
+            const { srcDir, outDir, customLogger, prerenderPaths, site, output } = await getZubyInternalConfig();
+            const chunksManifestPath = resolve(outDir, ZUBY_SERVER_CHUNKS_MANIFEST);
+            const chunksManifest = existsSync(chunksManifestPath)
+                ? JSON.parse(readFileSync(chunksManifestPath, 'utf-8'))
+                : {};
+            const pages = await getPages();
+            for (const page of pages) {
+                const srcFilename = normalizePath(relative(srcDir, page.filename));
+                const outFilename = chunksManifest[srcFilename]?.shift();
+                if (!outFilename) {
+                    customLogger?.warn(`WARNING: Page "${page.path}" couldn't be pre-rendered because it doesn't have corresponding chunk file.`);
+                    continue;
+                }
+                const modulePath = normalizePath(resolve(outDir, 'server', outFilename.substring(1)));
+                const module = await import(`file:///${modulePath}`);
+                const pagePrerenderValue = module?.prerender && typeof module?.prerender === 'function'
+                    ? await module?.prerender()
+                    : module?.prerender;
+                const globalPrerenderValue = output === OUTPUTS.static;
+                const shouldPrerender = pagePrerenderValue ?? globalPrerenderValue;
+                if (!shouldPrerender)
+                    continue;
+                if (page.pathType === PATH_TYPES.static) {
+                    prerenderPaths.push(page.path);
+                    continue;
+                }
+                if (!module?.prerenderPaths && pagePrerenderValue) {
+                    const exampleParam = page.pathParams.pop() || '';
+                    const exampleFullPath = substitutePathParams(page.path, { [exampleParam]: 'value3' });
+                    customLogger?.warn(`WARNING: Page "${page.path}" has dynamic path and enabled pre-rendering but doesn't export prerenderPaths property.`);
+                    customLogger?.warn(`1. If you don't want to pre-render this page, you need to export prerender property with false value.`);
+                    customLogger?.warn(`Example: export const prerender = false`);
+                    customLogger?.warn(`2. If you want to pre-render this page, you need to export prerenderPaths property with array of paths.`);
+                    customLogger?.warn(`Example: export const prerenderPaths = [ { "${exampleParam}" : "value" }, { "${exampleParam}" : "value2" }, "${exampleFullPath}" ]\r\n`);
+                }
+                if (!module?.prerenderPaths) {
+                    continue;
+                }
+                const pagePrerenderPaths = typeof module?.prerenderPaths === 'function'
+                    ? await module?.prerenderPaths()
+                    : module?.prerenderPaths;
+                pagePrerenderPaths.forEach((params) => {
+                    // Handle case when path is defined as string
+                    // Example: /products/123
+                    if (typeof params === 'string') {
+                        return prerenderPaths.push(params);
+                    }
+                    // Handle case when path is defined as object of params
+                    // Example: { id: 123 } => /products/123
+                    if (typeof params === 'object') {
+                        return prerenderPaths.push(substitutePathParams(page.path, params));
+                    }
+                });
+            }
             customLogger?.info(`${chalk.bgYellow.bold.whiteBright(` Step 3/4 `)} ${chalk.gray(`pre-rendering pages...`)}`);
             const zubyRenderer = new ZubyRenderer(outDir);
             await zubyRenderer.init();
@@ -42,7 +101,9 @@ export default function prerenderPlugin() {
                     zubyRenderer.render(propsReq),
                 ]);
                 const [page, props] = await Promise.all([pageRes.text(), propsRes.text()]);
-                const pageTarget = join(outDir, 'client', path, 'index.html');
+                const pageContentType = pageRes.headers?.get('content-type');
+                const pageExtension = pageContentType?.startsWith('application/json') ? 'json' : 'html';
+                const pageTarget = join(outDir, 'client', path, `index.${pageExtension}`);
                 const propsTarget = join(outDir, 'client', '_props', path, 'index.json');
                 const pageDir = dirname(pageTarget);
                 const propsDir = dirname(propsTarget);
@@ -54,7 +115,7 @@ export default function prerenderPlugin() {
                     });
                 });
                 await Promise.all([writeFile(pageTarget, page), writeFile(propsTarget, props)]);
-                console.log('[prerender] Prerendered page: ' + path);
+                customLogger.info('[prerender] Pre-rendered path: ' + path);
             }
             const finishTime = performance.now();
             customLogger?.info(chalk.green(`✓ pre-rendered in ${Math.ceil(finishTime - startTime)}ms`));

package/server/index.js

@@ -744,7 +744,7 @@ var getBrand = () => {
   return name.charAt(0).toUpperCase() + name.slice(1) + ".js";
 };
 var getTitle = (title) => {
-  return `${source_default.bgYellow.bold.whiteBright(` ${getBrand()} `)}${source_default.yellowBright.bgWhite(
+  return `${source_default.bgYellow.bold.whiteBright(` ${getBrand()} `)}${source_default.yellowBright.bgBlackBright(
     ` v${version} `
   )} ${title}`;
 };
@@ -800,11 +800,12 @@ function createLogger(level = "info", options = {}) {
     if (thresh >= LogLevels[type]) {
       const method = type === "info" ? "log" : type;
       const format = () => {
-        const tag = type === "info" ? source_default.cyan(source_default.bold(prefix)) : type === "warn" ? source_default.yellow(source_default.bold(prefix)) : source_default.red(source_default.bold(prefix));
+        const tag = source_default.bold(prefix);
+        const fmsg = type === "warn" ? source_default.yellow(msg) : type === "error" ? source_default.red(msg) : msg;
         if (options2.timestamp) {
-          return `${source_default.dim(timeFormatter.format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
+          return `${source_default.dim(timeFormatter.format(/* @__PURE__ */ new Date()))} ${tag} ${fmsg}`;
         } else {
-          return `${msg}`;
+          return `${fmsg}`;
         }
       };
       if (options2.error) {
@@ -8388,6 +8389,9 @@ function findMatchingTemplate(templates, path2) {
   };
 }
 
+// src/constants.ts
+var ZUBY_CLIENT_CHUNKS_MANIFEST = "client-chunks-manifest.json";
+
 // src/server/zubyRenderer.ts
 var ZubyRenderer = class {
   constructor(outDir) {
@@ -8408,7 +8412,7 @@ var ZubyRenderer = class {
     if (this.entryClientCss) {
       this.entryClientCss = `/chunks/${basename(this.entryClientCss || "")}`;
     }
-    const manifestPath = resolve2(this.outDir, "client", "chunks-manifest.json");
+    const manifestPath = resolve2(this.outDir, ZUBY_CLIENT_CHUNKS_MANIFEST);
     if (existsSync(manifestPath)) {
       this.chunksManifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
     }
@@ -8432,7 +8436,26 @@ var ZubyRenderer = class {
       const handlerFunction = handlerModule.default || handlerModule;
       return handlerFunction(pageContext, next);
     };
-    return next();
+    const handlerResult = await next();
+    if (!handlerResult)
+      return;
+    if (handlerResult instanceof Response) {
+      return handlerResult;
+    }
+    if (typeof handlerResult === "string") {
+      return new Response(handlerResult.toString(), {
+        status: pageContext.statusCode || 200,
+        headers: {
+          "Content-Type": "text/html;charset=UTF-8"
+        }
+      });
+    }
+    return new Response(JSON.stringify(handlerResult, null, 2), {
+      status: pageContext.statusCode || 200,
+      headers: {
+        "Content-Type": "application/json;charset=UTF-8"
+      }
+    });
   }
   async executeProps(pageContext) {
     const propsHeader = pageContext.request?.headers.get("x-zuby-props");

package/server/zubyDevServer.js

@@ -89,8 +89,9 @@ export default class ZubyDevServer extends ZubyServer {
             cacheDir: normalizePath(join(this.zubyInternalConfig.cacheDir, 'server')),
             mode: MODES.development,
         });
+        // TODO: Remove this middleware when testing is done
+        // this.useBefore(this.viteServerDevServer.middlewares);
         this.useBefore(this.viteClientDevServer.middlewares);
-        this.useBefore(this.viteServerDevServer.middlewares);
         this.renderer = new ZubyDevRenderer(this.zubyInternalConfig, this.viteServerDevServer);
         watch(join(this.zubyInternalConfig.srcDir, 'pages'), { recursive: true }, (eventType, fileName) => {
             if (eventType === 'rename')

package/server/zubyRenderer.js

@@ -5,6 +5,7 @@ import { basename, resolve } from 'path';
 import { glob } from 'glob';
 import { existsSync, readFileSync } from 'fs';
 import { findMatchingTemplate } from '../templates/pathUtils.js';
+import { ZUBY_CLIENT_CHUNKS_MANIFEST } from '../constants.js';
 export default class ZubyRenderer {
     constructor(outDir) {
         this.outDir = outDir;
@@ -24,7 +25,7 @@ export default class ZubyRenderer {
         if (this.entryClientCss) {
             this.entryClientCss = `/chunks/${basename(this.entryClientCss || '')}`;
         }
-        const manifestPath = resolve(this.outDir, 'client', 'chunks-manifest.json');
+        const manifestPath = resolve(this.outDir, ZUBY_CLIENT_CHUNKS_MANIFEST);
         if (existsSync(manifestPath)) {
             this.chunksManifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
         }
@@ -49,7 +50,32 @@ export default class ZubyRenderer {
             // Execute the handler function
             return handlerFunction(pageContext, next);
         };
-        return next();
+        // Execute the handlers chain
+        const handlerResult = await next();
+        // If handler returned nothing, we'll continue to executeProps and executeEntry
+        if (!handlerResult)
+            return;
+        // If handler returned a response, we can immediately return it
+        if (handlerResult instanceof Response) {
+            return handlerResult;
+        }
+        // If handler returned string,
+        // we'll assume that user wants to return html response
+        if (typeof handlerResult === 'string') {
+            return new Response(handlerResult.toString(), {
+                status: pageContext.statusCode || 200,
+                headers: {
+                    'Content-Type': 'text/html;charset=UTF-8',
+                },
+            });
+        }
+        // We'll try to serialize everything else as JSON
+        return new Response(JSON.stringify(handlerResult, null, 2), {
+            status: pageContext.statusCode || 200,
+            headers: {
+                'Content-Type': 'application/json;charset=UTF-8',
+            },
+        });
     }
     async executeProps(pageContext) {
         const propsHeader = pageContext.request?.headers.get('x-zuby-props');

package/templates/index.d.ts

@@ -37,7 +37,7 @@ export declare function getDefaultTemplate(filename: string, templateType: Templ
  * The pages are already sorted from the least dynamic path to the most dynamic.
  * If i18n config is defined, the pages will be localized and duplicated for each locale.
  */
-export declare function getTemplates(): Promise<Template[]>;
+export declare function getTemplates(cache?: boolean): Promise<Template[]>;
 /**
  * Calculates the weight of each template
  * and sorts them from the least dynamic path to the most dynamic.

package/templates/index.js

@@ -4,6 +4,7 @@ import { basename, join, resolve } from 'path';
 import { glob } from 'glob';
 import { normalizePath } from '../utils/pathUtils.js';
 import { pathToRegexp, toPath } from './pathUtils.js';
+let templatesCache;
 /**
  * Returns the array of pages with static path.
  */
@@ -91,7 +92,9 @@ export function getDefaultTemplate(filename, templateType) {
  * The pages are already sorted from the least dynamic path to the most dynamic.
  * If i18n config is defined, the pages will be localized and duplicated for each locale.
  */
-export async function getTemplates() {
+export async function getTemplates(cache = true) {
+    if (cache && templatesCache)
+        return templatesCache;
     const { srcDir, i18n, templateExtensions } = await getZubyInternalConfig();
     const pagesDir = normalizePath(join(srcDir, 'pages'));
     const files = await glob(`${pagesDir}/**/*.{${templateExtensions.join(',')}}`);
@@ -135,7 +138,7 @@ export async function getTemplates() {
         ...template,
         ...pathToRegexp(template.path),
     }));
-    return sortTemplates(templates);
+    return (templatesCache = sortTemplates(templates));
 }
 /**
  * Calculates the weight of each template

package/templates/pathUtils.d.ts

@@ -1,3 +1,4 @@
+import { PathParamsType } from './types.js';
 import { LazyTemplate, Template } from './types.js';
 /**
  * Returns the matching template for the given path.
@@ -11,6 +12,11 @@ export declare const pathToRegexp: (pathPattern: string) => {
     pathParams: string[];
     pathRegex: RegExp;
 };
+/**
+ * Substitutes the path params in the given path.
+ * @example substitutePathParams('/products/:id', { id: 123 }) -> '/products/123'
+ */
+export declare const substitutePathParams: (path: string, params: PathParamsType) => string;
 /**
  * Transforms the page filename with next.js like syntax
  * to a valid wouter router syntax.

package/templates/pathUtils.js

@@ -44,6 +44,21 @@ export const pathToRegexp = (pathPattern) => {
         pathRegex: new RegExp('^' + result + '(?:\\/)?$', 'i'),
     };
 };
+/**
+ * Substitutes the path params in the given path.
+ * @example substitutePathParams('/products/:id', { id: 123 }) -> '/products/123'
+ */
+export const substitutePathParams = (path, params) => {
+    return path.replace(/:(\w+)/g, (matched, key) => {
+        const value = params[key];
+        if (value === undefined)
+            return '';
+        if (Array.isArray(value)) {
+            return value.join('/');
+        }
+        return value.toString();
+    });
+};
 /**
  * Transforms the page filename with next.js like syntax
  * to a valid wouter router syntax.

package/templates/types.d.ts

@@ -3,6 +3,9 @@ export declare const PATH_TYPES: {
     dynamic: string;
 };
 export type PathType = (typeof PATH_TYPES)[keyof typeof PATH_TYPES];
+export type PathParamsType = {
+    [key: string]: string | string[] | number | number[] | boolean | boolean[];
+};
 export interface Template {
     path: string;
     pathRegex: RegExp;

package/types.d.ts

@@ -4,6 +4,7 @@ import type { Plugin as VitePlugin } from 'vite';
 import type { PluginOption as VitePluginOption } from 'vite';
 import { ZubyLogger } from './logger/types.js';
 import ReadableStream = NodeJS.ReadableStream;
+import { PathParamsType } from './templates/types.js';
 export interface ZubyConfig {
     /**
      * The JSX provider which will be used to render the pages.
@@ -182,3 +183,21 @@ export interface JsxProvider {
 }
 export type RenderToString = (vnode: any) => Promise<string> | string;
 export type RenderToStream = (vnode: any) => Promise<ReadableStream> | ReadableStream;
+/**
+ * Export this property with boolean value from page module
+ * to enable/disable the pre-rendering of the page.
+ * @example export const prerender = false;
+ */
+export type Prerender = boolean | (() => boolean) | (() => Promise<boolean>);
+/**
+ * Represents single path/item of the prerenderPaths array.
+ */
+export type PrerenderPathsItem = PathParamsType | string;
+/**
+ * Export this property from page module to specify the paths to pre-render
+ * in case the page has dynamic path.
+ * @example export const prerenderPaths = ['/products/1', '/products/2'];
+ * @example export const prerenderPaths = [{ id: 1 }, { id: 2 }];
+ * @example export const prerenderPaths = [{ id: 1 }, '/products/2'];
+ */
+export type PrerenderPaths = PrerenderPathsItem[] | (() => PrerenderPathsItem[]) | (() => Promise<PrerenderPathsItem[]>);