@handlebars/parser 2.2.1 → 2.2.3

package/lib/helpers.js

@@ -164,8 +164,18 @@ export function prepareBlock(
       );
     }
 
-    if (inverseAndProgram.chain) {
-      inverseAndProgram.program.body[0].closeStrip = close.strip;
+    // Only at the outermost block (where close is the real closing tag, not another
+    // chain link) propagate its strip flags through all chained else-if blocks.
+    if (inverseAndProgram.chain && !close.chain) {
+      const closeStrip = close.strip;
+      let innerBlock = inverseAndProgram.program.body[0];
+      // Walk the full chain so every block gets the real closing tag's strip flags.
+      while (innerBlock) {
+        innerBlock.closeStrip = closeStrip;
+        innerBlock = (innerBlock.inverse && innerBlock.inverse.chained)
+          ? innerBlock.inverse.body[0]
+          : null;
+      }
     }
 
     inverseStrip = inverseAndProgram.strip;

package/lib/whitespace-control.js

@@ -41,7 +41,9 @@ WhitespaceControl.prototype.Program = function (program) {
         // If we are on a standalone node, save the indent info for partials
         if (current.type === 'PartialStatement') {
           // Pull out the whitespace from the final line
-          current.indent = /([ \t]+$)/.exec(body[i - 1].original)[1];
+          current.indent = /(?:^|[^ \t])([ \t]+)$/.exec(
+            body[i - 1].original
+          )[1];
         }
       }
     }
@@ -55,7 +57,21 @@ WhitespaceControl.prototype.Program = function (program) {
       // Always strip the next node
       omitRight(body, i);
 
-      omitLeft((current.inverse || current.program).body);
+      // For chained else-if blocks, walk the chain and strip trailing indent
+      // from every terminal body so all execution paths lose the close-tag indent.
+      let chainNode = current.inverse;
+      if (chainNode && chainNode.chained) {
+        while (chainNode && chainNode.chained) {
+          let lastBlock = chainNode.body[chainNode.body.length - 1];
+          omitLeft(lastBlock.program.body);
+          chainNode = lastBlock.inverse;
+        }
+        if (chainNode) {
+          omitLeft(chainNode.body);
+        }
+      } else {
+        omitLeft((current.inverse || current.program).body);
+      }
     }
   }
 
@@ -158,9 +174,13 @@ function isPrevWhitespace(body, i, isRoot) {
   }
 
   if (prev.type === 'ContentStatement') {
-    return (sibling || !isRoot ? /\r?\n\s*?$/ : /(^|\r?\n)\s*?$/).test(
-      prev.original
-    );
+    // Matches when the trailing whitespace contains a newline (or, for the
+    // root's first node, is the whole string). See omitLeft for the anchoring.
+    return (
+      sibling || !isRoot
+        ? /(?:^|\S)[^\S\n]*\n\s*$/
+        : /^\s*$|(?:^|\S)[^\S\n]*\n\s*$/
+    ).test(prev.original);
   }
 }
 function isNextWhitespace(body, i, isRoot) {
@@ -225,7 +245,13 @@ function omitLeft(body, i, multiple) {
 
   // We omit the last node if it's whitespace only and not preceded by a non-content node.
   let original = current.value;
-  current.value = current.value.replace(multiple ? /\s+$/ : /[ \t]+$/, '');
+  // The match must start after a non-whitespace character (or at the start):
+  // a plain /\s+$/ is retried at every position of a whitespace run, which
+  // takes quadratic time on long runs.
+  current.value = current.value.replace(
+    multiple ? /(^|\S)\s+$/ : /(^|[^ \t])[ \t]+$/,
+    '$1'
+  );
   current.leftStripped = current.value !== original;
   return current.leftStripped;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@handlebars/parser",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "The parser for the Handlebars language",
   "homepage": "https://github.com/handlebars-lang/handlebars-parser#readme",
   "bugs": {
@@ -46,7 +46,7 @@
     "mocha": "^10.7.3",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.1.1",
-    "release-plan": "^0.16.0",
+    "release-plan": "^0.18.0",
     "typescript": "^5.6.3"
   },
   "engines": {
@@ -57,13 +57,13 @@
     "registry": "https://registry.npmjs.org"
   },
   "scripts": {
-    "lint": "eslint .",
     "build": "npm-run-all build:parser build:esm build:cjs",
-    "build:cjs": "tsc --module nodenext --moduleResolution nodenext --target es5 --outDir dist/cjs",
+    "build:cjs": "tsc --module commonjs --moduleResolution node --target es5 --outDir dist/cjs",
     "build:esm": "tsc --module es2015 --target es5 --outDir dist/esm",
     "build:jison": "jison -m js src/handlebars.yy src/handlebars.l -o lib/parser.js",
     "build:parser": "npm-run-all build:jison build:parser-suffix",
     "build:parser-suffix": "combine-files lib/parser.js,src/parser-suffix.js lib/parser.js",
+    "lint": "eslint .",
     "pretest": "pnpm run build",
     "test": "mocha --inline-diffs spec",
     "pretest:bail": "pnpm run build",

package/spec/ast.js

@@ -17,6 +17,17 @@ describe('ast', function () {
         equals(ast.body[0].value, '');
         equals(ast.body[1].program.body[0].value, 'foo');
       });
+
+      it('tilde on one else-if does not strip trailing whitespace in later branches', function () {
+        let ast = parse('{{#if a}}A{{else if b}}B {{~else if c}}C {{/if}}'),
+          block = ast.body[0],
+          bBlock = block.inverse.body[0],
+          cBlock = bBlock.inverse.body[0];
+
+        equals(block.program.body[0].value, 'A');
+        equals(bBlock.program.body[0].value, 'B'); // tilde strips trailing space from b
+        equals(cBlock.program.body[0].value, 'C '); // no tilde on {{/if}}, space preserved
+      });
     });
 
     describe('parseWithoutProcessing', function () {
@@ -36,6 +47,35 @@ describe('ast', function () {
         equals(ast.body[1].program.body[0].value, ' \nfoo\n ');
       });
     });
+
+    describe('performance', function () {
+      // Each template below takes several seconds to parse, and so exceeds the
+      // test timeout, if finding trailing whitespace is not linear in its length.
+      let spaces = ' '.repeat(100000),
+        newlines = '\n'.repeat(100000);
+
+      it('should strip whitespace in linear time', function () {
+        let ast = parse(spaces + 'x' + spaces + '{{~foo}}');
+
+        equals(ast.body[0].value, spaces + 'x');
+      });
+
+      it('should detect standalone lines in linear time', function () {
+        let ast = parse(newlines + 'x{{foo}}');
+        equals(ast.body[0].value, newlines + 'x');
+
+        ast = parse('{{foo}}' + newlines + 'x{{foo}}');
+        equals(ast.body[1].value, newlines + 'x');
+      });
+
+      it('should find partial indentation in linear time', function () {
+        let ast = parse(spaces + 'x\n  {{> dude}}\n');
+
+        equals(ast.body[0].value, spaces + 'x\n');
+        equals(ast.body[1].indent, '  ');
+        equals(ast.body[2].value, '');
+      });
+    });
   });
 
   describe('node details', function () {
@@ -236,6 +276,20 @@ describe('ast', function () {
 
         equals(ast.body[2].value, '');
       });
+
+      it('strips close-tag indent from all chained else-if branches', function () {
+        let ast = parse(
+            '  {{#if a}}\n    foo\n  {{else if b}}\n    bar\n  {{else if c}}\n    baz\n  {{/if}}'
+          ),
+          block = ast.body[1],
+          bBlock = block.inverse.body[0],
+          cBlock = bBlock.inverse.body[0];
+
+        equals(ast.body[0].value, '');
+        equals(block.program.body[0].value, '    foo\n');
+        equals(bBlock.program.body[0].value, '    bar\n');
+        equals(cBlock.program.body[0].value, '    baz\n'); // indent before {{/if}} stripped
+      });
     });
     describe('partials - parseWithoutProcessing', function () {
       it('simple partial', function () {

package/tsconfig.json

@@ -28,4 +28,4 @@
     "node_modules",
     ".vscode"
   ]
-}
+}