ember-legacy-class-transform
Version:
The default blueprint for ember-cli addons.
361 lines (314 loc) • 44.1 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.HandlebarsNodeVisitors = undefined;
var _builders = require("../builders");
var _builders2 = _interopRequireDefault(_builders);
var _utils = require("../utils");
var _parser = require("../parser");
var _syntaxError = require("../errors/syntax-error");
var _syntaxError2 = _interopRequireDefault(_syntaxError);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _defaults(obj, defaults) {
var keys = Object.getOwnPropertyNames(defaults);for (var i = 0; i < keys.length; i++) {
var key = keys[i];var value = Object.getOwnPropertyDescriptor(defaults, key);if (value && value.configurable && obj[key] === undefined) {
Object.defineProperty(obj, key, value);
}
}return obj;
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _possibleConstructorReturn(self, call) {
if (!self) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}return call && (typeof call === "object" || typeof call === "function") ? call : self;
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
}subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : _defaults(subClass, superClass);
}
var HandlebarsNodeVisitors = exports.HandlebarsNodeVisitors = function (_Parser) {
_inherits(HandlebarsNodeVisitors, _Parser);
function HandlebarsNodeVisitors() {
_classCallCheck(this, HandlebarsNodeVisitors);
return _possibleConstructorReturn(this, _Parser.apply(this, arguments));
}
HandlebarsNodeVisitors.prototype.Program = function Program(program) {
var body = [];
var node = _builders2.default.program(body, program.blockParams, program.loc);
var i = void 0,
l = program.body.length;
this.elementStack.push(node);
if (l === 0) {
return this.elementStack.pop();
}
for (i = 0; i < l; i++) {
this.acceptNode(program.body[i]);
}
// Ensure that that the element stack is balanced properly.
var poppedNode = this.elementStack.pop();
if (poppedNode !== node) {
var elementNode = poppedNode;
throw new _syntaxError2.default("Unclosed element `" + elementNode.tag + "` (on line " + elementNode.loc.start.line + ").", elementNode.loc);
}
return node;
};
HandlebarsNodeVisitors.prototype.BlockStatement = function BlockStatement(block) {
if (this.tokenizer['state'] === 'comment') {
this.appendToCommentData(this.sourceForNode(block));
return;
}
if (this.tokenizer['state'] !== 'comment' && this.tokenizer['state'] !== 'data' && this.tokenizer['state'] !== 'beforeData') {
throw new _syntaxError2.default("A block may only be used inside an HTML element or another block.", block.loc);
}
var _acceptCallNodes = acceptCallNodes(this, block),
path = _acceptCallNodes.path,
params = _acceptCallNodes.params,
hash = _acceptCallNodes.hash;
var program = this.Program(block.program);
var inverse = block.inverse ? this.Program(block.inverse) : null;
var node = _builders2.default.block(path, params, hash, program, inverse, block.loc);
var parentProgram = this.currentElement();
(0, _utils.appendChild)(parentProgram, node);
};
HandlebarsNodeVisitors.prototype.MustacheStatement = function MustacheStatement(rawMustache) {
var tokenizer = this.tokenizer;
if (tokenizer['state'] === 'comment') {
this.appendToCommentData(this.sourceForNode(rawMustache));
return;
}
var mustache = void 0;
var escaped = rawMustache.escaped,
loc = rawMustache.loc;
if (rawMustache.path.type.match(/Literal$/)) {
mustache = {
type: 'MustacheStatement',
path: this.acceptNode(rawMustache.path),
params: [],
hash: _builders2.default.hash(),
escaped: escaped,
loc: loc
};
} else {
var _acceptCallNodes2 = acceptCallNodes(this, rawMustache),
path = _acceptCallNodes2.path,
params = _acceptCallNodes2.params,
hash = _acceptCallNodes2.hash;
mustache = _builders2.default.mustache(path, params, hash, !escaped, loc);
}
switch (tokenizer.state) {
// Tag helpers
case "tagName":
addElementModifier(this.currentStartTag, mustache);
tokenizer.state = "beforeAttributeName";
break;
case "beforeAttributeName":
addElementModifier(this.currentStartTag, mustache);
break;
case "attributeName":
case "afterAttributeName":
this.beginAttributeValue(false);
this.finishAttributeValue();
addElementModifier(this.currentStartTag, mustache);
tokenizer.state = "beforeAttributeName";
break;
case "afterAttributeValueQuoted":
addElementModifier(this.currentStartTag, mustache);
tokenizer.state = "beforeAttributeName";
break;
// Attribute values
case "beforeAttributeValue":
appendDynamicAttributeValuePart(this.currentAttribute, mustache);
tokenizer.state = 'attributeValueUnquoted';
break;
case "attributeValueDoubleQuoted":
case "attributeValueSingleQuoted":
case "attributeValueUnquoted":
appendDynamicAttributeValuePart(this.currentAttribute, mustache);
break;
// TODO: Only append child when the tokenizer state makes
// sense to do so, otherwise throw an error.
default:
(0, _utils.appendChild)(this.currentElement(), mustache);
}
return mustache;
};
HandlebarsNodeVisitors.prototype.ContentStatement = function ContentStatement(content) {
updateTokenizerLocation(this.tokenizer, content);
this.tokenizer.tokenizePart(content.value);
this.tokenizer.flushData();
};
HandlebarsNodeVisitors.prototype.CommentStatement = function CommentStatement(rawComment) {
var tokenizer = this.tokenizer;
if (tokenizer.state === 'comment') {
this.appendToCommentData(this.sourceForNode(rawComment));
return null;
}
var value = rawComment.value,
loc = rawComment.loc;
var comment = _builders2.default.mustacheComment(value, loc);
switch (tokenizer.state) {
case "beforeAttributeName":
this.currentStartTag.comments.push(comment);
break;
case 'beforeData':
case 'data':
(0, _utils.appendChild)(this.currentElement(), comment);
break;
default:
throw new _syntaxError2.default("Using a Handlebars comment when in the `" + tokenizer.state + "` state is not supported: \"" + comment.value + "\" on line " + loc.start.line + ":" + loc.start.column, rawComment.loc);
}
return comment;
};
HandlebarsNodeVisitors.prototype.PartialStatement = function PartialStatement(partial) {
var loc = partial.loc;
throw new _syntaxError2.default("Handlebars partials are not supported: \"" + this.sourceForNode(partial, partial.name) + "\" at L" + loc.start.line + ":C" + loc.start.column, partial.loc);
};
HandlebarsNodeVisitors.prototype.PartialBlockStatement = function PartialBlockStatement(partialBlock) {
var loc = partialBlock.loc;
throw new _syntaxError2.default("Handlebars partial blocks are not supported: \"" + this.sourceForNode(partialBlock, partialBlock.name) + "\" at L" + loc.start.line + ":C" + loc.start.column, partialBlock.loc);
};
HandlebarsNodeVisitors.prototype.Decorator = function Decorator(decorator) {
var loc = decorator.loc;
throw new _syntaxError2.default("Handlebars decorators are not supported: \"" + this.sourceForNode(decorator, decorator.path) + "\" at L" + loc.start.line + ":C" + loc.start.column, decorator.loc);
};
HandlebarsNodeVisitors.prototype.DecoratorBlock = function DecoratorBlock(decoratorBlock) {
var loc = decoratorBlock.loc;
throw new _syntaxError2.default("Handlebars decorator blocks are not supported: \"" + this.sourceForNode(decoratorBlock, decoratorBlock.path) + "\" at L" + loc.start.line + ":C" + loc.start.column, decoratorBlock.loc);
};
HandlebarsNodeVisitors.prototype.SubExpression = function SubExpression(sexpr) {
var _acceptCallNodes3 = acceptCallNodes(this, sexpr),
path = _acceptCallNodes3.path,
params = _acceptCallNodes3.params,
hash = _acceptCallNodes3.hash;
return _builders2.default.sexpr(path, params, hash, sexpr.loc);
};
HandlebarsNodeVisitors.prototype.PathExpression = function PathExpression(path) {
var original = path.original,
loc = path.loc;
var parts = void 0;
if (original.indexOf('/') !== -1) {
if (original.slice(0, 2) === './') {
throw new _syntaxError2.default("Using \"./\" is not supported in Glimmer and unnecessary: \"" + path.original + "\" on line " + loc.start.line + ".", path.loc);
}
if (original.slice(0, 3) === '../') {
throw new _syntaxError2.default("Changing context using \"../\" is not supported in Glimmer: \"" + path.original + "\" on line " + loc.start.line + ".", path.loc);
}
if (original.indexOf('.') !== -1) {
throw new _syntaxError2.default("Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths: \"" + path.original + "\" on line " + loc.start.line + ".", path.loc);
}
parts = [path.parts.join('/')];
} else {
parts = path.parts;
}
var thisHead = false;
// This is to fix a bug in the Handlebars AST where the path expressions in
// `{{this.foo}}` (and similarly `{{foo-bar this.foo named=this.foo}}` etc)
// are simply turned into `{{foo}}`. The fix is to push it back onto the
// parts array and let the runtime see the difference. However, we cannot
// simply use the string `this` as it means literally the property called
// "this" in the current context (it can be expressed in the syntax as
// `{{[this]}}`, where the square bracket are generally for this kind of
// escaping – such as `{{foo.["bar.baz"]}}` would mean lookup a property
// named literally "bar.baz" on `this.foo`). By convention, we use `null`
// for this purpose.
if (original.match(/^this(\..+)?$/)) {
thisHead = true;
}
return {
type: 'PathExpression',
original: path.original,
this: thisHead,
parts: parts,
data: path.data,
loc: path.loc
};
};
HandlebarsNodeVisitors.prototype.Hash = function Hash(hash) {
var pairs = [];
for (var i = 0; i < hash.pairs.length; i++) {
var pair = hash.pairs[i];
pairs.push(_builders2.default.pair(pair.key, this.acceptNode(pair.value), pair.loc));
}
return _builders2.default.hash(pairs, hash.loc);
};
HandlebarsNodeVisitors.prototype.StringLiteral = function StringLiteral(string) {
return _builders2.default.literal('StringLiteral', string.value, string.loc);
};
HandlebarsNodeVisitors.prototype.BooleanLiteral = function BooleanLiteral(boolean) {
return _builders2.default.literal('BooleanLiteral', boolean.value, boolean.loc);
};
HandlebarsNodeVisitors.prototype.NumberLiteral = function NumberLiteral(number) {
return _builders2.default.literal('NumberLiteral', number.value, number.loc);
};
HandlebarsNodeVisitors.prototype.UndefinedLiteral = function UndefinedLiteral(undef) {
return _builders2.default.literal('UndefinedLiteral', undefined, undef.loc);
};
HandlebarsNodeVisitors.prototype.NullLiteral = function NullLiteral(nul) {
return _builders2.default.literal('NullLiteral', null, nul.loc);
};
return HandlebarsNodeVisitors;
}(_parser.Parser);
function calculateRightStrippedOffsets(original, value) {
if (value === '') {
// if it is empty, just return the count of newlines
// in original
return {
lines: original.split("\n").length - 1,
columns: 0
};
}
// otherwise, return the number of newlines prior to
// `value`
var difference = original.split(value)[0];
var lines = difference.split(/\n/);
var lineCount = lines.length - 1;
return {
lines: lineCount,
columns: lines[lineCount].length
};
}
function updateTokenizerLocation(tokenizer, content) {
var line = content.loc.start.line;
var column = content.loc.start.column;
var offsets = calculateRightStrippedOffsets(content.original, content.value);
line = line + offsets.lines;
if (offsets.lines) {
column = offsets.columns;
} else {
column = column + offsets.columns;
}
tokenizer.line = line;
tokenizer.column = column;
}
function acceptCallNodes(compiler, node) {
var path = compiler.PathExpression(node.path);
var params = node.params ? node.params.map(function (e) {
return compiler.acceptNode(e);
}) : [];
var hash = node.hash ? compiler.Hash(node.hash) : _builders2.default.hash();
return { path: path, params: params, hash: hash };
}
function addElementModifier(element, mustache) {
var path = mustache.path,
params = mustache.params,
hash = mustache.hash,
loc = mustache.loc;
if ((0, _utils.isLiteral)(path)) {
var _modifier = "{{" + (0, _utils.printLiteral)(path) + "}}";
var tag = "<" + element.name + " ... " + _modifier + " ...";
throw new _syntaxError2.default("In " + tag + ", " + _modifier + " is not a valid modifier: \"" + path.original + "\" on line " + (loc && loc.start.line) + ".", mustache.loc);
}
var modifier = _builders2.default.elementModifier(path, params, hash, loc);
element.modifiers.push(modifier);
}
function appendDynamicAttributeValuePart(attribute, part) {
attribute.isDynamic = true;
attribute.parts.push(part);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["lib/parser/handlebars-node-visitors.js"],"names":["b","appendChild","isLiteral","printLiteral","Parser","SyntaxError","HandlebarsNodeVisitors","Program","program","body","node","blockParams","loc","i","l","length","elementStack","push","pop","acceptNode","poppedNode","elementNode","tag","start","line","BlockStatement","block","tokenizer","appendToCommentData","sourceForNode","acceptCallNodes","path","params","hash","inverse","parentProgram","currentElement","MustacheStatement","rawMustache","mustache","escaped","type","match","state","addElementModifier","currentStartTag","beginAttributeValue","finishAttributeValue","appendDynamicAttributeValuePart","currentAttribute","ContentStatement","content","updateTokenizerLocation","tokenizePart","value","flushData","CommentStatement","rawComment","comment","mustacheComment","comments","column","PartialStatement","partial","name","PartialBlockStatement","partialBlock","Decorator","decorator","DecoratorBlock","decoratorBlock","SubExpression","sexpr","PathExpression","original","parts","indexOf","slice","join","thisHead","this","data","Hash","pairs","pair","key","StringLiteral","string","literal","BooleanLiteral","boolean","NumberLiteral","number","UndefinedLiteral","undef","undefined","NullLiteral","nul","calculateRightStrippedOffsets","lines","split","columns","difference","lineCount","offsets","compiler","map","e","element","modifier","elementModifier","modifiers","attribute","part","isDynamic"],"mappings":"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","file":"lib/parser/handlebars-node-visitors.js","sourcesContent":["import b from \"../builders\";\nimport { appendChild, isLiteral, printLiteral } from \"../utils\";\nimport { Parser } from '../parser';\nimport SyntaxError from '../errors/syntax-error';\nexport class HandlebarsNodeVisitors extends Parser {\n    Program(program) {\n        let body = [];\n        let node = b.program(body, program.blockParams, program.loc);\n        let i,\n            l = program.body.length;\n        this.elementStack.push(node);\n        if (l === 0) {\n            return this.elementStack.pop();\n        }\n        for (i = 0; i < l; i++) {\n            this.acceptNode(program.body[i]);\n        }\n        // Ensure that that the element stack is balanced properly.\n        let poppedNode = this.elementStack.pop();\n        if (poppedNode !== node) {\n            let elementNode = poppedNode;\n            throw new SyntaxError(\"Unclosed element `\" + elementNode.tag + \"` (on line \" + elementNode.loc.start.line + \").\", elementNode.loc);\n        }\n        return node;\n    }\n    BlockStatement(block) {\n        if (this.tokenizer['state'] === 'comment') {\n            this.appendToCommentData(this.sourceForNode(block));\n            return;\n        }\n        if (this.tokenizer['state'] !== 'comment' && this.tokenizer['state'] !== 'data' && this.tokenizer['state'] !== 'beforeData') {\n            throw new SyntaxError(\"A block may only be used inside an HTML element or another block.\", block.loc);\n        }\n        let { path, params, hash } = acceptCallNodes(this, block);\n        let program = this.Program(block.program);\n        let inverse = block.inverse ? this.Program(block.inverse) : null;\n        let node = b.block(path, params, hash, program, inverse, block.loc);\n        let parentProgram = this.currentElement();\n        appendChild(parentProgram, node);\n    }\n    MustacheStatement(rawMustache) {\n        let { tokenizer } = this;\n        if (tokenizer['state'] === 'comment') {\n            this.appendToCommentData(this.sourceForNode(rawMustache));\n            return;\n        }\n        let mustache;\n        let { escaped, loc } = rawMustache;\n        if (rawMustache.path.type.match(/Literal$/)) {\n            mustache = {\n                type: 'MustacheStatement',\n                path: this.acceptNode(rawMustache.path),\n                params: [],\n                hash: b.hash(),\n                escaped,\n                loc\n            };\n        } else {\n            let { path, params, hash } = acceptCallNodes(this, rawMustache);\n            mustache = b.mustache(path, params, hash, !escaped, loc);\n        }\n        switch (tokenizer.state) {\n            // Tag helpers\n            case \"tagName\":\n                addElementModifier(this.currentStartTag, mustache);\n                tokenizer.state = \"beforeAttributeName\";\n                break;\n            case \"beforeAttributeName\":\n                addElementModifier(this.currentStartTag, mustache);\n                break;\n            case \"attributeName\":\n            case \"afterAttributeName\":\n                this.beginAttributeValue(false);\n                this.finishAttributeValue();\n                addElementModifier(this.currentStartTag, mustache);\n                tokenizer.state = \"beforeAttributeName\";\n                break;\n            case \"afterAttributeValueQuoted\":\n                addElementModifier(this.currentStartTag, mustache);\n                tokenizer.state = \"beforeAttributeName\";\n                break;\n            // Attribute values\n            case \"beforeAttributeValue\":\n                appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n                tokenizer.state = 'attributeValueUnquoted';\n                break;\n            case \"attributeValueDoubleQuoted\":\n            case \"attributeValueSingleQuoted\":\n            case \"attributeValueUnquoted\":\n                appendDynamicAttributeValuePart(this.currentAttribute, mustache);\n                break;\n            // TODO: Only append child when the tokenizer state makes\n            // sense to do so, otherwise throw an error.\n            default:\n                appendChild(this.currentElement(), mustache);\n        }\n        return mustache;\n    }\n    ContentStatement(content) {\n        updateTokenizerLocation(this.tokenizer, content);\n        this.tokenizer.tokenizePart(content.value);\n        this.tokenizer.flushData();\n    }\n    CommentStatement(rawComment) {\n        let { tokenizer } = this;\n        if (tokenizer.state === 'comment') {\n            this.appendToCommentData(this.sourceForNode(rawComment));\n            return null;\n        }\n        let { value, loc } = rawComment;\n        let comment = b.mustacheComment(value, loc);\n        switch (tokenizer.state) {\n            case \"beforeAttributeName\":\n                this.currentStartTag.comments.push(comment);\n                break;\n            case 'beforeData':\n            case 'data':\n                appendChild(this.currentElement(), comment);\n                break;\n            default:\n                throw new SyntaxError(`Using a Handlebars comment when in the \\`${tokenizer.state}\\` state is not supported: \"${comment.value}\" on line ${loc.start.line}:${loc.start.column}`, rawComment.loc);\n        }\n        return comment;\n    }\n    PartialStatement(partial) {\n        let { loc } = partial;\n        throw new SyntaxError(`Handlebars partials are not supported: \"${this.sourceForNode(partial, partial.name)}\" at L${loc.start.line}:C${loc.start.column}`, partial.loc);\n    }\n    PartialBlockStatement(partialBlock) {\n        let { loc } = partialBlock;\n        throw new SyntaxError(`Handlebars partial blocks are not supported: \"${this.sourceForNode(partialBlock, partialBlock.name)}\" at L${loc.start.line}:C${loc.start.column}`, partialBlock.loc);\n    }\n    Decorator(decorator) {\n        let { loc } = decorator;\n        throw new SyntaxError(`Handlebars decorators are not supported: \"${this.sourceForNode(decorator, decorator.path)}\" at L${loc.start.line}:C${loc.start.column}`, decorator.loc);\n    }\n    DecoratorBlock(decoratorBlock) {\n        let { loc } = decoratorBlock;\n        throw new SyntaxError(`Handlebars decorator blocks are not supported: \"${this.sourceForNode(decoratorBlock, decoratorBlock.path)}\" at L${loc.start.line}:C${loc.start.column}`, decoratorBlock.loc);\n    }\n    SubExpression(sexpr) {\n        let { path, params, hash } = acceptCallNodes(this, sexpr);\n        return b.sexpr(path, params, hash, sexpr.loc);\n    }\n    PathExpression(path) {\n        let { original, loc } = path;\n        let parts;\n        if (original.indexOf('/') !== -1) {\n            if (original.slice(0, 2) === './') {\n                throw new SyntaxError(`Using \"./\" is not supported in Glimmer and unnecessary: \"${path.original}\" on line ${loc.start.line}.`, path.loc);\n            }\n            if (original.slice(0, 3) === '../') {\n                throw new SyntaxError(`Changing context using \"../\" is not supported in Glimmer: \"${path.original}\" on line ${loc.start.line}.`, path.loc);\n            }\n            if (original.indexOf('.') !== -1) {\n                throw new SyntaxError(`Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths: \"${path.original}\" on line ${loc.start.line}.`, path.loc);\n            }\n            parts = [path.parts.join('/')];\n        } else {\n            parts = path.parts;\n        }\n        let thisHead = false;\n        // This is to fix a bug in the Handlebars AST where the path expressions in\n        // `{{this.foo}}` (and similarly `{{foo-bar this.foo named=this.foo}}` etc)\n        // are simply turned into `{{foo}}`. The fix is to push it back onto the\n        // parts array and let the runtime see the difference. However, we cannot\n        // simply use the string `this` as it means literally the property called\n        // \"this\" in the current context (it can be expressed in the syntax as\n        // `{{[this]}}`, where the square bracket are generally for this kind of\n        // escaping – such as `{{foo.[\"bar.baz\"]}}` would mean lookup a property\n        // named literally \"bar.baz\" on `this.foo`). By convention, we use `null`\n        // for this purpose.\n        if (original.match(/^this(\\..+)?$/)) {\n            thisHead = true;\n        }\n        return {\n            type: 'PathExpression',\n            original: path.original,\n            this: thisHead,\n            parts,\n            data: path.data,\n            loc: path.loc\n        };\n    }\n    Hash(hash) {\n        let pairs = [];\n        for (let i = 0; i < hash.pairs.length; i++) {\n            let pair = hash.pairs[i];\n            pairs.push(b.pair(pair.key, this.acceptNode(pair.value), pair.loc));\n        }\n        return b.hash(pairs, hash.loc);\n    }\n    StringLiteral(string) {\n        return b.literal('StringLiteral', string.value, string.loc);\n    }\n    BooleanLiteral(boolean) {\n        return b.literal('BooleanLiteral', boolean.value, boolean.loc);\n    }\n    NumberLiteral(number) {\n        return b.literal('NumberLiteral', number.value, number.loc);\n    }\n    UndefinedLiteral(undef) {\n        return b.literal('UndefinedLiteral', undefined, undef.loc);\n    }\n    NullLiteral(nul) {\n        return b.literal('NullLiteral', null, nul.loc);\n    }\n}\nfunction calculateRightStrippedOffsets(original, value) {\n    if (value === '') {\n        // if it is empty, just return the count of newlines\n        // in original\n        return {\n            lines: original.split(\"\\n\").length - 1,\n            columns: 0\n        };\n    }\n    // otherwise, return the number of newlines prior to\n    // `value`\n    let difference = original.split(value)[0];\n    let lines = difference.split(/\\n/);\n    let lineCount = lines.length - 1;\n    return {\n        lines: lineCount,\n        columns: lines[lineCount].length\n    };\n}\nfunction updateTokenizerLocation(tokenizer, content) {\n    let line = content.loc.start.line;\n    let column = content.loc.start.column;\n    let offsets = calculateRightStrippedOffsets(content.original, content.value);\n    line = line + offsets.lines;\n    if (offsets.lines) {\n        column = offsets.columns;\n    } else {\n        column = column + offsets.columns;\n    }\n    tokenizer.line = line;\n    tokenizer.column = column;\n}\nfunction acceptCallNodes(compiler, node) {\n    let path = compiler.PathExpression(node.path);\n    let params = node.params ? node.params.map(e => compiler.acceptNode(e)) : [];\n    let hash = node.hash ? compiler.Hash(node.hash) : b.hash();\n    return { path, params, hash };\n}\nfunction addElementModifier(element, mustache) {\n    let { path, params, hash, loc } = mustache;\n    if (isLiteral(path)) {\n        let modifier = `{{${printLiteral(path)}}}`;\n        let tag = `<${element.name} ... ${modifier} ...`;\n        throw new SyntaxError(`In ${tag}, ${modifier} is not a valid modifier: \"${path.original}\" on line ${loc && loc.start.line}.`, mustache.loc);\n    }\n    let modifier = b.elementModifier(path, params, hash, loc);\n    element.modifiers.push(modifier);\n}\nfunction appendDynamicAttributeValuePart(attribute, part) {\n    attribute.isDynamic = true;\n    attribute.parts.push(part);\n}"]}