v4.5.0

- tests are not compiled with babel and must thus be in
  es5
- we don't use polyfills, so we need to make sure no
  functions aren't used that are not supported by popular browsers. (like Object.assign in Safari and IE11)
- Boths are errors that usually only appear when running
  tests in SauceLabs, which happens only on _after_
  merging a PR.

.eslintrc.js

@@ -1,25 +1,11 @@
 module.exports = {
-  "extends": "eslint:recommended",
+  "extends": ["eslint:recommended","plugin:compat/recommended"],
   "globals": {
     "self": false
   },
   "env": {
-    "node": true
-  },
-  "ecmaFeatures": {
-    // Enabling features that can be implemented without polyfills. Want to avoid polyfills at this time.
-    "arrowFunctions": true,
-    "blockBindings": true,
-    "defaultParams": true,
-    "destructuring": true,
-    "modules": true,
-    "objectLiteralComputedProperties": true,
-    "objectLiteralDuplicateProperties": true,
-    "objectLiteralShorthandMethods": true,
-    "objectLiteralShorthandProperties": true,
-    "restParams": true,
-    "spread": true,
-    "templateStrings": true
+    "node": true,
+    "es6": true
   },
   "rules": {
     // overrides eslint:recommended defaults
@@ -124,6 +110,8 @@ module.exports = {
     "no-var": "warn"
   },
   "parserOptions": {
-    "sourceType": "module"
+    "sourceType": "module",
+    "ecmaVersion": 6,
+    "ecmaFeatures": {}
   }
-}
+}

.gitignore

@@ -12,3 +12,4 @@ npm-debug.log
 sauce_connect.log*
 .idea
 yarn-error.log
+/handlebars-release.tgz

.travis.yml

@@ -3,7 +3,6 @@ before_install:
 - npm install -g grunt-cli
 script:
 - grunt --stack travis
-- multi-nodejs-test/run-tests.sh 0.10 0.12 4 5 6 7 8 9 10 11
 email:
   on_failure: change
   on_success: never

CONTRIBUTING.md

@@ -90,6 +90,7 @@ Handlebars utilizes the [release yeoman generator][generator-release] to perform
 A full release may be completed with the following:
 
 ```
+npm ci
 yo release
 npm publish
 yo release:publish components handlebars.js dist/components/
@@ -104,7 +105,7 @@ in those places still point to the latest version
 
 * [The npm-package](https://www.npmjs.com/package/handlebars) (check latest-tag)
 * [The bower package](https://github.com/components/handlebars.js) (check the package.json)
-* [The AWS S3 Bucket](http://builds.handlebarsjs.com.s3.amazonaws.com/) (check latest-tag)
+* [The AWS S3 Bucket](https://s3.amazonaws.com/builds.handlebarsjs.com) (check latest-tag)
 * [RubyGems](https://rubygems.org/gems/handlebars-source)
 
 When everything is OK, the handlebars site needs to be updated to point to the new version numbers. The jsfiddle link should be updated to point to the most recent distribution for all instances in our documentation.

Gruntfile.js

@@ -5,19 +5,19 @@ module.exports = function(grunt) {
     pkg: grunt.file.readJSON('package.json'),
 
     eslint: {
-      options: {
-      },
       files: [
         '*.js',
         'bench/**/*.js',
         'tasks/**/*.js',
         'lib/**/!(*.min|parser).js',
         'spec/**/!(*.amd|json2|require).js',
-        'multi-nodejs-test/*.js'
+        'integration-testing/multi-nodejs-test/*.js',
+        'integration-testing/webpack-test/*.js',
+        'integration-testing/webpack-test/src/*.js'
       ]
     },
 
-    clean: ['tmp', 'dist', 'lib/handlebars/compiler/parser.js'],
+    clean: ['tmp', 'dist', 'lib/handlebars/compiler/parser.js', 'integration-testing/**/node_modules'],
 
     copy: {
       dist: {
@@ -192,7 +192,13 @@ module.exports = function(grunt) {
         cmd: 'npm run checkTypes',
         bg: false,
         fail: true
+      },
+      integrationTests: {
+        cmd: './integration-testing/run-integration-tests.sh',
+        bg: false,
+        fail: true
       }
+
     },
 
     watch: {
@@ -233,7 +239,7 @@ module.exports = function(grunt) {
   grunt.loadNpmTasks('grunt-babel');
   grunt.loadNpmTasks('grunt-bg-shell');
   grunt.loadNpmTasks('grunt-eslint');
-  grunt.loadNpmTasks('grunt-saucelabs');
+  grunt.loadNpmTasks('@knappi/grunt-saucelabs');
   grunt.loadNpmTasks('grunt-webpack');
 
   grunt.task.loadTasks('tasks');
@@ -241,8 +247,9 @@ module.exports = function(grunt) {
   grunt.registerTask('bench', ['metrics']);
   grunt.registerTask('sauce', process.env.SAUCE_USERNAME ? ['tests', 'connect', 'saucelabs-mocha'] : []);
 
-  grunt.registerTask('travis', process.env.PUBLISH ? ['default', 'sauce', 'metrics', 'publish:latest'] : ['default']);
+  grunt.registerTask('travis', process.env.PUBLISH ? ['default', 'bgShell:integrationTests', 'sauce', 'metrics', 'publish:latest'] : ['default']);
 
   grunt.registerTask('dev', ['clean', 'connect', 'watch']);
   grunt.registerTask('default', ['clean', 'build', 'test', 'release']);
+  grunt.registerTask('integration-tests', ['default', 'bgShell:integrationTests']);
 };

components/bower.json

@@ -1,6 +1,6 @@
 {
   "name": "handlebars",
-  "version": "4.1.2-0",
+  "version": "4.5.0",
   "main": "handlebars.js",
   "license": "MIT",
   "dependencies": {}

components/handlebars.js.nuspec

@@ -2,7 +2,7 @@
 <package>
 	<metadata>
 		<id>handlebars.js</id>
-		<version>4.1.2-0</version>
+		<version>4.5.0</version>
 		<authors>handlebars.js Authors</authors>
 		<licenseUrl>https://github.com/wycats/handlebars.js/blob/master/LICENSE</licenseUrl>
 		<projectUrl>https://github.com/wycats/handlebars.js/</projectUrl>

components/package.json

@@ -1,6 +1,6 @@
 {
   "name": "handlebars",
-  "version": "4.1.2-0",
+  "version": "4.5.0",
   "license": "MIT",
   "jspm": {
     "main": "handlebars",

docs/compiler-api.md

@@ -16,6 +16,34 @@ var ast = Handlebars.parse(myTemplate);
 Handlebars.precompile(ast);
 ```
 
+### Parsing
+
+There are two primary APIs that are used to parse an existing template into the AST:
+
+#### parseWithoutProcessing
+
+`Handlebars.parseWithoutProcessing` is the primary mechanism to turn a raw template string into the Handlebars AST described in this document. No processing is done on the resulting AST which makes this ideal for codemod (for source to source transformation) tooling.
+
+Example:
+
+```js
+let ast = Handlebars.parseWithoutProcessing(myTemplate);
+```
+
+#### parse
+
+`Handlebars.parse` will parse the template with `parseWithoutProcessing` (see above) then it will update the AST to strip extraneous whitespace. The whitespace stripping functionality handles two distinct situations:
+
+* Removes whitespace around dynamic statements that are on a line by themselves (aka "stand alone")
+* Applies "whitespace control" characters (i.e. `~`) by truncating the `ContentStatement` `value` property appropriately (e.g. `\n\n{{~foo}}` would have a `ContentStatement` with a `value` of `''`)
+
+`Handlebars.parse` is used internally by `Handlebars.precompile` and `Handlebars.compile`.
+
+Example:
+
+```js
+let ast = Handlebars.parse(myTemplate);
+```
 
 ### Basic
 

integration-testing/README.md

@@ -0,0 +1,12 @@
+Add a new integration test by creating a new subfolder
+
+Add a file "test.sh" to that runs the test. "test.sh" should exit with a non-zero exit code 
+and display an error message, if something goes wrong.
+
+* An integration test should reflect real-world setups that use handlebars.
+* It should compile a minimal template and compare the output to an expected output.
+* It should use "../.." as dependency for Handlebars so that the currently built library is used.
+
+Currently, integration tests are only running on Linux, especially in travis-ci.
+
+  

integration-testing/multi-nodejs-test/.eslintrc.js

@@ -0,0 +1,12 @@
+module.exports = {
+  "extends": "eslint:recommended",
+  "globals": {
+    "self": false
+  },
+  "env": {
+    "node": true
+  },
+  "rules": {
+    'no-console': 'off'
+  }
+}

integration-testing/multi-nodejs-test/.gitignore

@@ -0,0 +1,2 @@
+target
+package-lock.json

integration-testing/multi-nodejs-test/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "multi-nodejs-test",
+  "version": "1.0.0",
+  "description": "Simple integration test with all relevant NodeJS-versions.",
+  "keywords": [],
+  "author": "Nils Knappmeier",
+  "private": true,
+  "license": "MIT",
+  "dependencies": {
+    "handlebars": "file:../.."
+  },
+  "scripts": {
+    "test": "node run-handlebars.js",
+    "test-precompile": "handlebars precompile-test-template.txt.hbs"
+  }
+}

integration-testing/multi-nodejs-test/precompile-test-template.txt.hbs

@@ -0,0 +1 @@
+Author: {{author}}

integration-testing/multi-nodejs-test/run-handlebars.js

@@ -0,0 +1,11 @@
+// This test should run successfully with node 0.10++ as long as Handlebars has been compiled before
+var assert = require('assert');
+var Handlebars = require('handlebars');
+
+console.log('Testing built Handlebars with Node version ' + process.version);
+
+var template = Handlebars.compile('Author: {{author}}');
+var output = template({author: 'Yehuda'});
+assert.strictEqual(output, 'Author: Yehuda');
+
+console.log('Success');

integration-testing/multi-nodejs-test/test.sh

@@ -1,6 +1,7 @@
 #!/bin/bash
 
-cd "$( dirname "$( readlink -f "$0" )" )"
+cd "$( dirname "$( readlink -f "$0" )" )" || exit 1
+# shellcheck disable=SC1090
 [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
 
 # This script tests with precompiler and the built distribution with multiple NodeJS version.
@@ -13,9 +14,13 @@ cd "$( dirname "$( readlink -f "$0" )" )"
 
 # A list of NodeJS versions is expected as cli-args
 echo "Handlebars should be able to run in various versions of NodeJS"
-for i in "$@" ; do
+for i in  0.10 0.12 4 5 6 7 8 9 10 11 ; do
+    rm target node_modules package-lock.json -rf
+    mkdir target
     nvm install "$i"
-    nvm exec "$i" node ./run-handlebars.js >/dev/null || exit 1
-    nvm exec "$i" node ../bin/handlebars template.txt.hbs >/dev/null || exit 1
+    nvm exec "$i" npm install
+    nvm exec "$i" npm run test || exit 1
+    nvm exec "$i" npm run test-precompile || exit 1
+
     echo Success
 done

integration-testing/run-integration-tests.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+cd "$( dirname "$( readlink -f "$0" )" )" || exit 1
+
+for i in */test.sh ; do
+  (
+    echo "----------------------------------------"
+    echo "-- Running integration test: $i"
+    echo "----------------------------------------"
+    cd "$( dirname "$i" )" || exit 1
+    ./test.sh || exit 1
+  )
+done

integration-testing/webpack-babel-test/.babelrc

@@ -0,0 +1,11 @@
+{
+  "plugins": [
+    "@roundingwellos/babel-plugin-handlebars-inline-precompile"
+   // "istanbul"
+  ],
+  "presets": [
+    [
+      "@babel/preset-env"
+    ]
+  ]
+}

integration-testing/webpack-babel-test/.gitignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+package-lock.json

integration-testing/webpack-babel-test/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "webpack-babel-test",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@babel/core": "^7.5.5",
+    "@babel/preset-env": "^7.5.5",
+    "@roundingwellos/babel-plugin-handlebars-inline-precompile": "^3.0.1",
+    "babel-loader": "^8.0.6",
+    "babel-plugin-istanbul": "^5.2.0",
+    "handlebars": "file:../..",
+    "handlebars-loader": "^1.7.1",
+    "nyc": "^14.1.1",
+    "webpack": "^4.39.3",
+    "webpack-cli": "^3.3.7"
+  },
+  "scripts": {
+    "build": "webpack --config webpack.config.js"
+  }
+}

integration-testing/webpack-babel-test/src/handlebars-inline-precompile-test.js

@@ -0,0 +1,12 @@
+import * as Handlebars from 'handlebars/runtime'
+import hbs from 'handlebars-inline-precompile';
+import {assertEquals} from "../../webpack-test/src/lib/assert";
+
+Handlebars.registerHelper('loud', function(text) {
+    return text.toUpperCase();
+});
+
+const template = hbs`{{loud name}}`;
+const output = template({name: 'yehuda'})
+
+assertEquals(output, 'YEHUDA')

integration-testing/webpack-babel-test/src/lib/assert.js

@@ -0,0 +1,5 @@
+export function assertEquals(actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Expected "${actual}" to equal "${expected}"`);
+    }
+}

integration-testing/webpack-babel-test/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+set -e
+
+# Cleanup: package-lock and "npm ci" is not working with local dependencies
+rm dist package-lock.json -rf
+npm install
+npm run build
+
+for i in dist/*-test.js ; do
+  echo "----------------------"
+  echo "-- Running $i"
+  echo "----------------------"
+  node "$i"
+  echo "Success"
+done

integration-testing/webpack-babel-test/webpack.config.js

@@ -0,0 +1,32 @@
+const fs = require('fs');
+
+const testFiles = fs.readdirSync('src');
+const entryPoints = {};
+testFiles
+    .filter(file => file.match(/-test.js$/))
+    .forEach(file => {
+        entryPoints[file] = `./src/${file}`;
+    });
+
+module.exports = {
+    entry: entryPoints,
+    output: {
+        filename: '[name]',
+        path: __dirname + '/dist'
+    },
+    module: {
+        rules: [
+            {
+                test: /\.js?$/,
+                exclude: /node_modules/,
+                use: {
+                    loader: 'babel-loader',
+                    options: { cacheDirectory: false },
+                }
+            }
+        ]
+    },
+    optimization: {
+        minimize: false
+    }
+};

integration-testing/webpack-test/.gitignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+package-lock.json

integration-testing/webpack-test/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "webpack-test",
+  "description": "Various tests with Handlebars and Webpack",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "build": "webpack --config webpack.config.js",
+    "test": "node dist/main.js"
+  },
+  "private": true,
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {},
+  "devDependencies": {
+    "handlebars": "file:../..",
+    "handlebars-loader": "^1.7.1",
+    "webpack": "^4.39.3",
+    "webpack-cli": "^3.3.7"
+  }
+}

integration-testing/webpack-test/src/handlebars-default-import-pre-4.2-test.js

@@ -0,0 +1,6 @@
+import Handlebars from 'handlebars/dist/handlebars';
+
+import {assertEquals} from './lib/assert';
+
+const template = Handlebars.compile('Author: {{author}}');
+assertEquals(template({author: 'Yehuda'}), 'Author: Yehuda');

integration-testing/webpack-test/src/handlebars-default-import-test.js

@@ -0,0 +1,6 @@
+import Handlebars from 'handlebars';
+import {assertEquals} from './lib/assert';
+
+
+const template = Handlebars.compile('Author: {{author}}');
+assertEquals(template({author: 'Yehuda'}), 'Author: Yehuda');

integration-testing/webpack-test/src/handlebars-loader-test.js

@@ -0,0 +1,8 @@
+import {assertEquals} from './lib/assert';
+
+import testTemplate from './test-template.handlebars';
+assertEquals(testTemplate({author: 'Yehuda'}).trim(), 'Author: Yehuda');
+
+
+const testTemplateRequire = require('./test-template.handlebars');
+assertEquals(testTemplateRequire({author: 'Yehuda'}).trim(), 'Author: Yehuda');

integration-testing/webpack-test/src/handlebars-require-vs-import-test.js

@@ -0,0 +1,10 @@
+import * as HandlebarsViaImport from 'handlebars';
+const HandlebarsViaRequire = require('handlebars');
+import {assertEquals} from './lib/assert';
+
+HandlebarsViaImport.registerHelper('loud', function(text) {
+    return text.toUpperCase();
+});
+
+const template = HandlebarsViaRequire.compile('Author: {{loud author}}');
+assertEquals(template({author: 'Yehuda'}), 'Author: YEHUDA');

integration-testing/webpack-test/src/handlebars-wildcard-import-pre-4.2-test.js

@@ -0,0 +1,6 @@
+import * as Handlebars from 'handlebars/dist/handlebars';
+
+import {assertEquals} from './lib/assert';
+
+const template = Handlebars.compile('Author: {{author}}');
+assertEquals(template({author: 'Yehuda'}), 'Author: Yehuda');

integration-testing/webpack-test/src/handlebars-wildcard-import-test.js

@@ -0,0 +1,5 @@
+import * as Handlebars from 'handlebars';
+import {assertEquals} from './lib/assert';
+
+const template = Handlebars.compile('Author: {{author}}');
+assertEquals(template({author: 'Yehuda'}), 'Author: Yehuda');

integration-testing/webpack-test/src/lib/assert.js

@@ -0,0 +1,5 @@
+export function assertEquals(actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Expected "${actual}" to equal "${expected}"`);
+    }
+}

integration-testing/webpack-test/src/test-template.handlebars

@@ -0,0 +1,2 @@
+Author: {{author}}
+

integration-testing/webpack-test/test.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+set -e
+
+# Cleanup: package-lock and "npm ci" is not working with local dependencies
+rm dist package-lock.json -rf
+npm install
+npm run build
+
+for i in dist/*-test.js ; do
+  echo "----------------------"
+  echo "-- Running $i"
+  echo "----------------------"
+  node "$i"
+  echo "Success"
+done

integration-testing/webpack-test/webpack.config.js

@@ -0,0 +1,22 @@
+const fs = require('fs');
+
+const testFiles = fs.readdirSync('src');
+const entryPoints = {};
+testFiles
+    .filter(file => file.match(/-test.js$/))
+    .forEach(file => {
+        entryPoints[file] = `./src/${file}`;
+    });
+
+module.exports = {
+    entry: entryPoints,
+    output: {
+        filename: '[name]',
+        path: __dirname + '/dist'
+    },
+    module: {
+        rules: [
+            {test: /\.handlebars$/, loader: 'handlebars-loader'}
+        ]
+    }
+};

lib/handlebars.js

@@ -2,7 +2,7 @@ import runtime from './handlebars.runtime';
 
 // Compiler imports
 import AST from './handlebars/compiler/ast';
-import { parser as Parser, parse } from './handlebars/compiler/base';
+import { parser as Parser, parse, parseWithoutProcessing } from './handlebars/compiler/base';
 import { Compiler, compile, precompile } from './handlebars/compiler/compiler';
 import JavaScriptCompiler from './handlebars/compiler/javascript-compiler';
 import Visitor from './handlebars/compiler/visitor';
@@ -25,6 +25,7 @@ function create() {
   hb.JavaScriptCompiler = JavaScriptCompiler;
   hb.Parser = Parser;
   hb.parse = parse;
+  hb.parseWithoutProcessing = parseWithoutProcessing;
 
   return hb;
 }

lib/handlebars/base.js

@@ -4,8 +4,9 @@ import {registerDefaultHelpers} from './helpers';
 import {registerDefaultDecorators} from './decorators';
 import logger from './logger';
 
-export const VERSION = '4.1.2-0';
-export const COMPILER_REVISION = 7;
+export const VERSION = '4.5.0';
+export const COMPILER_REVISION = 8;
+export const LAST_COMPATIBLE_COMPILER_REVISION = 7;
 
 export const REVISION_CHANGES = {
   1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
@@ -14,7 +15,8 @@ export const REVISION_CHANGES = {
   4: '== 1.x.x',
   5: '== 2.0.0-alpha.x',
   6: '>= 2.0.0-beta.1',
-  7: '>= 4.0.0'
+  7: '>= 4.0.0 <4.3.0',
+  8: '>= 4.3.0'
 };
 
 const objectType = '[object Object]';

lib/handlebars/compiler/base.js

@@ -8,7 +8,7 @@ export { parser };
 let yy = {};
 extend(yy, Helpers);
 
-export function parse(input, options) {
+export function parseWithoutProcessing(input, options) {
   // Just return if an already-compiled AST was passed in.
   if (input.type === 'Program') { return input; }
 
@@ -19,6 +19,14 @@ export function parse(input, options) {
     return new yy.SourceLocation(options && options.srcName, locInfo);
   };
 
-  let strip = new WhitespaceControl(options);
-  return strip.accept(parser.parse(input));
+  let ast = parser.parse(input);
+
+  return ast;
+}
+
+export function parse(input, options) {
+  let ast = parseWithoutProcessing(input, options);
+  let strip = new WhitespaceControl(options);
+
+  return strip.accept(ast);
 }

lib/handlebars/compiler/javascript-compiler.js

@@ -13,13 +13,19 @@ JavaScriptCompiler.prototype = {
   // PUBLIC API: You can override these methods in a subclass to provide
   // alternative compiled forms for name lookup and buffering semantics
   nameLookup: function(parent, name/* , type*/) {
+    const isEnumerable = [ this.aliasable('container.propertyIsEnumerable'), '.call(', parent, ',"constructor")'];
+
     if (name === 'constructor') {
-      return ['(', parent, '.propertyIsEnumerable(\'constructor\') ? ', parent, '.constructor : undefined', ')'];
+      return ['(', isEnumerable, '?', _actualLookup(), ' : undefined)'];
     }
-    if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
-      return [parent, '.', name];
-    } else {
-      return [parent, '[', JSON.stringify(name), ']'];
+    return _actualLookup();
+
+    function _actualLookup() {
+      if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
+        return [parent, '.', name];
+      } else {
+        return [parent, '[', JSON.stringify(name), ']'];
+      }
     }
   },
   depthedLookup: function(name) {
@@ -214,7 +220,6 @@ JavaScriptCompiler.prototype = {
     let aliasCount = 0;
     for (let alias in this.aliases) { // eslint-disable-line guard-for-in
       let node = this.aliases[alias];
-
       if (this.aliases.hasOwnProperty(alias) && node.children && node.referenceCount > 1) {
         varDeclarations += ', alias' + (++aliasCount) + '=' + alias;
         node.children[0] = 'alias' + aliasCount;
@@ -311,7 +316,7 @@ JavaScriptCompiler.prototype = {
   // replace it on the stack with the result of properly
   // invoking blockHelperMissing.
   blockValue: function(name) {
-    let blockHelperMissing = this.aliasable('helpers.blockHelperMissing'),
+    let blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'),
         params = [this.contextName(0)];
     this.setupHelperArgs(name, 0, params);
 
@@ -329,7 +334,7 @@ JavaScriptCompiler.prototype = {
   // On stack, after, if lastHelper: value
   ambiguousBlockValue: function() {
     // We're being a bit cheeky and reusing the options value from the prior exec
-    let blockHelperMissing = this.aliasable('helpers.blockHelperMissing'),
+    let blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'),
         params = [this.contextName(0)];
     this.setupHelperArgs('', 0, params, true);
 
@@ -339,9 +344,9 @@ JavaScriptCompiler.prototype = {
     params.splice(1, 0, current);
 
     this.pushSource([
-        'if (!', this.lastHelper, ') { ',
-          current, ' = ', this.source.functionCall(blockHelperMissing, 'call', params),
-        '}']);
+      'if (!', this.lastHelper, ') { ',
+      current, ' = ', this.source.functionCall(blockHelperMissing, 'call', params),
+      '}']);
   },
 
   // [appendContent]
@@ -538,7 +543,7 @@ JavaScriptCompiler.prototype = {
     if (this.hash) {
       this.hashes.push(this.hash);
     }
-    this.hash = {values: [], types: [], contexts: [], ids: []};
+    this.hash = {values: {}, types: [], contexts: [], ids: []};
   },
   popHash: function() {
     let hash = this.hash;
@@ -622,18 +627,32 @@ JavaScriptCompiler.prototype = {
   // If the helper is not found, `helperMissing` is called.
   invokeHelper: function(paramSize, name, isSimple) {
     let nonHelper = this.popStack(),
-        helper = this.setupHelper(paramSize, name),
-        simple = isSimple ? [helper.name, ' || '] : '';
+        helper = this.setupHelper(paramSize, name);
 
-    let lookup = ['('].concat(simple, nonHelper);
-    if (!this.options.strict) {
-      lookup.push(' || ', this.aliasable('helpers.helperMissing'));
+    let possibleFunctionCalls = [];
+
+    if (isSimple) { // direct call to helper
+      possibleFunctionCalls.push(helper.name);
+    }
+    // call a function from the input object
+    possibleFunctionCalls.push(nonHelper);
+    if (!this.options.strict) {
+      possibleFunctionCalls.push(this.aliasable('container.hooks.helperMissing'));
     }
-    lookup.push(')');
 
-    this.push(this.source.functionCall(lookup, 'call', helper.callParams));
+    let functionLookupCode = ['(', this.itemsSeparatedBy(possibleFunctionCalls, '||'), ')'];
+    let functionCall = this.source.functionCall(functionLookupCode, 'call', helper.callParams);
+    this.push(functionCall);
   },
 
+  itemsSeparatedBy: function(items, separator) {
+    let result = [];
+    result.push(items[0]);
+    for (let i = 1; i < items.length; i++) {
+      result.push(separator, items[i]);
+    }
+    return result;
+  },
   // [invokeKnownHelper]
   //
   // On stack, before: hash, inverse, program, params..., ...
@@ -672,16 +691,16 @@ JavaScriptCompiler.prototype = {
     if (!this.options.strict) {
       lookup[0] = '(helper = ';
       lookup.push(
-        ' != null ? helper : ',
-        this.aliasable('helpers.helperMissing')
+          ' != null ? helper : ',
+          this.aliasable('container.hooks.helperMissing')
       );
     }
 
     this.push([
-        '(', lookup,
-        (helper.paramsInit ? ['),(', helper.paramsInit] : []), '),',
-        '(typeof helper === ', this.aliasable('"function"'), ' ? ',
-        this.source.functionCall('helper', 'call', helper.callParams), ' : helper))'
+      '(', lookup,
+      (helper.paramsInit ? ['),(', helper.paramsInit] : []), '),',
+      '(typeof helper === ', this.aliasable('"function"'), ' ? ',
+      this.source.functionCall('helper', 'call', helper.callParams), ' : helper))'
     ]);
   },
 
@@ -1072,6 +1091,7 @@ JavaScriptCompiler.prototype = {
 
   setupHelperArgs: function(helper, paramSize, params, useRegister) {
     let options = this.setupParams(helper, paramSize, params);
+    options.loc = JSON.stringify(this.source.currentLocation);
     options = this.objectLiteral(options);
     if (useRegister) {
       this.useRegister('options');
@@ -1131,7 +1151,7 @@ function strictLookup(requireTerminal, compiler, parts, type) {
   }
 
   if (requireTerminal) {
-    return [compiler.aliasable('container.strict'), '(', stack, ', ', compiler.quotedString(parts[i]), ')'];
+    return [compiler.aliasable('container.strict'), '(', stack, ', ', compiler.quotedString(parts[i]), ', ', JSON.stringify(compiler.source.currentLocation), ' )'];
   } else {
     return stack;
   }

lib/handlebars/compiler/whitespace-control.js

@@ -206,7 +206,7 @@ function omitLeft(body, i, multiple) {
     return;
   }
 
-  // We omit the last node if it's whitespace only and not preceeded by a non-content node.
+  // 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]+$/), '');
   current.leftStripped = current.value !== original;

lib/handlebars/exception.js

@@ -1,13 +1,18 @@
 
-const errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+const errorProps = ['description', 'fileName', 'lineNumber', 'endLineNumber', 'message', 'name', 'number', 'stack'];
 
 function Exception(message, node) {
   let loc = node && node.loc,
       line,
-      column;
+      endLineNumber,
+      column,
+      endColumn;
+
   if (loc) {
     line = loc.start.line;
+    endLineNumber = loc.end.line;
     column = loc.start.column;
+    endColumn = loc.end.column;
 
     message += ' - ' + line + ':' + column;
   }
@@ -27,6 +32,7 @@ function Exception(message, node) {
   try {
     if (loc) {
       this.lineNumber = line;
+      this.endLineNumber = endLineNumber;
 
       // Work around issue under safari where we can't directly set the column value
       /* istanbul ignore next */
@@ -35,8 +41,13 @@ function Exception(message, node) {
           value: column,
           enumerable: true
         });
+        Object.defineProperty(this, 'endColumn', {
+          value: endColumn,
+          enumerable: true
+        });
       } else {
         this.column = column;
+        this.endColumn = endColumn;
       }
     }
   } catch (nop) {

lib/handlebars/helpers.js

@@ -15,3 +15,12 @@ export function registerDefaultHelpers(instance) {
   registerLookup(instance);
   registerWith(instance);
 }
+
+export function moveHelperToHooks(instance, helperName, keepHelper) {
+  if (instance.helpers[helperName]) {
+    instance.hooks[helperName] = instance.helpers[helperName];
+    if (!keepHelper) {
+      delete instance.helpers[helperName];
+    }
+  }
+}

lib/handlebars/helpers/each.js

@@ -49,6 +49,16 @@ export default function(instance) {
             execIteration(i, i, i === context.length - 1);
           }
         }
+      } else if (global.Symbol && context[global.Symbol.iterator]) {
+        const newContext = [];
+        const iterator = context[global.Symbol.iterator]();
+        for (let it = iterator.next(); !it.done; it = iterator.next()) {
+          newContext.push(it.value);
+        }
+        context = newContext;
+        for (let j = context.length; i < j; i++) {
+          execIteration(i, i, i === context.length - 1);
+        }
       } else {
         let priorKey;
 

lib/handlebars/helpers/if.js

@@ -1,7 +1,9 @@
-import {isEmpty, isFunction} from '../utils';
+import { isEmpty, isFunction } from '../utils';
+import Exception from '../exception';
 
 export default function(instance) {
   instance.registerHelper('if', function(conditional, options) {
+    if (arguments.length != 2) { throw new Exception('#if requires exactly one argument');}
     if (isFunction(conditional)) { conditional = conditional.call(this); }
 
     // Default behavior is to render the positive path if the value is truthy and not empty.
@@ -15,6 +17,7 @@ export default function(instance) {
   });
 
   instance.registerHelper('unless', function(conditional, options) {
+    if (arguments.length != 2) { throw new Exception('#unless requires exactly one argument');}
     return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});
   });
 }

lib/handlebars/helpers/with.js

@@ -1,7 +1,9 @@
-import {appendContextPath, blockParams, createFrame, isEmpty, isFunction} from '../utils';
+import { appendContextPath, blockParams, createFrame, isEmpty, isFunction } from '../utils';
+import Exception from '../exception';
 
 export default function(instance) {
   instance.registerHelper('with', function(context, options) {
+    if (arguments.length != 2) { throw new Exception('#with requires exactly one argument');}
     if (isFunction(context)) { context = context.call(this); }
 
     let fn = options.fn;

lib/handlebars/runtime.js

@@ -1,26 +1,30 @@
 import * as Utils from './utils';
 import Exception from './exception';
-import { COMPILER_REVISION, REVISION_CHANGES, createFrame } from './base';
+import {COMPILER_REVISION, createFrame, LAST_COMPATIBLE_COMPILER_REVISION, REVISION_CHANGES} from './base';
+import {moveHelperToHooks} from './helpers';
 
 export function checkRevision(compilerInfo) {
   const compilerRevision = compilerInfo && compilerInfo[0] || 1,
         currentRevision = COMPILER_REVISION;
 
-  if (compilerRevision !== currentRevision) {
-    if (compilerRevision < currentRevision) {
-      const runtimeVersions = REVISION_CHANGES[currentRevision],
-            compilerVersions = REVISION_CHANGES[compilerRevision];
-      throw new Exception('Template was precompiled with an older version of Handlebars than the current runtime. ' +
-            'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');
-    } else {
-      // Use the embedded version info since the runtime doesn't know about this revision yet
-      throw new Exception('Template was precompiled with a newer version of Handlebars than the current runtime. ' +
-            'Please update your runtime to a newer version (' + compilerInfo[1] + ').');
-    }
+  if (compilerRevision >= LAST_COMPATIBLE_COMPILER_REVISION && compilerRevision <= COMPILER_REVISION) {
+    return;
+  }
+
+  if (compilerRevision < LAST_COMPATIBLE_COMPILER_REVISION) {
+    const runtimeVersions = REVISION_CHANGES[currentRevision],
+          compilerVersions = REVISION_CHANGES[compilerRevision];
+    throw new Exception('Template was precompiled with an older version of Handlebars than the current runtime. ' +
+          'Please update your precompiler to a newer version (' + runtimeVersions + ') or downgrade your runtime to an older version (' + compilerVersions + ').');
+  } else {
+    // Use the embedded version info since the runtime doesn't know about this revision yet
+    throw new Exception('Template was precompiled with a newer version of Handlebars than the current runtime. ' +
+          'Please update your runtime to a newer version (' + compilerInfo[1] + ').');
   }
 }
 
 export function template(templateSpec, env) {
+
   /* istanbul ignore next */
   if (!env) {
     throw new Exception('No environment passed to template');
@@ -32,9 +36,12 @@ export function template(templateSpec, env) {
   templateSpec.main.decorator = templateSpec.main_d;
 
   // Note: Using env.VM references rather than local var references throughout this section to allow
-  // for external users to override these as psuedo-supported APIs.
+  // for external users to override these as pseudo-supported APIs.
   env.VM.checkRevision(templateSpec.compiler);
 
+  // backwards compatibility for precompiled templates with compiler-version 7 (<4.3.0)
+  const templateWasPrecompiledWithCompilerV7 = templateSpec.compiler && templateSpec.compiler[0] === 7;
+
   function invokePartialWrapper(partial, context, options) {
     if (options.hash) {
       context = Utils.extend({}, context, options.hash);
@@ -42,13 +49,15 @@ export function template(templateSpec, env) {
         options.ids[0] = true;
       }
     }
-
     partial = env.VM.resolvePartial.call(this, partial, context, options);
-    let result = env.VM.invokePartial.call(this, partial, context, options);
+
+    let optionsWithHooks = Utils.extend({}, options, {hooks: this.hooks});
+
+    let result = env.VM.invokePartial.call(this, partial, context, optionsWithHooks);
 
     if (result == null && env.compile) {
       options.partials[options.name] = env.compile(partial, templateSpec.compilerOptions, env);
-      result = options.partials[options.name](context, options);
+      result = options.partials[options.name](context, optionsWithHooks);
     }
     if (result != null) {
       if (options.indent) {
@@ -70,9 +79,9 @@ export function template(templateSpec, env) {
 
   // Just add water
   let container = {
-    strict: function(obj, name) {
-      if (!(name in obj)) {
-        throw new Exception('"' + name + '" not defined in ' + obj);
+    strict: function(obj, name, loc) {
+      if (!obj || !(name in obj)) {
+        throw new Exception('"' + name + '" not defined in ' + obj, { loc: loc });
       }
       return obj[name];
     },
@@ -115,15 +124,6 @@ export function template(templateSpec, env) {
       }
       return value;
     },
-    merge: function(param, common) {
-      let obj = param || common;
-
-      if (param && common && (param !== common)) {
-        obj = Utils.extend({}, common, param);
-      }
-
-      return obj;
-    },
     // An empty object to use as replacement for null-contexts
     nullContext: Object.seal({}),
 
@@ -158,19 +158,28 @@ export function template(templateSpec, env) {
 
   ret._setup = function(options) {
     if (!options.partial) {
-      container.helpers = container.merge(options.helpers, env.helpers);
+      container.helpers = Utils.extend({}, env.helpers, options.helpers);
 
       if (templateSpec.usePartial) {
-        container.partials = container.merge(options.partials, env.partials);
+        container.partials = Utils.extend({}, env.partials, options.partials);
       }
       if (templateSpec.usePartial || templateSpec.useDecorators) {
-        container.decorators = container.merge(options.decorators, env.decorators);
+        container.decorators = Utils.extend({}, env.decorators, options.decorators);
       }
+
+      container.hooks = {};
+
+      let keepHelperInHelpers = options.allowCallsToHelperMissing || templateWasPrecompiledWithCompilerV7;
+      moveHelperToHooks(container, 'helperMissing', keepHelperInHelpers);
+      moveHelperToHooks(container, 'blockHelperMissing', keepHelperInHelpers);
+
     } else {
       container.helpers = options.helpers;
       container.partials = options.partials;
       container.decorators = options.decorators;
+      container.hooks = options.hooks;
     }
+
   };
 
   ret._child = function(i, data, blockParams, depths) {
@@ -209,6 +218,9 @@ export function wrapProgram(container, i, fn, data, declaredBlockParams, blockPa
   return prog;
 }
 
+/**
+ * This is currently part of the official API, therefore implementation details should not be changed.
+ */
 export function resolvePartial(partial, context, options) {
   if (!partial) {
     if (options.name === '@partial-block') {

lib/handlebars/utils.js

@@ -1,3 +1,4 @@
+
 const escape = {
   '&': '&',
   '<': '&lt;',

multi-nodejs-test/.eslintrc.js

@@ -1,114 +0,0 @@
-module.exports = {
-  "extends": "eslint:recommended",
-  "globals": {
-    "self": false
-  },
-  "env": {
-    "node": true
-  },
-  "rules": {
-    // overrides eslint:recommended defaults
-    "no-sparse-arrays": "off",
-    "no-func-assign": "off",
-    "no-console": "off",
-    "no-debugger": "warn",
-    "no-unreachable": "warn",
-
-    // Possible Errors //
-    //-----------------//
-    "no-unsafe-negation": "error",
-
-
-    // Best Practices //
-    //----------------//
-    "curly": "error",
-    "default-case": "warn",
-    "dot-notation": ["error", { "allowKeywords": false }],
-    "guard-for-in": "warn",
-    "no-alert": "error",
-    "no-caller": "error",
-    "no-div-regex": "warn",
-    "no-eval": "error",
-    "no-extend-native": "error",
-    "no-extra-bind": "error",
-    "no-floating-decimal": "error",
-    "no-implied-eval": "error",
-    "no-iterator": "error",
-    "no-labels": "error",
-    "no-lone-blocks": "error",
-    "no-loop-func": "error",
-    "no-multi-spaces": "error",
-    "no-multi-str": "warn",
-    "no-global-assign": "error",
-    "no-new": "error",
-    "no-new-func": "error",
-    "no-new-wrappers": "error",
-    "no-octal-escape": "error",
-    "no-process-env": "error",
-    "no-proto": "error",
-    "no-return-assign": "error",
-    "no-script-url": "error",
-    "no-self-compare": "error",
-    "no-sequences": "error",
-    "no-throw-literal": "error",
-    "no-unused-expressions": "error",
-    "no-warning-comments": "warn",
-    "no-with": "error",
-    "radix": "error",
-    "wrap-iife": "error",
-
-
-    // Variables //
-    //-----------//
-    "no-catch-shadow": "error",
-    "no-label-var": "error",
-    "no-shadow-restricted-names": "error",
-    "no-undef-init": "error",
-    "no-use-before-define": ["error", "nofunc"],
-
-
-    // Stylistic Issues //
-    //------------------//
-    "comma-dangle": ["error", "never"],
-    "quote-props": ["error", "as-needed", { "keywords": true, "unnecessary": false }],
-    "brace-style": ["error", "1tbs", { "allowSingleLine": true }],
-    "camelcase": "error",
-    "comma-spacing": ["error", { "before": false, "after": true }],
-    "comma-style": ["error", "last"],
-    "consistent-this": ["warn", "self"],
-    "eol-last": "error",
-    "func-style": ["error", "declaration"],
-    "key-spacing": ["error", {
-      "beforeColon": false,
-      "afterColon": true
-    }],
-    "new-cap": "error",
-    "new-parens": "error",
-    "no-array-constructor": "error",
-    "no-lonely-if": "error",
-    "no-mixed-spaces-and-tabs": "error",
-    "no-nested-ternary": "warn",
-    "no-new-object": "error",
-    "no-spaced-func": "error",
-    "no-trailing-spaces": "error",
-    "no-extra-parens": ["error", "functions"],
-    "quotes": ["error", "single", "avoid-escape"],
-    "semi": "error",
-    "semi-spacing": ["error", { "before": false, "after": true }],
-    "keyword-spacing": "error",
-    "space-before-blocks": ["error", "always"],
-    "space-before-function-paren": ["error", { "anonymous": "never", "named": "never" }],
-    "space-in-parens": ["error", "never"],
-    "space-infix-ops": "error",
-    "space-unary-ops": "error",
-    "spaced-comment": ["error", "always", { "markers": [","] }],
-    "wrap-regex": "warn",
-
-    // ECMAScript 6 //
-    //--------------//
-    "no-var": "off"
-  },
-  "parserOptions": {
-    "sourceType": "module"
-  }
-}

multi-nodejs-test/expected.txt

@@ -1 +0,0 @@
-Author: Yehuda

multi-nodejs-test/run-handlebars.js

@@ -1,13 +0,0 @@
-// This test should run with node 0.10 as long as Handlebars has been compiled before
-var Handlebars = require('../');
-var fs = require('fs');
-
-console.log('Testing build Handlebars with Node version ' + process.version);
-var template = fs.readFileSync(require.resolve('./template.txt.hbs'), 'utf-8');
-var compiledOutput = Handlebars.compile(template)({author: 'Yehuda'}).trim();
-var expectedOutput = fs.readFileSync(require.resolve('./expected.txt'), 'utf-8').trim();
-
-if (compiledOutput !== expectedOutput) {
-    throw new Error('Compiled output (' + compiledOutput + ') did not match expected output (' + expectedOutput + ')');
-}
-console.log('Success');

multi-nodejs-test/template.txt.hbs

@@ -1 +0,0 @@
-Author: {{author}} 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "handlebars",
   "barename": "handlebars",
-  "version": "4.1.2-0",
+  "version": "4.5.0",
   "description": "Handlebars provides the power necessary to let you build semantic templates effectively with no frustration",
   "homepage": "http://www.handlebarsjs.com/",
   "keywords": [
@@ -21,6 +21,7 @@
     "node": ">=0.4.7"
   },
   "dependencies": {
+    "eslint-plugin-compat": "^3.3.0",
     "neo-async": "^2.6.0",
     "optimist": "^0.6.1",
     "source-map": "^0.6.1"
@@ -29,6 +30,7 @@
     "uglify-js": "^3.1.4"
   },
   "devDependencies": {
+    "@knappi/grunt-saucelabs": "^9.0.2",
     "aws-sdk": "^2.1.49",
     "babel-loader": "^5.0.0",
     "babel-runtime": "^5.1.10",
@@ -36,6 +38,7 @@
     "dtslint": "^0.5.5",
     "dustjs-linkedin": "^2.0.2",
     "eco": "~1.1.0-rc-3",
+    "eslint-plugin-es5": "^1.4.1",
     "grunt": "^1.0.3",
     "grunt-babel": "^5.0.0",
     "grunt-bg-shell": "^2.3.3",
@@ -48,7 +51,6 @@
     "grunt-contrib-uglify": "^1",
     "grunt-contrib-watch": "^1.1.0",
     "grunt-eslint": "^20.1.0",
-    "grunt-saucelabs": "9.x",
     "grunt-webpack": "^1.0.8",
     "istanbul": "^0.3.0",
     "jison": "~0.3.0",
@@ -64,8 +66,8 @@
   "main": "lib/index.js",
   "types": "types/index.d.ts",
   "browser": {
-    ".": "./dist/handlebars.min.js",
-    "./runtime": "./dist/handlebars.runtime.min.js"
+    ".": "./dist/cjs/handlebars.js",
+    "./runtime": "./dist/cjs/handlebars.runtime.js"
   },
   "bin": {
     "handlebars": "bin/handlebars"

release-notes.md

@@ -2,7 +2,175 @@
 
 ## Development
 
-[Commits](https://github.com/wycats/handlebars.js/compare/v4.1.2-0...master)
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.5.0...master)
+
+## v4.5.0 - October 28th, 2019
+Features / Improvements
+- Add method Handlebars.parseWithoutProcessing (#1584) - 62ed3c2
+- add guard to if & unless helpers (#1549)
+- show source location for the strict lookup exceptions - feb60f8
+
+Bugfixes:
+- Use objects for hash value tracking - 7fcf9d2
+
+Chore:
+- Resolve deprecation warning message from eslint while running eslint (#1586) - 7052e88
+- chore: add eslint-plugin-compat and eslint-plugin-es5 - 088e618
+
+Compatibility notes:
+- No compatibility issues are to be expected
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.4.5...v4.5.0)
+
+## v4.4.5 - October 20th, 2019
+Bugfixes: 
+
+- Contents of raw-blocks must be matched with non-eager regex-matching - 8d5530e, #1579
+
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.4.4...v4.4.5)
+
+## v4.4.4 - October 20th, 2019
+Bugfixes:
+- fix: prevent zero length tokens in raw-blocks (#1577, #1578) - f1752fe
+
+Chore: 
+- chore: link to s3 bucket with https, add "npm ci" to build instructions - 0b593bf
+
+Compatibility notes:
+- no compatibility issues are expected
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.4.3...v4.4.4)
+
+## v4.4.3 - October 8th, 2019
+Bugfixes
+
+Typings:
+- add missing type fields to AST typings and add tests for them - 0440af2
+
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.4.2...v4.4.3)
+
+## v4.4.2 - October 2nd, 2019
+- chore: fix grunt-saucelabs dependency - b7eada0
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.4.1...v4.4.2)
+
+## v4.4.1 - October 2nd, 2019
+- [#1562](https://github.com/wycats/handlebars.js/issues/1562) - Error message for syntax error missing location in 4.2.1+
+
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.4.0...v4.4.1)
+
+## v4.4.0 - September 29th, 2019
+- Added support for iterable objects in {{#each}} helper (#1557) - cf7545e
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.3.4...v4.4.0)
+
+## v4.3.4 - September 28th, 2019
+- fix: harden "propertyIsEnumerable"-check - ff4d827
+
+Compatibility notes:
+- No incompatibilities are known.
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.3.3...v4.3.4)
+
+## v4.3.3 - September 27th, 2019
+ - fix test case for browsers that do not support __defineGetter__ - 8742bde
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.3.2...v4.3.3)
+
+## v4.3.2 - September 26th, 2019
+- Use Object.prototype.propertyIsEnumerable to check for constructors - 213c0bb, #1563
+
+Compatibility notes:
+- There are no breaking changes
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.3.1...v4.3.2)
+
+## v4.3.1 - September 25th, 2019
+Fixes:
+
+- do not break on precompiled templates from Handlebars >=4.0.0 <4.3.0 - 1266838, #1561
+- Ensure allowCallsToHelperMissing runtime option is optional in typings - 93444c5, 64ecb9e, #1560
+
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.3.0...v4.3.1)
+
+## v4.3.0 - September 24th, 2019
+Fixes:
+
+- Security: Disallow calling "helperMissing" and "blockHelperMissing" directly - 2078c72
+- Disallow calling "helperMissing" and "blockHelperMissing" directly - 2078c72
+
+Features:
+
+- Add new runtime option `allowCallsToHelperMissing` to allow calling `blockHelperMissing` and `helperMissing`.
+
+Breaking changes:
+
+Compatibility notes:
+- Compiler revision increased - 06b7224
+  - This means that template compiled with versions prior to 4.3.0 will not work with runtimes >= 4.3.0
+    The increase was done because the "helperMissing" and "blockHelperMissing" are now moved from the helpers
+    to the internal "container.hooks" object, so old templates will not be able to call them anymore. We suggest
+    that you always recompile your templates with the latest compiler in your build pipelines.
+
+- Disallow calling "helperMissing" and "blockHelperMissing" directly - 2078c72
+  - Calling "helperMissing" and "blockHelperMissing" directly from a template (like in `{{blockHelperMissing}}` was 
+    never intended and was part of the exploits that have been revealed early in 2019 
+    (see https://github.com/wycats/handlebars.js/issues/1495). *It is also part of a new exploit that 
+    is not captured by the earlier fix.* In order to harden Handlebars against such exploits, calling thos helpers 
+    is now not possible anymore. *Overriding* those helpers is still possible.
+  - If you really need this behavior, you can set the runtime option `allowCallsToHelperMissing` to `true` and the
+    calls will again be possible
+
+Both bullet points imly that Handlebars is not 100% percent compatible to 4.2.0, despite the minor version bump.
+
+We consider it more important to resolve a major security issue than to maintain 100% compatibility.
+
+    
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.2.1...v4.3.0)
+
+## v4.2.1 - September 20th, 2019
+Bugfixes: 
+
+- The "browser" property in the package.json has been updated to use the common-js builds instead of the minified UMD - c55a7be, #1553
+
+Compatibility notes:
+- No compatibility issues should arise
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.2.0...v4.2.1)
+
+## v4.2.0 - September 3rd, 2019
+Chore/Test:
+- Use custom `grunt-saucelab` with current sauce-connect proxy - f119497
+- Add framework for various integration tests - f9cce4d
+- Add integration test for webpack - a57b682
+
+
+Bugfixes:
+- [#1544](https://github.com/wycats/handlebars.js/issues/1544) - Typescript types: `knownHelpers` doesnt allow for custom helpers ([@NickCis](https://api.github.com/users/NickCis))
+- [#1534](https://github.com/wycats/handlebars.js/pull/1534) - Add typings for "Handlebars.VM.resolvePartial ([@AndrewLeedham](https://api.github.com/users/AndrewLeedham))
+
+Features:
+- [#1540](https://github.com/wycats/handlebars.js/pull/1540) - added "browser"-property to package.json, resolves #1102 ([@ouijan](https://api.github.com/users/ouijan))
+
+Compatibility notes:
+- The new "browser"-property should not break anything, but you can never be sure. The integration test for webpack 
+  shows that it works, but if it doesn't please open an issue.
+
+
+
+[Commits](https://github.com/wycats/handlebars.js/compare/v4.1.2-0...v4.2.0)
 
 ## v4.1.2-0 - August 25th, 2019
 [#1540](https://github.com/wycats/handlebars.js/pull/1540) - added browser to package.json, resolves #1102 ([@ouijan](https://api.github.com/users/ouijan))
@@ -384,7 +552,7 @@ Compatibility notes:
 - Lines containing only block statements and whitespace are now removed. This matches the Mustache spec but may cause issues with code that expects whitespace to exist but would not otherwise.
 - Partials that are standalone will now indent their rendered content
 - `AST.ProgramNode`'s signature has changed. 
-- Numerious methods/features removed from psuedo-API classes
+- Numerious methods/features removed from pseudo-API classes
   - `JavaScriptCompiler.register`
   - `JavaScriptCompiler.replaceStack` no longer supports non-inline replace
   - `Compiler.disassemble`
@@ -575,7 +743,7 @@ Compatibility notes:
 ## v1.0.11 / 1.0.0-rc4 - May 13 2013
 
 - [#458](https://github.com/wycats/handlebars.js/issues/458) - Fix `./foo` syntax ([@jpfiset](https://github.com/jpfiset))
-- [#460](https://github.com/wycats/handlebars.js/issues/460) - Allow `:` in unescaped identifers ([@jpfiset](https://github.com/jpfiset))
+- [#460](https://github.com/wycats/handlebars.js/issues/460) - Allow `:` in unescaped identifiers ([@jpfiset](https://github.com/jpfiset))
 - [#471](https://github.com/wycats/handlebars.js/issues/471) - Create release notes (These!)
 - [#456](https://github.com/wycats/handlebars.js/issues/456) - Allow escaping of `\\`
 - [#211](https://github.com/wycats/handlebars.js/issues/211) - Fix exception in `escapeExpression`

spec/.eslintrc

@@ -1,14 +1,19 @@
 {
+  "extends": [
+    "../.eslintrc.js",
+    "plugin:es5/no-es2015"
+  ],
+  "plugins": [
+    "es5"
+  ],
   "globals": {
     "CompilerContext": true,
     "Handlebars": true,
     "handlebarsEnv": true,
-
     "shouldCompileTo": true,
     "shouldCompileToWithPartials": true,
     "shouldThrow": true,
     "compileWithPartials": true,
-
     "console": true,
     "require": true,
     "suite": true,

spec/ast.js

@@ -123,6 +123,40 @@ describe('ast', function() {
      });
   });
 
+  describe('whitespace control', function() {
+    describe('parse', function() {
+      it('mustache', function() {
+        var ast = Handlebars.parse('  {{~comment~}} ');
+
+        equals(ast.body[0].value, '');
+        equals(ast.body[2].value, '');
+      });
+
+      it('block statements', function() {
+        var ast = Handlebars.parse(' {{# comment~}} \nfoo\n {{~/comment}}');
+
+        equals(ast.body[0].value, '');
+        equals(ast.body[1].program.body[0].value, 'foo');
+      });
+    });
+
+    describe('parseWithoutProcessing', function() {
+      it('mustache', function() {
+        var ast = Handlebars.parseWithoutProcessing('  {{~comment~}} ');
+
+        equals(ast.body[0].value, '  ');
+        equals(ast.body[2].value, ' ');
+      });
+
+      it('block statements', function() {
+        var ast = Handlebars.parseWithoutProcessing(' {{# comment~}} \nfoo\n {{~/comment}}');
+
+        equals(ast.body[0].value, ' ');
+        equals(ast.body[1].program.body[0].value, ' \nfoo\n ');
+      });
+    });
+  });
+
   describe('standalone flags', function() {
     describe('mustache', function() {
       it('does not mark mustaches as standalone', function() {
@@ -131,6 +165,54 @@ describe('ast', function() {
         equals(!!ast.body[2].value, true);
       });
     });
+    describe('blocks - parseWithoutProcessing', function() {
+      it('block mustaches', function() {
+        var ast = Handlebars.parseWithoutProcessing(' {{# comment}} \nfoo\n {{else}} \n  bar \n  {{/comment}} '),
+          block = ast.body[1];
+
+        equals(ast.body[0].value, ' ');
+
+        equals(block.program.body[0].value, ' \nfoo\n ');
+        equals(block.inverse.body[0].value, ' \n  bar \n  ');
+
+        equals(ast.body[2].value, ' ');
+      });
+      it('initial block mustaches', function() {
+        var ast = Handlebars.parseWithoutProcessing('{{# comment}} \nfoo\n {{/comment}}'),
+          block = ast.body[0];
+
+        equals(block.program.body[0].value, ' \nfoo\n ');
+      });
+      it('mustaches with children', function() {
+        var ast = Handlebars.parseWithoutProcessing('{{# comment}} \n{{foo}}\n {{/comment}}'),
+          block = ast.body[0];
+
+        equals(block.program.body[0].value, ' \n');
+        equals(block.program.body[1].path.original, 'foo');
+        equals(block.program.body[2].value, '\n ');
+      });
+      it('nested block mustaches', function() {
+        var ast = Handlebars.parseWithoutProcessing('{{#foo}} \n{{# comment}} \nfoo\n {{else}} \n  bar \n  {{/comment}} \n{{/foo}}'),
+          body = ast.body[0].program.body,
+          block = body[1];
+
+        equals(body[0].value, ' \n');
+
+        equals(block.program.body[0].value, ' \nfoo\n ');
+        equals(block.inverse.body[0].value, ' \n  bar \n  ');
+      });
+      it('column 0 block mustaches', function() {
+        var ast = Handlebars.parseWithoutProcessing('test\n{{# comment}} \nfoo\n {{else}} \n  bar \n  {{/comment}} '),
+            block = ast.body[1];
+
+        equals(ast.body[0].omit, undefined);
+
+        equals(block.program.body[0].value, ' \nfoo\n ');
+        equals(block.inverse.body[0].value, ' \n  bar \n  ');
+
+        equals(ast.body[2].value, ' ');
+      });
+    });
     describe('blocks', function() {
       it('marks block mustaches as standalone', function() {
         var ast = Handlebars.parse(' {{# comment}} \nfoo\n {{else}} \n  bar \n  {{/comment}} '),
@@ -204,6 +286,18 @@ describe('ast', function() {
         equals(ast.body[2].value, '');
       });
     });
+    describe('partials - parseWithoutProcessing', function() {
+      it('simple partial', function() {
+        var ast = Handlebars.parseWithoutProcessing('{{> partial }} ');
+        equals(ast.body[1].value, ' ');
+      });
+      it('indented partial', function() {
+        var ast = Handlebars.parseWithoutProcessing('  {{> partial }} ');
+        equals(ast.body[0].value, '  ');
+        equals(ast.body[1].indent, '');
+        equals(ast.body[2].value, ' ');
+      });
+    });
     describe('partials', function() {
       it('marks partial as standalone', function() {
         var ast = Handlebars.parse('{{> partial }} ');
@@ -223,6 +317,17 @@ describe('ast', function() {
         equals(ast.body[1].omit, undefined);
       });
     });
+    describe('comments - parseWithoutProcessing', function() {
+      it('simple comment', function() {
+        var ast = Handlebars.parseWithoutProcessing('{{! comment }} ');
+        equals(ast.body[1].value, ' ');
+      });
+      it('indented comment', function() {
+        var ast = Handlebars.parseWithoutProcessing('  {{! comment }} ');
+        equals(ast.body[0].value, '  ');
+        equals(ast.body[2].value, ' ');
+      });
+    });
     describe('comments', function() {
       it('marks comment as standalone', function() {
         var ast = Handlebars.parse('{{! comment }} ');

spec/builtins.js

@@ -254,6 +254,37 @@ describe('builtin helpers', function() {
         template({});
       }, handlebarsEnv.Exception, 'Must pass iterator to #each');
     });
+
+    if (global.Symbol && global.Symbol.iterator) {
+      it('each on iterable', function() {
+        function Iterator(arr) {
+          this.arr = arr;
+          this.index = 0;
+        }
+        Iterator.prototype.next = function() {
+          var value = this.arr[this.index];
+          var done = this.index === this.arr.length;
+          if (!done) {
+            this.index++;
+          }
+          return { value: value, done: done };
+        };
+        function Iterable(arr) {
+          this.arr = arr;
+        }
+        Iterable.prototype[global.Symbol.iterator] = function() {
+          return new Iterator(this.arr);
+        };
+        var string = '{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!';
+        var goodbyes = new Iterable([{text: 'goodbye'}, {text: 'Goodbye'}, {text: 'GOODBYE'}]);
+        var goodbyesEmpty = new Iterable([]);
+        var hash = {goodbyes: goodbyes, world: 'world'};
+        shouldCompileTo(string, hash, 'goodbye! Goodbye! GOODBYE! cruel world!',
+          'each with array argument iterates over the contents when not empty');
+        shouldCompileTo(string, {goodbyes: goodbyesEmpty, world: 'world'}, 'cruel world!',
+          'each with array argument ignores the contents when empty');
+      });
+    }
   });
 
   describe('#log', function() {

spec/env/browser.js

@@ -9,7 +9,7 @@ var filename = 'dist/handlebars.js';
 if (global.minimizedTest) {
   filename = 'dist/handlebars.min.js';
 }
-var distHandlebars = fs.readFileSync(require.resolve(`../../${filename}`), 'utf-8');
+var distHandlebars = fs.readFileSync(require.resolve('../../' + filename), 'utf-8');
 vm.runInThisContext(distHandlebars, filename);
 
 global.CompilerContext = {

spec/expected/empty.amd.js

@@ -1,6 +1,6 @@
 define(['handlebars.runtime'], function(Handlebars) {
   Handlebars = Handlebars["default"];  var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
-return templates['empty'] = template({"compiler":[7,">= 4.0.0"],"main":function(container,depth0,helpers,partials,data) {
+return templates['empty'] = template({"compiler":[8,">= 4.3.0"],"main":function(container,depth0,helpers,partials,data) {
     return "";
 },"useData":true});
 });

spec/helpers.js

@@ -28,14 +28,43 @@ describe('helpers', function() {
                     'raw block helper gets raw content');
   });
 
-  it('helper for nested raw block gets raw content', function() {
-    var string = '{{{{a}}}} {{{{b}}}} {{{{/b}}}} {{{{/a}}}}';
-    var helpers = {
-        a: function(options) {
+  describe('raw block parsing (with identity helper-function)', function() {
+
+    function runWithIdentityHelper(template, expected) {
+      var helpers = {
+        identity: function(options) {
           return options.fn();
-      }
-    };
-    shouldCompileTo(string, [{}, helpers], ' {{{{b}}}} {{{{/b}}}} ', 'raw block helper should get nested raw block as raw content');
+        }
+      };
+      shouldCompileTo(template, [{}, helpers], expected);
+    }
+
+    it('helper for nested raw block gets raw content', function() {
+      runWithIdentityHelper('{{{{identity}}}} {{{{b}}}} {{{{/b}}}} {{{{/identity}}}}', ' {{{{b}}}} {{{{/b}}}} ');
+    });
+
+    it('helper for nested raw block works with empty content', function() {
+      runWithIdentityHelper('{{{{identity}}}}{{{{/identity}}}}', '');
+    });
+
+    xit('helper for nested raw block works if nested raw blocks are broken', function() {
+      // This test was introduced in 4.4.4, but it was not the actual problem that lead to the patch release
+      // The test is deactivated, because in 3.x this template cases an exception and it also does not work in 4.4.3
+      // If anyone can make this template work without breaking everything else, then go for it,
+      // but for now, this is just a known bug, that will be documented.
+      runWithIdentityHelper('{{{{identity}}}} {{{{a}}}} {{{{ {{{{/ }}}} }}}} {{{{/identity}}}}', ' {{{{a}}}} {{{{ {{{{/ }}}} }}}} ');
+    });
+
+    it('helper for nested raw block closes after first matching close', function() {
+      runWithIdentityHelper('{{{{identity}}}}abc{{{{/identity}}}} {{{{identity}}}}abc{{{{/identity}}}}', 'abc abc');
+    });
+
+    it('helper for nested raw block throw exception when with missing closing braces', function() {
+      var string = '{{{{a}}}} {{{{/a';
+      shouldThrow(function() {
+        Handlebars.compile(string)();
+      });
+    });
   });
 
   it('helper block with identical context', function() {
@@ -737,4 +766,70 @@ describe('helpers', function() {
       shouldCompileTo('{{#if bar}}{{else goodbyes as |value|}}{{value}}{{/if}}{{value}}', [hash, helpers], '1foo');
     });
   });
+
+  describe('built-in helpers malformed arguments ', function() {
+    it('if helper - too few arguments', function() {
+      var template = CompilerContext.compile('{{#if}}{{/if}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#if requires exactly one argument/);
+    });
+
+    it('if helper - too many arguments, string', function() {
+      var template = CompilerContext.compile('{{#if test "string"}}{{/if}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#if requires exactly one argument/);
+    });
+
+    it('if helper - too many arguments, undefined', function() {
+      var template = CompilerContext.compile('{{#if test undefined}}{{/if}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#if requires exactly one argument/);
+    });
+
+    it('if helper - too many arguments, null', function() {
+      var template = CompilerContext.compile('{{#if test null}}{{/if}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#if requires exactly one argument/);
+    });
+
+    it('unless helper - too few arguments', function() {
+      var template = CompilerContext.compile('{{#unless}}{{/unless}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#unless requires exactly one argument/);
+    });
+
+    it('unless helper - too many arguments', function() {
+      var template = CompilerContext.compile('{{#unless test null}}{{/unless}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#unless requires exactly one argument/);
+    });
+
+    it('with helper - too few arguments', function() {
+      var template = CompilerContext.compile('{{#with}}{{/with}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#with requires exactly one argument/);
+    });
+
+    it('with helper - too many arguments', function() {
+      var template = CompilerContext.compile('{{#with test "string"}}{{/with}}');
+        shouldThrow(function() {
+
+            template({});
+        }, undefined, /#with requires exactly one argument/);
+    });
+  });
 });

spec/regressions.js

@@ -291,4 +291,47 @@ describe('Regressions', function() {
     };
     shouldCompileToWithPartials(string, [{}, {}, partials], true, 'template  block  partial  block  template');
   });
+
+  describe('GH-1561: 4.3.x should still work with precompiled templates from 4.0.0 <= x < 4.3.0', function() {
+
+    it('should compile and execute templates', function() {
+      var newHandlebarsInstance = Handlebars.create();
+
+      registerTemplate(newHandlebarsInstance);
+      newHandlebarsInstance.registerHelper('loud', function(value) {
+        return value.toUpperCase();
+      });
+      var result = newHandlebarsInstance.templates['test.hbs']({name: 'yehuda'});
+      equals(result.trim(), 'YEHUDA');
+    });
+
+    it('should call "helperMissing" if a helper is missing', function() {
+      var newHandlebarsInstance = Handlebars.create();
+
+      shouldThrow(function() {
+        registerTemplate(newHandlebarsInstance);
+        newHandlebarsInstance.templates['test.hbs']({});
+      }, Handlebars.Exception, 'Missing helper: "loud"');
+    });
+
+    // This is a only slightly modified precompiled templated from compiled with 4.2.1
+    function registerTemplate(Handlebars) {
+      var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
+      templates['test.hbs'] = template({'compiler': [7, '>= 4.0.0'], 'main': function(container, depth0, helpers, partials, data) {
+          return container.escapeExpression((helpers.loud || (depth0 && depth0.loud) || helpers.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}), (depth0 != null ? depth0.name : depth0), {'name': 'loud', 'hash': {}, 'data': data}))
+              + '\n\n';
+        }, 'useData': true});
+    }
+  });
+
+  it('should allow hash with protected array names', function() {
+    var obj = {array: [1], name: 'John'};
+    var helpers = {
+      helpa: function(options) {
+        return options.hash.length;
+      }
+    };
+
+    shouldCompileTo('{{helpa length="foo"}}', [obj, helpers], 'foo');
+  });
 });

spec/runtime.js

@@ -21,7 +21,7 @@ describe('runtime', function() {
       shouldThrow(function() {
         Handlebars.template({
           main: {},
-          compiler: [Handlebars.COMPILER_REVISION - 1]
+          compiler: [Handlebars.LAST_COMPATIBLE_COMPILER_REVISION - 1]
         });
       }, Error, /Template was precompiled with an older version of Handlebars than the current runtime/);
       shouldThrow(function() {

spec/security.js

@@ -32,4 +32,73 @@ describe('security issues', function() {
 
         });
     });
+
+    describe('GH-1558: Prevent explicit call of helperMissing-helpers', function() {
+        if (!Handlebars.compile) {
+            return;
+        }
+
+        describe('without the option "allowExplicitCallOfHelperMissing"', function() {
+            it('should throw an exception when calling  "{{helperMissing}}" ', function() {
+                shouldThrow(function() {
+                    var template = Handlebars.compile('{{helperMissing}}');
+                    template({});
+                }, Error);
+            });
+            it('should throw an exception when calling  "{{#helperMissing}}{{/helperMissing}}" ', function() {
+                shouldThrow(function() {
+                    var template = Handlebars.compile('{{#helperMissing}}{{/helperMissing}}');
+                    template({});
+                }, Error);
+            });
+            it('should throw an exception when calling  "{{blockHelperMissing "abc" .}}" ', function() {
+                var functionCalls = [];
+                shouldThrow(function() {
+                    var template = Handlebars.compile('{{blockHelperMissing "abc" .}}');
+                    template({ fn: function() { functionCalls.push('called'); }});
+                }, Error);
+                equals(functionCalls.length, 0);
+            });
+            it('should throw an exception when calling  "{{#blockHelperMissing .}}{{/blockHelperMissing}}"', function() {
+                shouldThrow(function() {
+                    var template = Handlebars.compile('{{#blockHelperMissing .}}{{/blockHelperMissing}}');
+                    template({ fn: function() { return 'functionInData';}});
+                }, Error);
+            });
+        });
+
+        describe('with the option "allowCallsToHelperMissing" set to true', function() {
+            it('should not throw an exception when calling  "{{helperMissing}}" ', function() {
+                    var template = Handlebars.compile('{{helperMissing}}');
+                    template({}, {allowCallsToHelperMissing: true});
+            });
+            it('should not throw an exception when calling  "{{#helperMissing}}{{/helperMissing}}" ', function() {
+                    var template = Handlebars.compile('{{#helperMissing}}{{/helperMissing}}');
+                    template({}, {allowCallsToHelperMissing: true});
+            });
+            it('should not throw an exception when calling  "{{blockHelperMissing "abc" .}}" ', function() {
+                    var functionCalls = [];
+                    var template = Handlebars.compile('{{blockHelperMissing "abc" .}}');
+                    template({ fn: function() { functionCalls.push('called'); }}, {allowCallsToHelperMissing: true});
+                    equals(functionCalls.length, 1);
+            });
+            it('should not throw an exception when calling  "{{#blockHelperMissing .}}{{/blockHelperMissing}}"', function() {
+                    var template = Handlebars.compile('{{#blockHelperMissing true}}sdads{{/blockHelperMissing}}');
+                    template({}, {allowCallsToHelperMissing: true});
+            });
+        });
+    });
+
+    describe('GH-1563', function() {
+        it('should not allow to access constructor after overriding via __defineGetter__', function() {
+            if (({}).__defineGetter__ == null || ({}).__lookupGetter__ == null) {
+                return; // Browser does not support this exploit anyway
+            }
+            shouldCompileTo('{{__defineGetter__ "undefined" valueOf }}' +
+                '{{#with __lookupGetter__ }}' +
+                '{{__defineGetter__ "propertyIsEnumerable" (this.bind (this.bind 1)) }}' +
+                '{{constructor.name}}' +
+                '{{/with}}', {}, '');
+        });
+    });
 });

spec/strict.js

@@ -95,6 +95,25 @@ describe('strict', function() {
       };
       equals(template({}, {helpers: helpers}), 'success');
     });
+
+    it('should show error location on missing property lookup', function() {
+      shouldThrow(function() {
+        var template = CompilerContext.compile('\n\n\n   {{hello}}', {strict: true});
+        template({});
+      }, Exception, '"hello" not defined in [object Object] - 4:5');
+    });
+
+    it('should error contains correct location properties on missing property lookup', function() {
+      try {
+        var template = CompilerContext.compile('\n\n\n   {{hello}}', {strict: true});
+        template({});
+      } catch (error) {
+        equals(error.lineNumber, 4);
+        equals(error.endLineNumber, 4);
+        equals(error.column, 5);
+        equals(error.endColumn, 10);
+      }
+    });
   });
 
   describe('assume objects', function() {

spec/tokenizer.js

@@ -441,4 +441,9 @@ describe('Tokenizer', function() {
     result = tokenize('{{else foo as |bar baz|}}');
     shouldMatchTokens(result, ['OPEN_INVERSE_CHAIN', 'ID', 'OPEN_BLOCK_PARAMS', 'ID', 'ID', 'CLOSE_BLOCK_PARAMS', 'CLOSE']);
   });
+
+  it('tokenizes raw blocks', function() {
+    var result = tokenize('{{{{a}}}} abc {{{{/a}}}} aaa {{{{a}}}} abc {{{{/a}}}}');
+    shouldMatchTokens(result, ['OPEN_RAW_BLOCK', 'ID', 'CLOSE_RAW_BLOCK', 'CONTENT', 'END_RAW_BLOCK', 'CONTENT', 'OPEN_RAW_BLOCK', 'ID', 'CLOSE_RAW_BLOCK', 'CONTENT', 'END_RAW_BLOCK']);
+  });
 });

src/handlebars.l

@@ -63,7 +63,7 @@ ID    [^\s!"#%-,\.\/;->@\[-\^`\{-~]+/{LOOKAHEAD}
                                     return 'END_RAW_BLOCK';
                                   }
                                  }
-<raw>[^\x00]*?/("{{{{")          { return 'CONTENT'; }
+<raw>[^\x00]+?/("{{{{")          { return 'CONTENT'; }
 
 <com>[\s\S]*?"--"{RIGHT_STRIP}?"}}" {
   this.popState();

src/handlebars.yy

@@ -39,7 +39,7 @@ content
   };
 
 rawBlock
-  : openRawBlock content+ END_RAW_BLOCK -> yy.prepareRawBlock($1, $2, $3, @$)
+  : openRawBlock content* END_RAW_BLOCK -> yy.prepareRawBlock($1, $2, $3, @$)
   ;
 
 openRawBlock

types/index.d.ts

@@ -7,6 +7,8 @@
  *   - Raanan Weber <https://github.com/RaananW>
  *   - Sergei Dorogin <https://github.com/evil-shrike>
  *   - webbiesdk <https://github.com/webbiesdk>
+ *   - Andrew Leedham <https://github.com/AndrewLeedham>
+ *   - Nils Knappmeier <https://github.com/nknapp>
  * For full history prior to their migration to handlebars.js, please see:
  * https://github.com/DefinitelyTyped/DefinitelyTyped/commits/1ce60bdc07f10e0b076778c6c953271c072bc894/types/handlebars/index.d.ts
  */
@@ -27,6 +29,7 @@ declare namespace Handlebars {
       decorators?: { [name: string]: Function };
       data?: any;
       blockParams?: any[];
+      allowCallsToHelperMissing?: boolean;
   }
 
   export interface HelperOptions {
@@ -44,8 +47,8 @@ declare namespace Handlebars {
   }
 
   export interface ParseOptions {
-      srcName?: string,
-      ignoreStandalone?: boolean
+      srcName?: string;
+      ignoreStandalone?: boolean;
   }
 
   export function registerHelper(name: string, fn: HelperDelegate): void;
@@ -63,9 +66,9 @@ declare namespace Handlebars {
   export function K(): void;
   export function createFrame(object: any): any;
   export function blockParams(obj: any[], ids: any[]): any[];
-  export function Exception(message: string): void;
   export function log(level: number, obj: any): void;
   export function parse(input: string, options?: ParseOptions): hbs.AST.Program;
+  export function parseWithoutProcessing(input: string, options?: ParseOptions): hbs.AST.Program;
   export function compile<T = any>(input: any, options?: CompileOptions): HandlebarsTemplateDelegate<T>;
   export function precompile(input: any, options?: PrecompileOptions): TemplateSpecification;
   export function template<T = any>(precompilation: TemplateSpecification): HandlebarsTemplateDelegate<T>;
@@ -83,6 +86,20 @@ declare namespace Handlebars {
 
   export function noConflict(): typeof Handlebars;
 
+  export class Exception {
+      constructor(message: string, node?: hbs.AST.Node);
+      description: string;
+      fileName: string;
+      lineNumber?: any;
+      endLineNumber?: any;
+      message: string;
+      name: string;
+      number: number;
+      stack?: string;
+      column?: any;
+      endColumn?: any;
+  }
+
   export class SafeString {
       constructor(str: string);
       toString(): string;
@@ -147,6 +164,22 @@ declare namespace Handlebars {
       NullLiteral(): void;
       Hash(hash: hbs.AST.Hash): void;
   }
+
+
+  export interface ResolvePartialOptions {
+    name: string;
+    helpers?: { [name: string]: Function };
+    partials?: { [name: string]: HandlebarsTemplateDelegate };
+    decorators?: { [name: string]: Function };
+    data?: any;
+  }
+
+  export namespace VM {
+    /**
+     * @deprecated
+     */
+    export function resolvePartial<T = any>(partial: HandlebarsTemplateDelegate<T> | undefined, context: any, options: ResolvePartialOptions): HandlebarsTemplateDelegate<T>;
+  }
 }
 
 /**
@@ -173,16 +206,7 @@ type RuntimeOptions = Handlebars.RuntimeOptions;
 interface CompileOptions {
   data?: boolean;
   compat?: boolean;
-  knownHelpers?: {
-      helperMissing?: boolean;
-      blockHelperMissing?: boolean;
-      each?: boolean;
-      if?: boolean;
-      unless?: boolean;
-      with?: boolean;
-      log?: boolean;
-      lookup?: boolean;
-  };
+  knownHelpers?: KnownHelpers;
   knownHelpersOnly?: boolean;
   noEscape?: boolean;
   strict?: boolean;
@@ -192,6 +216,22 @@ interface CompileOptions {
   explicitPartialContext?: boolean;
 }
 
+type KnownHelpers = {
+  [name in BuiltinHelperName | CustomHelperName]: boolean;
+};
+
+type BuiltinHelperName =
+  "helperMissing"|
+  "blockHelperMissing"|
+  "each"|
+  "if"|
+  "unless"|
+  "with"|
+  "log"|
+  "lookup";
+
+type CustomHelperName = string;
+
 interface PrecompileOptions extends CompileOptions {
   srcName?: string;
   destName?: string;
@@ -216,6 +256,8 @@ interface Logger {
   log(level: number, obj: string): void;
 }
 
+type CompilerInfo = [number/* revision */, string /* versions */];
+
 declare namespace hbs {
   namespace AST {
       interface Node {
@@ -242,6 +284,7 @@ declare namespace hbs {
       interface Statement extends Node {}
 
       interface MustacheStatement extends Statement {
+          type: 'MustacheStatement';
           path: PathExpression | Literal;
           params: Expression[];
           hash: Hash;
@@ -252,6 +295,7 @@ declare namespace hbs {
       interface Decorator extends MustacheStatement { }
 
       interface BlockStatement extends Statement {
+          type: 'BlockStatement';
           path: PathExpression;
           params: Expression[];
           hash: Hash;
@@ -265,6 +309,7 @@ declare namespace hbs {
       interface DecoratorBlock extends BlockStatement { }
 
       interface PartialStatement extends Statement {
+          type: 'PartialStatement';
           name: PathExpression | SubExpression;
           params: Expression[];
           hash: Hash;
@@ -273,6 +318,7 @@ declare namespace hbs {
       }
 
       interface PartialBlockStatement extends Statement {
+          type: 'PartialBlockStatement';
           name: PathExpression | SubExpression;
           params: Expression[];
           hash: Hash;
@@ -282,11 +328,13 @@ declare namespace hbs {
       }
 
       interface ContentStatement extends Statement {
+          type: 'ContentStatement';
           value: string;
           original: StripFlags;
       }
 
       interface CommentStatement extends Statement {
+          type: 'CommentStatement';
           value: string;
           strip: StripFlags;
       }
@@ -294,12 +342,14 @@ declare namespace hbs {
       interface Expression extends Node {}
 
       interface SubExpression extends Expression {
+          type: 'SubExpression';
           path: PathExpression;
           params: Expression[];
           hash: Hash;
       }
 
       interface PathExpression extends Expression {
+          type: 'PathExpression';
           data: boolean;
           depth: number;
           parts: string[];
@@ -308,29 +358,38 @@ declare namespace hbs {
 
       interface Literal extends Expression {}
       interface StringLiteral extends Literal {
+          type: 'StringLiteral';
           value: string;
           original: string;
       }
 
       interface BooleanLiteral extends Literal {
+          type: 'BooleanLiteral';
           value: boolean;
           original: boolean;
       }
 
       interface NumberLiteral extends Literal {
+          type: 'NumberLiteral';
           value: number;
           original: number;
       }
 
-      interface UndefinedLiteral extends Literal {}
+      interface UndefinedLiteral extends Literal {
+          type: 'UndefinedLiteral';
+	  }
 
-      interface NullLiteral extends Literal {}
+      interface NullLiteral extends Literal {
+          type: 'NullLiteral';
+	  }
 
       interface Hash extends Node {
+          type: 'Hash';
           pairs: HashPair[];
       }
 
       interface HashPair extends Node {
+          type: 'HashPair';
           key: string;
           value: Expression;
       }

types/test.ts

@@ -76,7 +76,7 @@ Handlebars.registerHelper('list', (context, options: Handlebars.HelperOptions) =
   }
   return ret + "</ul>";
 });
-template6([{url:"", title:""}])
+template6([{url:"", title:""}]);
 
 
 const escapedExpression = Handlebars.Utils.escapeExpression('<script>alert(\'xss\');</script>');
@@ -88,4 +88,155 @@ const parsedTmpl = Handlebars.parse('<p>Hello, my name is {{name}}.</p>', {
   ignoreStandalone: true
 });
 
-const parsedTmplWithoutOptions = Handlebars.parse('<p>Hello, my name is {{name}}.</p>');
+const parsedTmplWithoutOptions = Handlebars.parse('<p>Hello, my name is {{name}}.</p>');
+
+// Custom partial resolution.
+const originalResolvePartial = Handlebars.VM.resolvePartial;
+Handlebars.VM.resolvePartial = <T>(partial: HandlebarsTemplateDelegate<T> | undefined, context: any, options: Handlebars.ResolvePartialOptions): HandlebarsTemplateDelegate<T> => {
+  const name = options.name.replace(/my/,'your');
+  // transform name.
+  options.name = name;
+  return originalResolvePartial(partial, context, options);
+};
+
+
+// #1544, allow custom helpers in knownHelpers
+Handlebars.compile('test', {
+  knownHelpers: {
+    each: true,
+    customHelper: true
+  }
+});
+
+Handlebars.compile('test')({},{allowCallsToHelperMissing: true});
+
+Handlebars.compile('test')({},{});
+
+
+const allthings = {} as hbs.AST.MustacheStatement |
+  hbs.AST.BlockStatement |
+  hbs.AST.PartialStatement |
+  hbs.AST.PartialBlockStatement |
+  hbs.AST.ContentStatement |
+  hbs.AST.CommentStatement |
+  hbs.AST.SubExpression |
+  hbs.AST.PathExpression |
+  hbs.AST.StringLiteral |
+  hbs.AST.BooleanLiteral |
+  hbs.AST.NumberLiteral |
+  hbs.AST.UndefinedLiteral |
+  hbs.AST.NullLiteral |
+  hbs.AST.Hash |
+  hbs.AST.HashPair;
+
+switch(allthings.type) {
+  case "MustacheStatement":
+    let mustacheStatement: hbs.AST.MustacheStatement;
+    mustacheStatement = allthings;
+    break;
+  case "BlockStatement":
+    let blockStatement: hbs.AST.BlockStatement;
+    blockStatement = allthings;
+    break;
+  case "PartialStatement":
+    let partialStatement: hbs.AST.PartialStatement;
+    partialStatement = allthings;
+    break;
+  case "PartialBlockStatement":
+    let partialBlockStatement: hbs.AST.PartialBlockStatement;
+    partialBlockStatement = allthings;
+    break;
+  case "ContentStatement":
+    let ContentStatement: hbs.AST.ContentStatement;
+    ContentStatement = allthings;
+    break;
+  case "CommentStatement":
+    let CommentStatement: hbs.AST.CommentStatement;
+    CommentStatement = allthings;
+    break;
+  case "SubExpression":
+    let SubExpression: hbs.AST.SubExpression;
+    SubExpression = allthings;
+    break;
+  case "PathExpression":
+    let PathExpression: hbs.AST.PathExpression;
+    PathExpression = allthings;
+    break;
+  case "StringLiteral":
+    let StringLiteral: hbs.AST.StringLiteral;
+    StringLiteral = allthings;
+    break;
+  case "BooleanLiteral":
+    let BooleanLiteral: hbs.AST.BooleanLiteral;
+    BooleanLiteral = allthings;
+    break;
+  case "NumberLiteral":
+    let NumberLiteral: hbs.AST.NumberLiteral;
+    NumberLiteral = allthings;
+    break;
+  case "UndefinedLiteral":
+    let UndefinedLiteral: hbs.AST.UndefinedLiteral;
+    UndefinedLiteral = allthings;
+    break;
+  case "NullLiteral":
+    let NullLiteral: hbs.AST.NullLiteral;
+    NullLiteral = allthings;
+    break;
+  case "Hash":
+    let Hash: hbs.AST.Hash;
+    Hash = allthings;
+    break;
+  case "HashPair":
+    let HashPair: hbs.AST.HashPair;
+    HashPair = allthings;
+    break;
+  default:
+    break;
+}
+
+function testParseWithoutProcessing() {
+  const parsedTemplate: hbs.AST.Program = Handlebars.parseWithoutProcessing('<p>Hello, my name is {{name}}.</p>', {
+    srcName: "/foo/bar/baz.hbs",
+  });
+
+  const parsedTemplateWithoutOptions: hbs.AST.Program = Handlebars.parseWithoutProcessing('<p>Hello, my name is {{name}}.</p>');
+}
+
+function testExceptionTypings() {
+  // Test exception constructor with a single argument - message.
+  let exception: Handlebars.Exception = new Handlebars.Exception('message');
+
+  // Fields
+  let message: string = exception.message;
+  let lineNumber: number = exception.lineNumber;
+  let column: number = exception.column;
+  let endLineNumber: number = exception.endLineNumber;
+  let endColumn: number = exception.endColumn;
+  let description = exception.description;
+  let name: string = exception.name;
+  let fileName: string = exception.fileName;
+  let stack: string | undefined = exception.stack;
+}
+
+function testExceptionWithNodeTypings() {
+  // Test exception constructor with both arguments.
+  const exception: Handlebars.Exception = new Handlebars.Exception('message', {
+    type: 'MustacheStatement',
+    loc: {
+      source: 'source',
+      start: { line: 1, column: 5 },
+      end: { line: 10, column: 2 }
+    }
+  });
+
+  // Fields
+  let message: string = exception.message;
+  let lineNumber: number = exception.lineNumber;
+  let column: number = exception.column;
+  let endLineNumber: number = exception.endLineNumber;
+  let endColumn: number = exception.endColumn;
+  let description = exception.description;
+  let name: string = exception.name;
+  let fileName: string = exception.fileName;
+  let stack: string | undefined = exception.stack;
+}