nsp-server-pages 0.0.2 → 0.1.0

package/README.md

@@ -112,6 +112,22 @@ render(context);
 
 Launch web server with Express.js:
 
+```js
+const nsp = createNSP();
+const app = express();
+
+app.use("/", async (req, res, next) => {
+    const {path} = req;
+    const context = {indexDto: {name: req.query.name || "nsp"}};
+    const render = nsp.loadJSP(`${BASE}/src/main/webapp/WEB-INF/${path}`);
+    if (!render) return next();
+    const html = await render(context);
+    res.type("html").send(html);
+});
+```
+
+Or use its own router `nsp.mount()` which helps to load JSP, HTML and JS files.
+
 ```js
 const nsp = createNSP();
 
@@ -125,10 +141,12 @@ nsp.mount("/include/", (path) => nsp.loadFile(`${BASE}/htdocs/${path}`));
 nsp.mount("/cached/", (path) => nsp.loadJS(`${BASE}/cached/${path}`));
 
 const app = express();
+
 app.use("/", async (req, res, next) => {
     const context = {indexDto: {name: req.query.name || "nsp"}};
     const render = await nsp.load(req.path);
-    const html = render(context);
+    if (!render) return next();
+    const html = await render(context);
     res.type("html").send(html);
 });
 ```

package/cjs/src/app.js

@@ -17,17 +17,17 @@ class App {
         this.fnMap = new Map();
         this.listeners = new Map;
         this.options = options = Object.create(options || null);
-        if (!options.conf)
-            options.conf = {};
-        if (!options.vKey)
-            options.vKey = "v";
-        if (!options.nspKey)
-            options.nspKey = "nsp";
-    }
-    on(type, fn) {
+        if (!options.vName)
+            options.vName = "v";
+        if (!options.nspName)
+            options.nspName = "nsp";
+        if (!options.storeKey)
+            options.storeKey = "#nsp";
+    }
+    hook(type, fn) {
         this.listeners.set(type, fn);
     }
-    emit(type, arg) {
+    process(type, arg) {
         const fn = this.listeners.get(type);
         if (fn)
             return fn(arg);
@@ -60,8 +60,8 @@ class App {
     parse(src) {
         return (0, parse_jsp_js_1.parseJSP)(this, src);
     }
-    mount(match, fn) {
-        return (0, mount_js_1.mount)(this, match, fn);
+    mount(path, fn) {
+        return (0, mount_js_1.mount)(this, path, fn);
     }
     load(path) {
         return (0, mount_js_1.load)(this, path);
@@ -78,4 +78,17 @@ class App {
         const loader = this.fileLoader || (this.fileLoader = new loaders_js_1.FileLoader(this));
         return loader.load(file);
     }
+    store(context, key, initFn) {
+        if ("object" !== typeof context && context == null) {
+            throw new Error("Context must be an object");
+        }
+        const { storeKey } = this.options;
+        const map = context[storeKey] || (context[storeKey] = new Map());
+        let value = map.get(key);
+        if (value == null) {
+            value = initFn();
+            map.set(key, value);
+        }
+        return value;
+    }
 }

package/cjs/src/catch.js

@@ -19,11 +19,18 @@ const catchFn = (app, fn) => {
             return errorHandler(e);
         }
         function errorHandler(e) {
-            const result = app.emit("error", e, context);
-            if (result == null) {
-                return `<!--\n[ERR] ${escapeError(e)}\n-->`;
+            // just throw the error if it's already handled
+            if (context != null) {
+                const data = app.store(context, "error", () => ({}));
+                if (data.error === e)
+                    throw e;
+                data.error = e;
             }
-            return result;
+            // call the error handler
+            const result = app.process("error", e, context);
+            if (result != null)
+                return result;
+            return `<!--\n[ERR] ${escapeError(e)}\n-->`;
         }
     };
 };

package/cjs/src/parse-attr.js

@@ -24,10 +24,10 @@ class AttrParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, vKey, `return ${js}`);
+            const fn = Function(nspName, vName, `return ${js}`);
             return (context) => fn(app, context);
         }
         catch (e) {

package/cjs/src/parse-el.js

@@ -25,9 +25,8 @@ const floatRE = `${numericRE}(?:\\.${numericRE})?(?!\\.)`;
 const stringRE = `"(?:\\\\\\.|[^\\\\"])*"|'(?:\\\\\\.|[^\\\\'])*'`;
 const nameRE = `[A-Za-z_][A-Za-z_0-9]*(?![A-Za-z_0-9])`;
 const tagFnRE = `${nameRE}:${nameRE}\\(`;
-const variableRE = `${nameRE}(?:\\.${nameRE}|\\[(?:${numericRE}|${stringRE})\\])*`;
-const opRE = `[+\\-\\*/%=<>()!|&:?,]+(?![+\\-\\*/%=<>()!|&:?,])`;
-const itemRE = [tagFnRE, variableRE, floatRE, stringRE, opRE].join("|");
+const variableRE = `${nameRE}(?:\\??\\.${nameRE}|(?:\\?\\.)?\\[(?:${numericRE}|${stringRE})\\]|\\[)*`;
+const itemRE = [tagFnRE, variableRE, floatRE, stringRE].join("|");
 const tagFnRegExp = new RegExp(`^${tagFnRE}$`, "s");
 const variableRegExp = new RegExp(`^${variableRE}$`, "s");
 const itemRegExp = new RegExp(`(${itemRE})`, "s");
@@ -47,10 +46,10 @@ class ElParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, vKey, `return ${js}`);
+            const fn = Function(nspName, vName, `return ${js}`);
             return (context) => fn(app, context);
         }
         catch (e) {
@@ -63,14 +62,14 @@ class ElParser {
      */
     toJS(_) {
         const { app } = this;
-        const { prefilter, postfilter } = app.options;
+        const { nullish, prefilter, postfilter } = app.options;
         let src = trim(this.src);
         if (prefilter)
             src = prefilter(src);
         if (src == null)
             return 'null';
         const array = src.split(itemRegExp);
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         for (let i = 0; i < array.length; i++) {
             let exp = array[i];
             if (i & 1) {
@@ -81,14 +80,14 @@ class ElParser {
                 else if (tagFnRegExp.test(exp)) {
                     // taglib function
                     exp = exp.replace(/\($/, "");
-                    array[i] = `${nspKey}.fn(${JSON.stringify(exp)})(`;
+                    array[i] = `${nspName}.fn(${JSON.stringify(exp)})(`;
                 }
                 else if (variableRegExp.test(exp)) {
                     // variable
-                    exp = exp.replace(/\./g, "?.");
-                    exp = exp.replace(/\[/g, "?.[");
+                    exp = exp.replace(/(\?)?\./g, "?.");
+                    exp = exp.replace(/(\?\.)?\[/g, "?.[");
                     exp = exp.replace(/\s+$/, "");
-                    array[i] = `${vKey}.${exp}`;
+                    array[i] = `${vName}.${exp}`;
                 }
             }
             else {
@@ -97,6 +96,12 @@ class ElParser {
             }
         }
         let js = array.join("");
+        if (!nullish) {
+            if (array.filter(v => /\S/.test(v)).length > 1) {
+                js = `(${js})`;
+            }
+            js = `${js} ?? ""`;
+        }
         if (postfilter)
             js = postfilter(js);
         return js;

package/cjs/src/parse-jsp.js

@@ -37,7 +37,7 @@ class Element {
      */
     toJS(option) {
         const { app, tagLine } = this;
-        const { comment, nspKey, vKey } = app.options;
+        const { comment, nspName, trimSpaces, vName } = app.options;
         const indent = +app.options.indent || 0;
         const currentIndent = +option?.indent || 0;
         const nextIndent = currentIndent + indent;
@@ -50,12 +50,18 @@ class Element {
             }
             else if (!/\S/.test(item)) {
                 // item with only whitespace
-                return '""';
+                return (trimSpaces !== false) ? '""' : JSON.stringify(item);
             }
             else {
+                if (trimSpaces !== false) {
+                    item = item.replace(/^\s*[\r\n]/s, "\n");
+                    item = item.replace(/\s*[\r\n]\s*$/s, "\n");
+                    item = item.replace(/^[ \t]+/s, " ");
+                    item = item.replace(/[ \t]+$/s, " ");
+                }
                 let js = (0, parse_text_js_1.parseText)(app, item).toJS({ indent: nextIndent });
                 if (/\(.+?\)|\$\{.+?}/s.test(js)) {
-                    js = `${vKey} => ${js}`; // array function
+                    js = `${vName} => ${js}`; // array function
                 }
                 return js;
             }
@@ -81,19 +87,19 @@ class Element {
         const bodyL = /^`\n/s.test(body) ? (isRoot ? "" : " ") : nextLF;
         const bodyR = /(\n`|[)\s])$/s.test(body) ? "" : currentLF;
         if (isRoot) {
-            return `${nspKey}.bundle(${bodyL}${body}${bodyR})`; // root element
+            return `${nspName}.bundle(${bodyL}${body}${bodyR})`; // root element
         }
         // attributes as the second argument
         let attr = (0, parse_attr_js_1.parseAttr)(app, tagLine).toJS({ indent: args.length ? nextIndent : currentIndent });
         if (/\(.+?\)|\$\{.+?}/s.test(attr)) {
-            attr = `${vKey} => (${attr})`; // array function
+            attr = `${vName} => (${attr})`; // array function
         }
         const commentV = comment ? `// ${tagLine?.replace(/\s*[\r\n]\s*/g, " ") ?? ""}${currentLF}` : "";
         const nameV = JSON.stringify(tagName);
         const hasAttr = /:/.test(attr);
         const attrV = (hasBody || hasAttr) ? `, ${attr}` : "";
         const bodyV = hasBody ? `,${bodyL}${body}${bodyR}` : "";
-        return `${commentV}${nspKey}.tag(${nameV}${attrV}${bodyV})`;
+        return `${commentV}${nspName}.tag(${nameV}${attrV}${bodyV})`;
     }
 }
 /**
@@ -144,10 +150,10 @@ class JspParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey } = app.options;
+        const { nspName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, `return ${js}`);
+            const fn = Function(nspName, `return ${js}`);
             return fn(app);
         }
         catch (e) {
@@ -163,7 +169,6 @@ const tagRegExp = new RegExp(`(</?${nameRE}:(?:${insideRE})*?>)|(<%(?:${insideRE
 const jspToJS = (app, src, option) => {
     const root = new Element(app);
     const tree = new Tree(root);
-    const { trimSpaces } = app.options;
     const array = src.split(tagRegExp);
     for (let i = 0; i < array.length; i++) {
         const i3 = i % 3;
@@ -190,12 +195,6 @@ const jspToJS = (app, src, option) => {
         }
         else if (i3 === 0) {
             // text node
-            if (trimSpaces !== false) {
-                str = str.replace(/^\s*[\r\n]/s, "\n");
-                str = str.replace(/\s*[\r\n]\s*$/s, "\n");
-                str = str.replace(/^[ \t]+/s, " ");
-                str = str.replace(/[ \t]+$/s, " ");
-            }
             tree.append(str);
         }
     }

package/cjs/src/parse-scriptlet.js

@@ -29,13 +29,13 @@ class ScriptletParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey } = app.options;
+        const { nspName } = app.options;
         const js = this.toJS();
         const isComment = /^\/\/[^\n]*$/s.test(js);
         if (isComment)
             return () => null;
         try {
-            const fn = Function(nspKey, `return ${js}`);
+            const fn = Function(nspName, `return ${js}`);
             return fn(app);
         }
         catch (e) {
@@ -48,22 +48,24 @@ class ScriptletParser {
      */
     toJS(option) {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
+        const currentIndent = +option?.indent || 0;
+        const currentLF = currentIndent ? "\n" + " ".repeat(currentIndent) : "\n";
         let { src } = this;
         const type = typeMap[src.substring(0, 3)] || "scriptlet";
         if (type === "comment") {
-            src = src.replace(/\s\s+/sg, " ");
+            src = src.replace(/[ \t]*[\r\n]+/sg, `${currentLF}// `);
             return `// ${src}`;
         }
         if (type === "expression") {
             src = src.replace(/^<%=\s*/s, "");
             src = src.replace(/\s*%>$/s, "");
             src = (0, parse_el_js_1.parseEL)(app, src).toJS(option);
-            return `${vKey} => (${src})`;
+            return `${vName} => (${src})`;
         }
         app.log(`${type} found: ${src?.substring(0, 1000)}`);
         src = /`|\$\{/.test(src) ? JSON.stringify(src) : "`" + src + "`";
-        src = `${vKey} => ${nspKey}.emit("${type}", ${src}, ${vKey})`;
+        src = `${vName} => ${nspName}.process("${type}", ${src}, ${vName})`;
         return src;
     }
 }

package/cjs/src/parse-text.js

@@ -38,10 +38,10 @@ class TextParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, vKey, `return ${js}`);
+            const fn = Function(nspName, vName, `return ${js}`);
             return (context) => fn(app, context);
         }
         catch (e) {

package/cjs/src/taglib.js

@@ -18,11 +18,10 @@ const addTagLib = (app, tagLibDef) => {
 };
 exports.addTagLib = addTagLib;
 const prepareTag = (app, name, attr, body) => {
-    const { tagMap, options } = app;
+    const { tagMap } = app;
     const tagFn = tagMap.get(name) || defaultTagFn;
-    const conf = options.conf[name];
     const attrFn = !attr ? () => ({}) : (typeof attr !== "function") ? () => attr : attr;
-    const tagDef = { name, app, conf, attr: attrFn, body };
+    const tagDef = { name, app, attr: attrFn, body };
     return tagFn(tagDef);
 };
 exports.prepareTag = prepareTag;

package/index.d.ts

@@ -23,7 +23,6 @@ declare namespace NSP {
 
     interface TagDef<A, T = any> {
         app: App;
-        conf: any;
         name: string;
         attr: AttrFn<A, T>;
         body: NodeFn<T>;
@@ -33,35 +32,47 @@ declare namespace NSP {
         logger?: { log: (message: string) => void };
 
         /**
-         * tag configuration
+         * variable name for context
+         * @default "v"
          */
-        conf?: { [tagName: string]: any };
+        vName?: string;
 
         /**
-         * variable name for context
+         * variable name for App instance
+         * @default "nsp"
          */
-        vKey?: string;
+        nspName?: string;
 
         /**
-         * variable name for App instance
+         * property name for data store in context
+         * @default "#nsp"
          */
-        nspKey?: string;
+        storeKey?: string;
 
         /**
          * indent size for JavaScript source generated
+         * @default 0
          */
         indent?: number;
 
         /**
          * add comments at toJS() result
+         * @default false
          */
         comment?: boolean;
 
         /**
-         * remove edge spaces in HTML in some cases
+         * set false not to remove edge spaces in HTML in some cases.
+         * @default true
          */
         trimSpaces?: boolean;
 
+        /**
+         * set true to keep EL result value of `null` and `undefined` as is.
+         * @default false
+         */
+        nullish?: boolean;
+
         /**
          * expression filter before transpile starts
          */
@@ -79,52 +90,102 @@ declare namespace NSP {
         options: Options;
         tagMap: Map<string, TagFn<any>>;
 
+        /**
+         * register a tag library
+         */
         addTagLib(tagLibDef: TagLibDef): void;
 
-        bundle<T>(...node: Node<T>[]): NodeFn<T>;
+        /**
+         * build a NodeFn which returns a string for the content nodes
+         */
+        bundle<T>(...nodes: Node<T>[]): NodeFn<T>;
 
+        /**
+         * concat strings even if they are Promise<string>
+         */
         concat(...text: TextFlex[]): string | Promise<string>;
 
-        emit<T>(type: "error", e: Error, context?: T): string;
+        /**
+         * retrieve a result from hook function
+         */
+        process<T>(type: "error", e: Error, context?: T): string;
 
-        emit<T>(type: "directive", src: string, context?: T): string;
+        process<T>(type: "directive", src: string, context?: T): string;
 
-        emit<T>(type: "declaration", src: string, context?: T): string;
+        process<T>(type: "declaration", src: string, context?: T): string;
 
-        emit<T>(type: "scriptlet", src: string, context?: T): string;
+        process<T>(type: "scriptlet", src: string, context?: T): string;
 
+        /**
+         * pickup the taglib function
+         */
         fn(name: string): (...args: any[]) => any;
 
+        /**
+         * load a NodeFn for the path mounted by mount()
+         */
         load<T>(path: string): Promise<NodeFn<T>>;
 
+        /**
+         * load a NodeFn for the local filesystem path
+         */
         loadFile<T>(file: string): Promise<NodeFn<T>>;
 
         loadJS<T>(file: string): Promise<NodeFn<T>>;
 
         loadJSP<T>(file: string): Promise<NodeFn<T>>;
 
+        /**
+         * log a message via options.logger which defaults console.log
+         */
         log(message: string): void;
 
-        mount(match: RegExp | string, fn: LoaderFn): void;
+        /**
+         * mount a loader function for the path matched
+         */
+        mount(path: RegExp | string, fn: LoaderFn): void;
 
-        on(type: "error", fn: <T>(e: Error, context?: T) => string | void): void;
+        /**
+         * register a hook function
+         */
+        hook(type: "error", fn: <T>(e: Error, context?: T) => string | void): void;
 
-        on(type: "directive", fn: <T>(src: string, context?: T) => string | void): void;
+        hook(type: "directive", fn: <T>(src: string, context?: T) => string | void): void;
 
-        on(type: "declaration", fn: <T>(src: string, context?: T) => string | void): void;
+        hook(type: "declaration", fn: <T>(src: string, context?: T) => string | void): void;
 
-        on(type: "scriptlet", fn: <T>(src: string, context?: T) => string | void): void;
+        hook(type: "scriptlet", fn: <T>(src: string, context?: T) => string | void): void;
 
+        /**
+         * parse a JSP document
+         */
         parse(src: string): Parser;
 
+        /**
+         * get a private data store in context
+         */
+        store<S>(context: any, key: string, initFn?: () => S): S;
+
+        /**
+         * generates a NodeFn for the tag
+         */
         tag<A, T = any>(name: string, attr?: A | AttrFn<A, T>, ...body: Node<T>[]): NodeFn<T>;
     }
 
     interface TagLibDef {
+        /**
+         * namespace
+         */
         ns: string;
 
+        /**
+         * functions
+         */
         fn?: { [name: string]: (...args: any[]) => any };
 
+        /**
+         * tags
+         */
         tag?: { [name: string]: TagFn<any> };
     }
 
@@ -136,8 +197,14 @@ declare namespace NSP {
      * Parser for JSP document
      */
     interface Parser {
+        /**
+         * transpile the JSP document to JavaScript source code
+         */
         toJS(option?: ToJSOption): string;
 
+        /**
+         * compile the JSP document as a NodeFn
+         */
         toFn<T>(): NodeFn<T>;
     }
 }

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "nsp-server-pages",
   "description": "NSP JavaScript Server Pages for Node.js",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "author": "@kawanet",
   "bugs": {
     "url": "https://github.com/kawanet/nsp-server-pages/issues"
   },
   "dependencies": {
-    "async-cache-queue": "^0.2.7",
-    "to-xml": "^0.1.10"
+    "async-cache-queue": "^0.2.8",
+    "to-xml": "^0.1.11"
   },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^15.2.0",
+    "@rollup/plugin-node-resolve": "^15.2.1",
     "@types/mocha": "^10.0.1",
-    "@types/node": "^20.5.1",
+    "@types/node": "^20.5.3",
     "mocha": "^10.2.0",
     "typescript": "^5.1.6"
   },

package/src/app.js

@@ -13,17 +13,17 @@ class App {
         this.fnMap = new Map();
         this.listeners = new Map;
         this.options = options = Object.create(options || null);
-        if (!options.conf)
-            options.conf = {};
-        if (!options.vKey)
-            options.vKey = "v";
-        if (!options.nspKey)
-            options.nspKey = "nsp";
-    }
-    on(type, fn) {
+        if (!options.vName)
+            options.vName = "v";
+        if (!options.nspName)
+            options.nspName = "nsp";
+        if (!options.storeKey)
+            options.storeKey = "#nsp";
+    }
+    hook(type, fn) {
         this.listeners.set(type, fn);
     }
-    emit(type, arg) {
+    process(type, arg) {
         const fn = this.listeners.get(type);
         if (fn)
             return fn(arg);
@@ -56,8 +56,8 @@ class App {
     parse(src) {
         return parseJSP(this, src);
     }
-    mount(match, fn) {
-        return mount(this, match, fn);
+    mount(path, fn) {
+        return mount(this, path, fn);
     }
     load(path) {
         return load(this, path);
@@ -74,4 +74,17 @@ class App {
         const loader = this.fileLoader || (this.fileLoader = new FileLoader(this));
         return loader.load(file);
     }
+    store(context, key, initFn) {
+        if ("object" !== typeof context && context == null) {
+            throw new Error("Context must be an object");
+        }
+        const { storeKey } = this.options;
+        const map = context[storeKey] || (context[storeKey] = new Map());
+        let value = map.get(key);
+        if (value == null) {
+            value = initFn();
+            map.set(key, value);
+        }
+        return value;
+    }
 }

package/src/catch.js

@@ -16,11 +16,18 @@ export const catchFn = (app, fn) => {
             return errorHandler(e);
         }
         function errorHandler(e) {
-            const result = app.emit("error", e, context);
-            if (result == null) {
-                return `<!--\n[ERR] ${escapeError(e)}\n-->`;
+            // just throw the error if it's already handled
+            if (context != null) {
+                const data = app.store(context, "error", () => ({}));
+                if (data.error === e)
+                    throw e;
+                data.error = e;
             }
-            return result;
+            // call the error handler
+            const result = app.process("error", e, context);
+            if (result != null)
+                return result;
+            return `<!--\n[ERR] ${escapeError(e)}\n-->`;
         }
     };
 };

package/src/parse-attr.js

@@ -20,10 +20,10 @@ class AttrParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, vKey, `return ${js}`);
+            const fn = Function(nspName, vName, `return ${js}`);
             return (context) => fn(app, context);
         }
         catch (e) {

package/src/parse-el.js

@@ -22,9 +22,8 @@ const floatRE = `${numericRE}(?:\\.${numericRE})?(?!\\.)`;
 const stringRE = `"(?:\\\\\\.|[^\\\\"])*"|'(?:\\\\\\.|[^\\\\'])*'`;
 const nameRE = `[A-Za-z_][A-Za-z_0-9]*(?![A-Za-z_0-9])`;
 const tagFnRE = `${nameRE}:${nameRE}\\(`;
-const variableRE = `${nameRE}(?:\\.${nameRE}|\\[(?:${numericRE}|${stringRE})\\])*`;
-const opRE = `[+\\-\\*/%=<>()!|&:?,]+(?![+\\-\\*/%=<>()!|&:?,])`;
-const itemRE = [tagFnRE, variableRE, floatRE, stringRE, opRE].join("|");
+const variableRE = `${nameRE}(?:\\??\\.${nameRE}|(?:\\?\\.)?\\[(?:${numericRE}|${stringRE})\\]|\\[)*`;
+const itemRE = [tagFnRE, variableRE, floatRE, stringRE].join("|");
 const tagFnRegExp = new RegExp(`^${tagFnRE}$`, "s");
 const variableRegExp = new RegExp(`^${variableRE}$`, "s");
 const itemRegExp = new RegExp(`(${itemRE})`, "s");
@@ -43,10 +42,10 @@ class ElParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, vKey, `return ${js}`);
+            const fn = Function(nspName, vName, `return ${js}`);
             return (context) => fn(app, context);
         }
         catch (e) {
@@ -59,14 +58,14 @@ class ElParser {
      */
     toJS(_) {
         const { app } = this;
-        const { prefilter, postfilter } = app.options;
+        const { nullish, prefilter, postfilter } = app.options;
         let src = trim(this.src);
         if (prefilter)
             src = prefilter(src);
         if (src == null)
             return 'null';
         const array = src.split(itemRegExp);
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         for (let i = 0; i < array.length; i++) {
             let exp = array[i];
             if (i & 1) {
@@ -77,14 +76,14 @@ class ElParser {
                 else if (tagFnRegExp.test(exp)) {
                     // taglib function
                     exp = exp.replace(/\($/, "");
-                    array[i] = `${nspKey}.fn(${JSON.stringify(exp)})(`;
+                    array[i] = `${nspName}.fn(${JSON.stringify(exp)})(`;
                 }
                 else if (variableRegExp.test(exp)) {
                     // variable
-                    exp = exp.replace(/\./g, "?.");
-                    exp = exp.replace(/\[/g, "?.[");
+                    exp = exp.replace(/(\?)?\./g, "?.");
+                    exp = exp.replace(/(\?\.)?\[/g, "?.[");
                     exp = exp.replace(/\s+$/, "");
-                    array[i] = `${vKey}.${exp}`;
+                    array[i] = `${vName}.${exp}`;
                 }
             }
             else {
@@ -93,6 +92,12 @@ class ElParser {
             }
         }
         let js = array.join("");
+        if (!nullish) {
+            if (array.filter(v => /\S/.test(v)).length > 1) {
+                js = `(${js})`;
+            }
+            js = `${js} ?? ""`;
+        }
         if (postfilter)
             js = postfilter(js);
         return js;

package/src/parse-jsp.js

@@ -33,7 +33,7 @@ class Element {
      */
     toJS(option) {
         const { app, tagLine } = this;
-        const { comment, nspKey, vKey } = app.options;
+        const { comment, nspName, trimSpaces, vName } = app.options;
         const indent = +app.options.indent || 0;
         const currentIndent = +option?.indent || 0;
         const nextIndent = currentIndent + indent;
@@ -46,12 +46,18 @@ class Element {
             }
             else if (!/\S/.test(item)) {
                 // item with only whitespace
-                return '""';
+                return (trimSpaces !== false) ? '""' : JSON.stringify(item);
             }
             else {
+                if (trimSpaces !== false) {
+                    item = item.replace(/^\s*[\r\n]/s, "\n");
+                    item = item.replace(/\s*[\r\n]\s*$/s, "\n");
+                    item = item.replace(/^[ \t]+/s, " ");
+                    item = item.replace(/[ \t]+$/s, " ");
+                }
                 let js = parseText(app, item).toJS({ indent: nextIndent });
                 if (/\(.+?\)|\$\{.+?}/s.test(js)) {
-                    js = `${vKey} => ${js}`; // array function
+                    js = `${vName} => ${js}`; // array function
                 }
                 return js;
             }
@@ -77,19 +83,19 @@ class Element {
         const bodyL = /^`\n/s.test(body) ? (isRoot ? "" : " ") : nextLF;
         const bodyR = /(\n`|[)\s])$/s.test(body) ? "" : currentLF;
         if (isRoot) {
-            return `${nspKey}.bundle(${bodyL}${body}${bodyR})`; // root element
+            return `${nspName}.bundle(${bodyL}${body}${bodyR})`; // root element
         }
         // attributes as the second argument
         let attr = parseAttr(app, tagLine).toJS({ indent: args.length ? nextIndent : currentIndent });
         if (/\(.+?\)|\$\{.+?}/s.test(attr)) {
-            attr = `${vKey} => (${attr})`; // array function
+            attr = `${vName} => (${attr})`; // array function
         }
         const commentV = comment ? `// ${tagLine?.replace(/\s*[\r\n]\s*/g, " ") ?? ""}${currentLF}` : "";
         const nameV = JSON.stringify(tagName);
         const hasAttr = /:/.test(attr);
         const attrV = (hasBody || hasAttr) ? `, ${attr}` : "";
         const bodyV = hasBody ? `,${bodyL}${body}${bodyR}` : "";
-        return `${commentV}${nspKey}.tag(${nameV}${attrV}${bodyV})`;
+        return `${commentV}${nspName}.tag(${nameV}${attrV}${bodyV})`;
     }
 }
 /**
@@ -140,10 +146,10 @@ class JspParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey } = app.options;
+        const { nspName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, `return ${js}`);
+            const fn = Function(nspName, `return ${js}`);
             return fn(app);
         }
         catch (e) {
@@ -159,7 +165,6 @@ const tagRegExp = new RegExp(`(</?${nameRE}:(?:${insideRE})*?>)|(<%(?:${insideRE
 export const jspToJS = (app, src, option) => {
     const root = new Element(app);
     const tree = new Tree(root);
-    const { trimSpaces } = app.options;
     const array = src.split(tagRegExp);
     for (let i = 0; i < array.length; i++) {
         const i3 = i % 3;
@@ -186,12 +191,6 @@ export const jspToJS = (app, src, option) => {
         }
         else if (i3 === 0) {
             // text node
-            if (trimSpaces !== false) {
-                str = str.replace(/^\s*[\r\n]/s, "\n");
-                str = str.replace(/\s*[\r\n]\s*$/s, "\n");
-                str = str.replace(/^[ \t]+/s, " ");
-                str = str.replace(/[ \t]+$/s, " ");
-            }
             tree.append(str);
         }
     }

package/src/parse-scriptlet.js

@@ -25,13 +25,13 @@ class ScriptletParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey } = app.options;
+        const { nspName } = app.options;
         const js = this.toJS();
         const isComment = /^\/\/[^\n]*$/s.test(js);
         if (isComment)
             return () => null;
         try {
-            const fn = Function(nspKey, `return ${js}`);
+            const fn = Function(nspName, `return ${js}`);
             return fn(app);
         }
         catch (e) {
@@ -44,22 +44,24 @@ class ScriptletParser {
      */
     toJS(option) {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
+        const currentIndent = +option?.indent || 0;
+        const currentLF = currentIndent ? "\n" + " ".repeat(currentIndent) : "\n";
         let { src } = this;
         const type = typeMap[src.substring(0, 3)] || "scriptlet";
         if (type === "comment") {
-            src = src.replace(/\s\s+/sg, " ");
+            src = src.replace(/[ \t]*[\r\n]+/sg, `${currentLF}// `);
             return `// ${src}`;
         }
         if (type === "expression") {
             src = src.replace(/^<%=\s*/s, "");
             src = src.replace(/\s*%>$/s, "");
             src = parseEL(app, src).toJS(option);
-            return `${vKey} => (${src})`;
+            return `${vName} => (${src})`;
         }
         app.log(`${type} found: ${src?.substring(0, 1000)}`);
         src = /`|\$\{/.test(src) ? JSON.stringify(src) : "`" + src + "`";
-        src = `${vKey} => ${nspKey}.emit("${type}", ${src}, ${vKey})`;
+        src = `${vName} => ${nspName}.process("${type}", ${src}, ${vName})`;
         return src;
     }
 }

package/src/parse-text.js

@@ -34,10 +34,10 @@ class TextParser {
      */
     toFn() {
         const { app } = this;
-        const { nspKey, vKey } = app.options;
+        const { nspName, vName } = app.options;
         const js = this.toJS();
         try {
-            const fn = Function(nspKey, vKey, `return ${js}`);
+            const fn = Function(nspName, vName, `return ${js}`);
             return (context) => fn(app, context);
         }
         catch (e) {

package/src/taglib.js

@@ -14,11 +14,10 @@ export const addTagLib = (app, tagLibDef) => {
     }
 };
 export const prepareTag = (app, name, attr, body) => {
-    const { tagMap, options } = app;
+    const { tagMap } = app;
     const tagFn = tagMap.get(name) || defaultTagFn;
-    const conf = options.conf[name];
     const attrFn = !attr ? () => ({}) : (typeof attr !== "function") ? () => attr : attr;
-    const tagDef = { name, app, conf, attr: attrFn, body };
+    const tagDef = { name, app, attr: attrFn, body };
     return tagFn(tagDef);
 };
 const defaultTagFn = (tagDef) => {