ember-legacy-class-transform
Version:
The default blueprint for ember-cli addons.
326 lines (288 loc) • 44.8 kB
JavaScript
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); }
import b from "../builders";
import { appendChild, isLiteral, printLiteral } from "../utils";
import { Parser } from '../parser';
import SyntaxError from '../errors/syntax-error';
export var 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 = b.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 SyntaxError("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 SyntaxError("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 = b.block(path, params, hash, program, inverse, block.loc);
var parentProgram = this.currentElement();
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: b.hash(),
escaped: escaped,
loc: loc
};
} else {
var _acceptCallNodes2 = acceptCallNodes(this, rawMustache),
path = _acceptCallNodes2.path,
params = _acceptCallNodes2.params,
hash = _acceptCallNodes2.hash;
mustache = b.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:
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 = b.mustacheComment(value, loc);
switch (tokenizer.state) {
case "beforeAttributeName":
this.currentStartTag.comments.push(comment);
break;
case 'beforeData':
case 'data':
appendChild(this.currentElement(), comment);
break;
default:
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);
}
return comment;
};
HandlebarsNodeVisitors.prototype.PartialStatement = function PartialStatement(partial) {
var loc = partial.loc;
throw new SyntaxError("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 SyntaxError("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 SyntaxError("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 SyntaxError("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 b.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 SyntaxError("Using \"./\" is not supported in Glimmer and unnecessary: \"" + path.original + "\" on line " + loc.start.line + ".", path.loc);
}
if (original.slice(0, 3) === '../') {
throw new SyntaxError("Changing context using \"../\" is not supported in Glimmer: \"" + path.original + "\" on line " + loc.start.line + ".", path.loc);
}
if (original.indexOf('.') !== -1) {
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);
}
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(b.pair(pair.key, this.acceptNode(pair.value), pair.loc));
}
return b.hash(pairs, hash.loc);
};
HandlebarsNodeVisitors.prototype.StringLiteral = function StringLiteral(string) {
return b.literal('StringLiteral', string.value, string.loc);
};
HandlebarsNodeVisitors.prototype.BooleanLiteral = function BooleanLiteral(boolean) {
return b.literal('BooleanLiteral', boolean.value, boolean.loc);
};
HandlebarsNodeVisitors.prototype.NumberLiteral = function NumberLiteral(number) {
return b.literal('NumberLiteral', number.value, number.loc);
};
HandlebarsNodeVisitors.prototype.UndefinedLiteral = function UndefinedLiteral(undef) {
return b.literal('UndefinedLiteral', undefined, undef.loc);
};
HandlebarsNodeVisitors.prototype.NullLiteral = function NullLiteral(nul) {
return b.literal('NullLiteral', null, nul.loc);
};
return HandlebarsNodeVisitors;
}(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) : b.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 (isLiteral(path)) {
var _modifier = "{{" + printLiteral(path) + "}}";
var tag = "<" + element.name + " ... " + _modifier + " ...";
throw new SyntaxError("In " + tag + ", " + _modifier + " is not a valid modifier: \"" + path.original + "\" on line " + (loc && loc.start.line) + ".", mustache.loc);
}
var modifier = b.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}"]}