@mrhenry/twig-parser 0.1.0

package/src/printer.js

@@ -0,0 +1,752 @@
+// @ts-check
+/**
+ * The Twig source printer used by {@link Node#serialize}.
+ *
+ * Renders a node subtree back to Twig source from its current contents. Only
+ * nodes whose subtree changed since parsing are printed; unchanged descendants
+ * still return their retained source text (see `Node#_serialize`).
+ *
+ * @module twig-parser
+ */
+import { Node, NodeType } from './node.js';
+
+/**
+ * @param {unknown} value
+ * @returns {string} A single-quoted Twig string literal.
+ */
+function quoteString(value) {
+	const text = String(value);
+	return `'${text.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string} A number as it appears in Twig source.
+ */
+function formatNumber(value) {
+	const numeric = Number(value);
+	if (Number.isNaN(numeric)) {
+		return '0';
+	}
+	return String(numeric);
+}
+
+/**
+ * Serializes a node, reusing retained source where possible.
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+function serialize(node) {
+	return node._serialize();
+}
+
+/**
+ * Serializes the content of a body child.
+ *
+ * @param {Node|null|undefined} node
+ * @returns {string}
+ */
+function printBody(node) {
+	if (!node) {
+		return '';
+	}
+	return serialize(node);
+}
+
+/**
+ * Prints a call argument list (`arguments` is an array of `{name, value}`).
+ *
+ * @param {Array<{name: string|null, value: Node}>|null|undefined} args
+ * @returns {string}
+ */
+function printArguments(args) {
+	if (!args || !args.length) {
+		return '';
+	}
+	const parts = args.map((arg) => (arg.name === null || arg.name === undefined
+		? serialize(arg.value)
+		: `${arg.name}: ${serialize(arg.value)}`));
+	return `(${parts.join(', ')})`;
+}
+
+/**
+ * Prints the argument list held by an `array` node (used for method/macro
+ * calls, where named arguments are preserved as constant string keys).
+ *
+ * @param {Node|null|undefined} array
+ * @returns {string}
+ */
+function printArrayArguments(array) {
+	if (!array || array.type !== NodeType.ArrayExpr) {
+		return '()';
+	}
+	const pairs = /** @type {Array<[Node, Node]>} */ (
+		/** @type {any} */ (array).getKeyValuePairs()
+	);
+	const parts = pairs.map(([key, value]) => {
+		if (
+			key.type === NodeType.Constant &&
+			typeof key.getAttribute('value') === 'string' &&
+			!/^[0-9]+$/.test(String(key.getAttribute('value')))
+		) {
+			return `${key.getAttribute('value')}: ${serialize(value)}`;
+		}
+		return serialize(value);
+	});
+	return `(${parts.join(', ')})`;
+}
+
+/**
+ * Prints an expression node.
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+function printExpression(node) {
+	switch (node.type) {
+		case NodeType.Constant:
+			return printConstant(node.getAttribute('value'));
+		case NodeType.ContextVariable:
+		case NodeType.AssignContextVariable:
+			return String(node.getAttribute('name') ?? '');
+		case NodeType.LocalVariable: {
+			const name = node.getAttribute('name');
+			return name === null || name === undefined ? '' : String(name);
+		}
+		case NodeType.ArrayExpr:
+			return printArray(node);
+		case NodeType.ListExpr: {
+			const names = /** @type {Node[]} */ (node.getAttribute('names') ?? []);
+			return `(${names.map((name) => printExpression(name)).join(', ')})`;
+		}
+		case NodeType.GetAttr:
+			return printGetAttr(node);
+		case NodeType.MacroReference:
+			return printMacroReference(node);
+		case NodeType.Filter:
+			return printFilter(node);
+		case NodeType.FunctionCall: {
+			const name = String(node.getAttribute('name') ?? '');
+			return `${name}${printArguments(/** @type {any} */ (node.children.arguments))}`;
+		}
+		case NodeType.Test: {
+			const name = String(node.getAttribute('name') ?? '');
+			const args = /** @type {Array<{name: string|null, value: Node}>|null} */ (
+				node.children.arguments ?? null
+			);
+			return `${serialize(/** @type {Node} */ (node.getNode('node')))} is ${name}${printArguments(args)}`;
+		}
+		case NodeType.ArrowFunction: {
+			const args = node.getNode('arguments');
+			const params = args && args.type === NodeType.ListExpr
+				? printExpression(args)
+				: `(${args ? printExpression(args) : ''})`;
+			return `${params} => ${serialize(/** @type {Node} */ (node.getNode('body')))}`;
+		}
+		case NodeType.Binary: {
+			const operator = String(node.getAttribute('operator') ?? '');
+			return `${serialize(/** @type {Node} */ (node.getNode('left')))} ${operator} ${serialize(
+				/** @type {Node} */ (node.getNode('right')),
+			)}`;
+		}
+		case NodeType.Unary: {
+			const operator = String(node.getAttribute('operator') ?? '');
+			const operand = serialize(/** @type {Node} */ (node.getNode('node')));
+			return operator === 'not' ? `not ${operand}` : `${operator}${operand}`;
+		}
+		case NodeType.SetBinary:
+			return `${serialize(/** @type {Node} */ (node.getNode('left')))} = ${serialize(
+				/** @type {Node} */ (node.getNode('right')),
+			)}`;
+		case NodeType.SequenceDestructuringSet:
+			return `${printDestructuringTarget(/** @type {Node} */ (node.getNode('left')))} = ${serialize(
+				/** @type {Node} */ (node.getNode('right')),
+			)}`;
+		case NodeType.ObjectDestructuringSet:
+			return `${printDestructuringTarget(/** @type {Node} */ (node.getNode('left')))} = ${serialize(
+				/** @type {Node} */ (node.getNode('right')),
+			)}`;
+		case NodeType.Conditional: {
+			const cond = serialize(/** @type {Node} */ (node.getNode('cond')));
+			const then = serialize(/** @type {Node} */ (node.getNode('then')));
+			const elseNode = node.getNode('else');
+			if (
+				elseNode &&
+				elseNode.type === NodeType.Constant &&
+				elseNode.getAttribute('value') === ''
+			) {
+				return `${cond} ? ${then}`;
+			}
+			return `${cond} ? ${then} : ${elseNode ? serialize(elseNode) : ''}`;
+		}
+		case NodeType.Empty:
+			return '';
+		default:
+			return printNode(node);
+	}
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+function printConstant(value) {
+	if (typeof value === 'string') {
+		return quoteString(value);
+	}
+	if (typeof value === 'number') {
+		return formatNumber(value);
+	}
+	if (typeof value === 'boolean') {
+		return value ? 'true' : 'false';
+	}
+	if (value === null || value === undefined) {
+		return 'null';
+	}
+	if (Array.isArray(value)) {
+		return `[${value.map((item) => printConstant(item)).join(', ')}]`;
+	}
+	if (typeof value === 'object') {
+		const object = /** @type {{name?: unknown, alias?: unknown}} */ (value);
+		if ('name' in object) {
+			const alias = object.alias;
+			if (alias !== undefined && alias !== null && alias !== object.name) {
+				return `${String(object.name)} as ${String(alias)}`;
+			}
+			return String(object.name);
+		}
+	}
+	return String(value);
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printArray(node) {
+	const array = /** @type {any} */ (node);
+	const pairs = /** @type {Array<[Node, Node]>} */ (array.getKeyValuePairs());
+	const sequence = typeof array.isSequence === 'function' ? array.isSequence() : false;
+	if (sequence) {
+		return `[${pairs.map(([, value]) => serialize(value)).join(', ')}]`;
+	}
+	return `{${pairs
+		.map(([key, value]) => `${serialize(key)}: ${serialize(value)}`)
+		.join(', ')}}`;
+}
+
+/**
+ * Prints a `.` attribute (a bare name or number), not a quoted string.
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+function printDotAttribute(node) {
+	if (node.type === NodeType.Constant) {
+		const value = node.getAttribute('value');
+		if (typeof value === 'string' && /^[a-zA-Z_\u007f-\uffff][a-zA-Z0-9_\u007f-\uffff]*$/.test(value)) {
+			return value;
+		}
+		if (typeof value === 'number') {
+			return formatNumber(value);
+		}
+	}
+	return serialize(node);
+}
+
+/**
+ * Prints the left-hand side of a destructuring assignment.
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+function printDestructuringTarget(node) {
+	if (node.type !== NodeType.ArrayExpr) {
+		return printExpression(node);
+	}
+	const array = /** @type {any} */ (node);
+	const pairs = /** @type {Array<[Node, Node]>} */ (array.getKeyValuePairs());
+	if (typeof array.isSequence === 'function' && array.isSequence()) {
+		return `[${pairs.map(([, value]) => printExpression(value)).join(', ')}]`;
+	}
+	const parts = pairs.map(([key, value]) => {
+		const keyName =
+			key.type === NodeType.Constant && typeof key.getAttribute('value') === 'string'
+				? String(key.getAttribute('value'))
+				: null;
+		const valueName =
+			value && (value.type === NodeType.ContextVariable || value.type === NodeType.AssignContextVariable)
+				? String(value.getAttribute('name'))
+				: null;
+		if (keyName !== null && valueName === keyName) {
+			return keyName;
+		}
+		return `${printMappingKey(key)}: ${printExpression(value)}`;
+	});
+	return `{${parts.join(', ')}}`;
+}
+
+/**
+ * Prints a mapping key (bare when it is a valid name).
+ *
+ * @param {Node} key
+ * @returns {string}
+ */
+function printMappingKey(key) {
+	if (key.type === NodeType.Constant) {
+		const value = key.getAttribute('value');
+		if (typeof value === 'string' && /^[a-zA-Z_\u007f-\uffff][a-zA-Z0-9_\u007f-\uffff]*$/.test(value)) {
+			return value;
+		}
+	}
+	return printExpression(key);
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printGetAttr(node) {
+	const base = serialize(/** @type {Node} */ (node.getNode('node')));
+	const attributeNode = /** @type {Node} */ (node.getNode('attribute'));
+	const type = String(node.getAttribute('type') ?? 'any');
+	const nullSafe = Boolean(node.getAttribute('nullSafe'));
+	if (type === 'array') {
+		return `${base}[${serialize(attributeNode)}]`;
+	}
+	const attribute = printDotAttribute(attributeNode);
+	if (type === 'method') {
+		return `${base}${nullSafe ? '?.' : '.'}${attribute}${printArrayArguments(node.getNode('arguments'))}`;
+	}
+	return `${base}${nullSafe ? '?.' : '.'}${attribute}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printMacroReference(node) {
+	const target = node.getNode('var');
+	const name = node.getNode('name');
+	const prefix = target ? printExpression(target) : '';
+	const attribute = name ? printDotAttribute(name) : '';
+	const args = printArrayArguments(node.getNode('arguments'));
+	if (node.getAttribute('hasCallParentheses') === false) {
+		return `${prefix}.${attribute}`;
+	}
+	return `${prefix}.${attribute}${args}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printFilter(node) {
+	const base = serialize(/** @type {Node} */ (node.getNode('node')));
+	const name = String(node.getAttribute('name') ?? '');
+	const args = printArguments(/** @type {any} */ (node.children.arguments));
+	return `${base}|${name}${args}`;
+}
+
+/**
+ * Prints the filter chain of an `apply` tag (whose base is a captured
+ * reference that must not be printed).
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+function printApplyFilter(node) {
+	const parts = [];
+	/** @type {Node|null} */
+	let current = node;
+	while (current && current.type === NodeType.Filter) {
+		const name = String(current.getAttribute('name') ?? '');
+		const args = printArguments(/** @type {any} */ (current.children.arguments));
+		parts.unshift(`${name}${args}`);
+		current = /** @type {Node|null} */ (current.getNode('node'));
+	}
+	return parts.join('|');
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printNodes(node) {
+	const children = node.getNodes('nodes');
+	return children.map((child) => serialize(child)).join('');
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printIf(node) {
+	const tests = /** @type {Node[]} */ (node.children.tests ?? []);
+	const elseBody = node.getNode('elseBody');
+	let out = '{% if ';
+	for (let i = 0; i < tests.length; i += 2) {
+		const condition = serialize(tests[i]);
+		const body = tests[i + 1] ? serialize(tests[i + 1]) : '';
+		if (i === 0) {
+			out += `${condition} %}${body}`;
+		} else {
+			out += `{% elseif ${condition} %}${body}`;
+		}
+	}
+	if (elseBody) {
+		out += `{% else %}${printBody(elseBody)}`;
+	}
+	return `${out}{% endif %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printFor(node) {
+	const keyTarget = /** @type {Node|null} */ (node.getNode('keyTarget'));
+	const valueTarget = /** @type {Node|null} */ (node.getNode('valueTarget'));
+	const seq = serialize(/** @type {Node} */ (node.getNode('seq')));
+	const body = printBody(node.getNode('body'));
+	const elseBody = node.getNode('elseBody');
+	/** @type {string[]} */
+	const targets = [];
+	if (keyTarget && keyTarget.getAttribute('name') !== '_key') {
+		targets.push(serialize(keyTarget));
+	}
+	if (valueTarget) {
+		targets.push(serialize(valueTarget));
+	}
+	const elsePart = elseBody ? `{% else %}${printBody(elseBody)}` : '';
+	return `{% for ${targets.join(', ')} in ${seq} %}${body}${elsePart}{% endfor %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printSet(node) {
+	const capture = Boolean(node.getAttribute('capture'));
+	const namesNode = node.getNode('names');
+	const names = namesNode ? namesNode.getNodes('nodes') : [];
+	if (capture) {
+		return `{% set ${names.map((name) => serialize(name)).join(', ')} %}${printBody(
+			node.getNode('body'),
+		)}{% endset %}`;
+	}
+	const valuesNode = node.getNode('values');
+	const values = valuesNode ? valuesNode.getNodes('nodes') : [];
+	return `{% set ${names.map((name) => serialize(name)).join(', ')} = ${values
+		.map((value) => serialize(value))
+		.join(', ')} %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printBlock(node) {
+	const name = String(node.getAttribute('name') ?? '');
+	return `{% block ${name} %}${printBody(node.getNode('body'))}{% endblock %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printMacro(node) {
+	const name = String(node.getAttribute('name') ?? '');
+	const variadicName = node.getAttribute('variadicName');
+	const args = /** @type {Array<[string, Node]>} */ (node.getAttribute('arguments') ?? []);
+	const parts = args.map(([argumentName, defaultNode]) => {
+		if (defaultNode && defaultNode.getAttribute('is_implicit')) {
+			return argumentName;
+		}
+		return `${argumentName} = ${serialize(defaultNode)}`;
+	});
+	if (variadicName) {
+		parts.push(`...${variadicName}`);
+	}
+	return `{% macro ${name}(${parts.join(', ')}) %}${printBody(
+		node.getNode('body'),
+	)}{% endmacro %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printInclude(node) {
+	const expr = serialize(/** @type {Node} */ (node.getNode('expr')));
+	const ignoreMissing = node.getNode('ignoreMissing')?.getAttribute('value');
+	const variables = node.getNode('variables');
+	const only = node.getNode('only')?.getAttribute('value');
+	let out = `{% include ${expr}`;
+	if (ignoreMissing) {
+		out += ' ignore missing';
+	}
+	if (variables) {
+		out += ` with ${serialize(variables)}`;
+	}
+	if (only) {
+		out += ' only';
+	}
+	return `${out} %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printImport(node) {
+	const expr = serialize(/** @type {Node} */ (node.getNode('expr')));
+	const targets = node.getNode('targets');
+	if (targets) {
+		const parts = targets.getNodes('nodes').map((target) => printConstant(target.getAttribute('value')));
+		return `{% from ${expr} import ${parts.join(', ')} %}`;
+	}
+	const variable = node.getNode('var');
+	const name = variable ? String(variable.getAttribute('name') ?? '') : '';
+	return `{% import ${expr} as ${name} %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printUse(node) {
+	const template = serialize(/** @type {Node} */ (node.getNode('template')));
+	const targets = node.getNode('targets');
+	const parts = targets
+		? targets.getNodes('nodes').map((target) => printConstant(target.getAttribute('value')))
+		: [];
+	const withPart = parts.length ? ` with ${parts.join(', ')}` : '';
+	return `{% use ${template}${withPart} %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printWith(node) {
+	const variables = node.getNode('variables');
+	const only = Boolean(node.getAttribute('only'));
+	let out = '{% with';
+	if (variables) {
+		out += ` ${serialize(variables)}`;
+	}
+	if (only) {
+		out += ' only';
+	}
+	return `${out} %}${printBody(node.getNode('body'))}{% endwith %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printAutoEscape(node) {
+	const value = node.getAttribute('value');
+	const strategy = value === undefined || value === null ? '' : ` ${printConstant(value)}`;
+	return `{% autoescape${strategy} %}${printBody(node.getNode('body'))}{% endautoescape %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printDeprecated(node) {
+	let out = `{% deprecated ${serialize(/** @type {Node} */ (node.getNode('expr')))}`;
+	const packageNode = node.getNode('package');
+	const versionNode = node.getNode('version');
+	if (packageNode) {
+		out += ` package=${serialize(packageNode)}`;
+	}
+	if (versionNode) {
+		out += ` version=${serialize(versionNode)}`;
+	}
+	return `${out} %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printTypes(node) {
+	const types = /** @type {Array<{name: string, type: string, optional: boolean}>} */ (
+		node.getAttribute('types') ?? []
+	);
+	const parts = types.map(
+		(type) => `${type.name}${type.optional ? '?' : ''}: ${quoteString(type.type)}`,
+	);
+	const body = node.getAttribute('enclosed') ? `{${parts.join(', ')}}` : parts.join(', ');
+	return `{% types ${body} %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printApply(node) {
+	const children = node.getNodes('nodes');
+	if (children.length !== 2) {
+		return printNodes(node);
+	}
+	const setNode = children[0];
+	const printNode2 = children[1];
+	const filter = printNode2.getNode('expr');
+	if (!filter) {
+		return printNodes(node);
+	}
+	return `{% apply ${printApplyFilter(filter)} %}${printBody(
+		setNode.getNode('body'),
+	)}{% endapply %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printGuard(node) {
+	const guardType = String(node.getAttribute('guardType') ?? '');
+	const guardName = String(node.getAttribute('guardName') ?? '');
+	const exists = Boolean(node.getAttribute('guardExists'));
+	const body = node.getNodes('nodes')[0];
+	const elsePart = exists ? '' : '{% else %}';
+	return `{% guard ${guardType} ${guardName} %}${elsePart}${printBody(body)}{% endguard %}`;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string}
+ */
+function printEmbed(node) {
+	const exprNode = /** @type {Node|null} */ (node.getAttribute('parent') ?? node.getNode('expr'));
+	const expr = exprNode ? serialize(exprNode) : '';
+	const ignoreMissing = node.getNode('ignoreMissing')?.getAttribute('value');
+	const variables = node.getNode('variables');
+	const only = node.getNode('only')?.getAttribute('value');
+	let out = `{% embed ${expr}`;
+	if (ignoreMissing) {
+		out += ' ignore missing';
+	}
+	if (variables) {
+		out += ` with ${serialize(variables)}`;
+	}
+	if (only) {
+		out += ' only';
+	}
+	const embedded = /** @type {Node|null} */ (node.getAttribute('embedded') ?? null);
+	const body = embedded ? printEmbeddedBody(embedded) : '';
+	return `${out} %}${body}{% endembed %}`;
+}
+
+/**
+ * Prints the body of an embedded template: its block definitions in order
+ * (the injected `extends` empties the inline body).
+ *
+ * @param {Node} module
+ * @returns {string}
+ */
+function printEmbeddedBody(module) {
+	const blocks = module.children.blocks;
+	if (blocks && typeof blocks === 'object' && !Array.isArray(blocks) && !(blocks instanceof Node)) {
+		const definitions = Object.values(/** @type {Record<string, Node>} */ (blocks));
+		if (definitions.length) {
+			return definitions.map((block) => printBlock(block)).join('');
+		}
+	}
+	return printBody(module.getNode('body'));
+}
+
+/**
+ * Prints a node subtree as Twig source.
+ *
+ * @param {Node} node
+ * @returns {string}
+ */
+export function printNode(node) {
+	// `NodeType.Set` and `NodeType.SetBinary` share the value "set" (the
+	// reference implementation uses one string for both), so disambiguate by
+	// shape before switching.
+	if (node.type === NodeType.Set && node.children.left !== undefined && node.children.names === undefined) {
+		return printExpression(node);
+	}
+	switch (node.type) {
+		case NodeType.Module: {
+			const body = node.getNode('body');
+			const trailing = String(node.getAttribute('trailing') ?? '');
+			return `${body ? serialize(body) : ''}${trailing}`;
+		}
+		case NodeType.Body:
+			return printNodes(node);
+		case NodeType.Nodes: {
+			if (node.getAttribute('desugared') === 'apply') {
+				return printApply(node);
+			}
+			if (node.getAttribute('guardType') !== undefined) {
+				return printGuard(node);
+			}
+			return printNodes(node);
+		}
+		case NodeType.Text:
+			return String(node.getAttribute('data') ?? '');
+		case NodeType.Print:
+			return `{{ ${serialize(/** @type {Node} */ (node.getNode('expr')))} }}`;
+		case NodeType.Set:
+			return printSet(node);
+		case NodeType.For:
+			return printFor(node);
+		case NodeType.If:
+			return printIf(node);
+		case NodeType.Block:
+			return printBlock(node);
+		case NodeType.BlockReference: {
+			const block = /** @type {Node|null} */ (node.getAttribute('block') ?? null);
+			return block ? printBlock(block) : '';
+		}
+		case NodeType.Macro:
+			return printMacro(node);
+		case NodeType.MacroDeclaration: {
+			const macro = /** @type {Node|null} */ (node.getAttribute('macro') ?? null);
+			return macro ? printMacro(macro) : '';
+		}
+		case NodeType.Extends: {
+			const parent = /** @type {Node|null} */ (node.getAttribute('parent') ?? null);
+			return `{% extends ${parent ? serialize(parent) : ''} %}`;
+		}
+		case NodeType.Include:
+			return printInclude(node);
+		case NodeType.Import:
+			return printImport(node);
+		case NodeType.Use:
+			return printUse(node);
+		case NodeType.With:
+			return printWith(node);
+		case NodeType.Do:
+			return `{% do ${serialize(/** @type {Node} */ (node.getNode('expr')))} %}`;
+		case NodeType.AutoEscape:
+			return printAutoEscape(node);
+		case NodeType.Sandbox:
+			return `{% sandbox %}${printBody(node.getNode('body'))}{% endsandbox %}`;
+		case NodeType.Deprecated:
+			return printDeprecated(node);
+		case NodeType.Flush:
+			return '{% flush %}';
+		case NodeType.Types:
+			return printTypes(node);
+		case NodeType.Embed:
+			return printEmbed(node);
+		case NodeType.Guard:
+			return printGuard(node);
+		case NodeType.Empty:
+			return '';
+		default:
+			if (node.raw !== null) {
+				return node.raw;
+			}
+			return printExpression(node);
+	}
+}