@glimmer/syntax/dist/modules/es5/lib/v2-a/normalize.js

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

import { assert, assign, isPresent } from '@glimmer/util';
import Printer from '../generation/printer';
import { preprocess } from '../parser/tokenizer-event-handlers';
import { SourceSlice } from '../source/slice';
import { SpanList } from '../source/span-list';
import { SymbolTable } from '../symbol-table';
import { generateSyntaxError } from '../syntax-error';
import { isLowerCase, isUpperCase } from '../utils';
import b from '../v1/parser-builders';
import * as ASTv2 from './api';
import { Builder } from './builders';
import { AppendSyntaxContext, AttrValueSyntaxContext, BlockSyntaxContext, ComponentSyntaxContext, ModifierSyntaxContext, SexpSyntaxContext } from './loose-resolution';
export function normalize(source, options) {
  if (options === void 0) {
    options = {};
  }

  var _a;

  var ast = preprocess(source, options);
  var normalizeOptions = assign({
    strictMode: false,
    locals: []
  }, options);
  var top = SymbolTable.top(normalizeOptions.locals, (_a = // eslint-disable-next-line @typescript-eslint/unbound-method
  options.customizeComponentName) !== null && _a !== void 0 ? _a : function (name) {
    return name;
  });
  var block = new BlockContext(source, normalizeOptions, top);
  var normalizer = new StatementNormalizer(block);
  var astV2 = new TemplateChildren(block.loc(ast.loc), ast.body.map(function (b) {
    return normalizer.normalize(b);
  }), block).assertTemplate(top);
  var locals = top.getUsedTemplateLocals();
  return [astV2, locals];
}
/**
 * A `BlockContext` represents the block that a particular AST node is contained inside of.
 *
 * `BlockContext` is aware of template-wide options (such as strict mode), as well as the bindings
 * that are in-scope within that block.
 *
 * Concretely, it has the `PrecompileOptions` and current `SymbolTable`, and provides
 * facilities for working with those options.
 *
 * `BlockContext` is stateless.
 */

export var BlockContext = /*#__PURE__*/function () {
  function BlockContext(source, options, table) {
    this.source = source;
    this.options = options;
    this.table = table;
    this.builder = new Builder();
  }

  var _proto = BlockContext.prototype;

  _proto.loc = function loc(_loc) {
    return this.source.spanFor(_loc);
  };

  _proto.resolutionFor = function resolutionFor(node, resolution) {
    if (this.strict) {
      return {
        resolution: ASTv2.STRICT_RESOLUTION
      };
    }

    if (this.isFreeVar(node)) {
      var r = resolution(node);

      if (r === null) {
        return {
          resolution: 'error',
          path: printPath(node),
          head: printHead(node)
        };
      }

      return {
        resolution: r
      };
    } else {
      return {
        resolution: ASTv2.STRICT_RESOLUTION
      };
    }
  };

  _proto.isFreeVar = function isFreeVar(callee) {
    if (callee.type === 'PathExpression') {
      if (callee.head.type !== 'VarHead') {
        return false;
      }

      return !this.table.has(callee.head.name);
    } else if (callee.path.type === 'PathExpression') {
      return this.isFreeVar(callee.path);
    } else {
      return false;
    }
  };

  _proto.hasBinding = function hasBinding(name) {
    return this.table.has(name);
  };

  _proto.child = function child(blockParams) {
    return new BlockContext(this.source, this.options, this.table.child(blockParams));
  };

  _proto.customizeComponentName = function customizeComponentName(input) {
    if (this.options.customizeComponentName) {
      return this.options.customizeComponentName(input);
    } else {
      return input;
    }
  };

  _createClass(BlockContext, [{
    key: "strict",
    get: function get() {
      return this.options.strictMode || false;
    }
  }]);

  return BlockContext;
}();
/**
 * An `ExpressionNormalizer` normalizes expressions within a block.
 *
 * `ExpressionNormalizer` is stateless.
 */

var ExpressionNormalizer = /*#__PURE__*/function () {
  function ExpressionNormalizer(block) {
    this.block = block;
  }

  var _proto2 = ExpressionNormalizer.prototype;

  _proto2.normalize = function normalize(expr, resolution) {
    switch (expr.type) {
      case 'NullLiteral':
      case 'BooleanLiteral':
      case 'NumberLiteral':
      case 'StringLiteral':
      case 'UndefinedLiteral':
        return this.block.builder.literal(expr.value, this.block.loc(expr.loc));

      case 'PathExpression':
        return this.path(expr, resolution);

      case 'SubExpression':
        {
          var _resolution = this.block.resolutionFor(expr, SexpSyntaxContext);

          if (_resolution.resolution === 'error') {
            throw generateSyntaxError("You attempted to invoke a path (`" + _resolution.path + "`) but " + _resolution.head + " was not in scope", expr.loc);
          }

          return this.block.builder.sexp(this.callParts(expr, _resolution.resolution), this.block.loc(expr.loc));
        }
    }
  };

  _proto2.path = function path(expr, resolution) {
    var headOffsets = this.block.loc(expr.head.loc);
    var tail = []; // start with the head

    var offset = headOffsets;

    for (var _iterator = _createForOfIteratorHelperLoose(expr.tail), _step; !(_step = _iterator()).done;) {
      var part = _step.value;
      offset = offset.sliceStartChars({
        chars: part.length,
        skipStart: 1
      });
      tail.push(new SourceSlice({
        loc: offset,
        chars: part
      }));
    }

    return this.block.builder.path(this.ref(expr.head, resolution), tail, this.block.loc(expr.loc));
  }
  /**
   * The `callParts` method takes ASTv1.CallParts as well as a syntax context and normalizes
   * it to an ASTv2 CallParts.
   */
  ;

  _proto2.callParts = function callParts(parts, context) {
    var _this = this;

    var path = parts.path,
        params = parts.params,
        hash = parts.hash;
    var callee = this.normalize(path, context);
    var paramList = params.map(function (p) {
      return _this.normalize(p, ASTv2.ARGUMENT_RESOLUTION);
    });
    var paramLoc = SpanList.range(paramList, callee.loc.collapse('end'));
    var namedLoc = this.block.loc(hash.loc);
    var argsLoc = SpanList.range([paramLoc, namedLoc]);
    var positional = this.block.builder.positional(params.map(function (p) {
      return _this.normalize(p, ASTv2.ARGUMENT_RESOLUTION);
    }), paramLoc);
    var named = this.block.builder.named(hash.pairs.map(function (p) {
      return _this.namedArgument(p);
    }), this.block.loc(hash.loc));
    return {
      callee: callee,
      args: this.block.builder.args(positional, named, argsLoc)
    };
  };

  _proto2.namedArgument = function namedArgument(pair) {
    var offsets = this.block.loc(pair.loc);
    var keyOffsets = offsets.sliceStartChars({
      chars: pair.key.length
    });
    return this.block.builder.namedArgument(new SourceSlice({
      chars: pair.key,
      loc: keyOffsets
    }), this.normalize(pair.value, ASTv2.ARGUMENT_RESOLUTION));
  }
  /**
   * The `ref` method normalizes an `ASTv1.PathHead` into an `ASTv2.VariableReference`.
   * This method is extremely important, because it is responsible for normalizing free
   * variables into an an ASTv2.PathHead *with appropriate context*.
   *
   * The syntax context is originally determined by the syntactic position that this `PathHead`
   * came from, and is ultimately attached to the `ASTv2.VariableReference` here. In ASTv2,
   * the `VariableReference` node bears full responsibility for loose mode rules that control
   * the behavior of free variables.
   */
  ;

  _proto2.ref = function ref(head, resolution) {
    var block = this.block;
    var builder = block.builder,
        table = block.table;
    var offsets = block.loc(head.loc);

    switch (head.type) {
      case 'ThisHead':
        return builder.self(offsets);

      case 'AtHead':
        {
          var symbol = table.allocateNamed(head.name);
          return builder.at(head.name, symbol, offsets);
        }

      case 'VarHead':
        {
          if (block.hasBinding(head.name)) {
            var _table$get = table.get(head.name),
                _symbol = _table$get[0],
                isRoot = _table$get[1];

            return block.builder.localVar(head.name, _symbol, isRoot, offsets);
          } else {
            var context = block.strict ? ASTv2.STRICT_RESOLUTION : resolution;

            var _symbol2 = block.table.allocateFree(head.name, context);

            return block.builder.freeVar({
              name: head.name,
              context: context,
              symbol: _symbol2,
              loc: offsets
            });
          }
        }
    }
  };

  return ExpressionNormalizer;
}();
/**
 * `TemplateNormalizer` normalizes top-level ASTv1 statements to ASTv2.
 */


var StatementNormalizer = /*#__PURE__*/function () {
  function StatementNormalizer(block) {
    this.block = block;
  }

  var _proto3 = StatementNormalizer.prototype;

  _proto3.normalize = function normalize(node) {
    switch (node.type) {
      case 'PartialStatement':
        throw new Error("Handlebars partial syntax ({{> ...}}) is not allowed in Glimmer");

      case 'BlockStatement':
        return this.BlockStatement(node);

      case 'ElementNode':
        return new ElementNormalizer(this.block).ElementNode(node);

      case 'MustacheStatement':
        return this.MustacheStatement(node);
      // These are the same in ASTv2

      case 'MustacheCommentStatement':
        return this.MustacheCommentStatement(node);

      case 'CommentStatement':
        {
          var loc = this.block.loc(node.loc);
          return new ASTv2.HtmlComment({
            loc: loc,
            text: loc.slice({
              skipStart: 4,
              skipEnd: 3
            }).toSlice(node.value)
          });
        }

      case 'TextNode':
        return new ASTv2.HtmlText({
          loc: this.block.loc(node.loc),
          chars: node.chars
        });
    }
  };

  _proto3.MustacheCommentStatement = function MustacheCommentStatement(node) {
    var loc = this.block.loc(node.loc);
    var textLoc;

    if (loc.asString().slice(0, 5) === '{{!--') {
      textLoc = loc.slice({
        skipStart: 5,
        skipEnd: 4
      });
    } else {
      textLoc = loc.slice({
        skipStart: 3,
        skipEnd: 2
      });
    }

    return new ASTv2.GlimmerComment({
      loc: loc,
      text: textLoc.toSlice(node.value)
    });
  }
  /**
   * Normalizes an ASTv1.MustacheStatement to an ASTv2.AppendStatement
   */
  ;

  _proto3.MustacheStatement = function MustacheStatement(mustache) {
    var escaped = mustache.escaped;
    var loc = this.block.loc(mustache.loc); // Normalize the call parts in AppendSyntaxContext

    var callParts = this.expr.callParts({
      path: mustache.path,
      params: mustache.params,
      hash: mustache.hash
    }, AppendSyntaxContext(mustache));
    var value = callParts.args.isEmpty() ? callParts.callee : this.block.builder.sexp(callParts, loc);
    return this.block.builder.append({
      table: this.block.table,
      trusting: !escaped,
      value: value
    }, loc);
  }
  /**
   * Normalizes a ASTv1.BlockStatement to an ASTv2.BlockStatement
   */
  ;

  _proto3.BlockStatement = function BlockStatement(block) {
    var program = block.program,
        inverse = block.inverse;
    var loc = this.block.loc(block.loc);
    var resolution = this.block.resolutionFor(block, BlockSyntaxContext);

    if (resolution.resolution === 'error') {
      throw generateSyntaxError("You attempted to invoke a path (`{{#" + resolution.path + "}}`) but " + resolution.head + " was not in scope", loc);
    }

    var callParts = this.expr.callParts(block, resolution.resolution);
    return this.block.builder.blockStatement(assign({
      symbols: this.block.table,
      program: this.Block(program),
      inverse: inverse ? this.Block(inverse) : null
    }, callParts), loc);
  };

  _proto3.Block = function Block(_ref) {
    var body = _ref.body,
        loc = _ref.loc,
        blockParams = _ref.blockParams;
    var child = this.block.child(blockParams);
    var normalizer = new StatementNormalizer(child);
    return new BlockChildren(this.block.loc(loc), body.map(function (b) {
      return normalizer.normalize(b);
    }), this.block).assertBlock(child.table);
  };

  _createClass(StatementNormalizer, [{
    key: "expr",
    get: function get() {
      return new ExpressionNormalizer(this.block);
    }
  }]);

  return StatementNormalizer;
}();

var ElementNormalizer = /*#__PURE__*/function () {
  function ElementNormalizer(ctx) {
    this.ctx = ctx;
  }
  /**
   * Normalizes an ASTv1.ElementNode to:
   *
   * - ASTv2.NamedBlock if the tag name begins with `:`
   * - ASTv2.Component if the tag name matches the component heuristics
   * - ASTv2.SimpleElement if the tag name doesn't match the component heuristics
   *
   * A tag name represents a component if:
   *
   * - it begins with `@`
   * - it is exactly `this` or begins with `this.`
   * - the part before the first `.` is a reference to an in-scope variable binding
   * - it begins with an uppercase character
   */


  var _proto4 = ElementNormalizer.prototype;

  _proto4.ElementNode = function ElementNode(element) {
    var _this2 = this;

    var tag = element.tag,
        selfClosing = element.selfClosing,
        comments = element.comments;
    var loc = this.ctx.loc(element.loc);

    var _tag$split = tag.split('.'),
        tagHead = _tag$split[0],
        rest = _tag$split.slice(1); // the head, attributes and modifiers are in the current scope


    var path = this.classifyTag(tagHead, rest, element.loc);
    var attrs = element.attributes.filter(function (a) {
      return a.name[0] !== '@';
    }).map(function (a) {
      return _this2.attr(a);
    });
    var args = element.attributes.filter(function (a) {
      return a.name[0] === '@';
    }).map(function (a) {
      return _this2.arg(a);
    });
    var modifiers = element.modifiers.map(function (m) {
      return _this2.modifier(m);
    }); // the element's block params are in scope for the children

    var child = this.ctx.child(element.blockParams);
    var normalizer = new StatementNormalizer(child);
    var childNodes = element.children.map(function (s) {
      return normalizer.normalize(s);
    });
    var el = this.ctx.builder.element({
      selfClosing: selfClosing,
      attrs: attrs,
      componentArgs: args,
      modifiers: modifiers,
      comments: comments.map(function (c) {
        return new StatementNormalizer(_this2.ctx).MustacheCommentStatement(c);
      })
    });
    var children = new ElementChildren(el, loc, childNodes, this.ctx);
    var offsets = this.ctx.loc(element.loc);
    var tagOffsets = offsets.sliceStartChars({
      chars: tag.length,
      skipStart: 1
    });

    if (path === 'ElementHead') {
      if (tag[0] === ':') {
        return children.assertNamedBlock(tagOffsets.slice({
          skipStart: 1
        }).toSlice(tag.slice(1)), child.table);
      } else {
        return children.assertElement(tagOffsets.toSlice(tag), element.blockParams.length > 0);
      }
    }

    if (element.selfClosing) {
      return el.selfClosingComponent(path, loc);
    } else {
      var blocks = children.assertComponent(tag, child.table, element.blockParams.length > 0);
      return el.componentWithNamedBlocks(path, blocks, loc);
    }
  };

  _proto4.modifier = function modifier(m) {
    var resolution = this.ctx.resolutionFor(m, ModifierSyntaxContext);

    if (resolution.resolution === 'error') {
      throw generateSyntaxError("You attempted to invoke a path (`{{#" + resolution.path + "}}`) as a modifier, but " + resolution.head + " was not in scope. Try adding `this` to the beginning of the path", m.loc);
    }

    var callParts = this.expr.callParts(m, resolution.resolution);
    return this.ctx.builder.modifier(callParts, this.ctx.loc(m.loc));
  }
  /**
   * This method handles attribute values that are curlies, as well as curlies nested inside of
   * interpolations:
   *
   * ```hbs
   * <a href={{url}} />
   * <a href="{{url}}.html" />
   * ```
   */
  ;

  _proto4.mustacheAttr = function mustacheAttr(mustache) {
    // Normalize the call parts in AttrValueSyntaxContext
    var sexp = this.ctx.builder.sexp(this.expr.callParts(mustache, AttrValueSyntaxContext(mustache)), this.ctx.loc(mustache.loc)); // If there are no params or hash, just return the function part as its own expression

    if (sexp.args.isEmpty()) {
      return sexp.callee;
    } else {
      return sexp;
    }
  }
  /**
   * attrPart is the narrowed down list of valid attribute values that are also
   * allowed as a concat part (you can't nest concats).
   */
  ;

  _proto4.attrPart = function attrPart(part) {
    switch (part.type) {
      case 'MustacheStatement':
        return {
          expr: this.mustacheAttr(part),
          trusting: !part.escaped
        };

      case 'TextNode':
        return {
          expr: this.ctx.builder.literal(part.chars, this.ctx.loc(part.loc)),
          trusting: true
        };
    }
  };

  _proto4.attrValue = function attrValue(part) {
    var _this3 = this;

    switch (part.type) {
      case 'ConcatStatement':
        {
          var parts = part.parts.map(function (p) {
            return _this3.attrPart(p).expr;
          });
          return {
            expr: this.ctx.builder.interpolate(parts, this.ctx.loc(part.loc)),
            trusting: false
          };
        }

      default:
        return this.attrPart(part);
    }
  };

  _proto4.attr = function attr(m) {
    false && assert(m.name[0] !== '@', 'An attr name must not start with `@`');

    if (m.name === '...attributes') {
      return this.ctx.builder.splatAttr(this.ctx.table.allocateBlock('attrs'), this.ctx.loc(m.loc));
    }

    var offsets = this.ctx.loc(m.loc);
    var nameSlice = offsets.sliceStartChars({
      chars: m.name.length
    }).toSlice(m.name);
    var value = this.attrValue(m.value);
    return this.ctx.builder.attr({
      name: nameSlice,
      value: value.expr,
      trusting: value.trusting
    }, offsets);
  };

  _proto4.maybeDeprecatedCall = function maybeDeprecatedCall(arg, part) {
    if (this.ctx.strict) {
      return null;
    }

    if (part.type !== 'MustacheStatement') {
      return null;
    }

    var path = part.path;

    if (path.type !== 'PathExpression') {
      return null;
    }

    if (path.head.type !== 'VarHead') {
      return null;
    }

    var name = path.head.name;

    if (name === 'has-block' || name === 'has-block-params') {
      return null;
    }

    if (this.ctx.hasBinding(name)) {
      return null;
    }

    if (path.tail.length !== 0) {
      return null;
    }

    if (part.params.length !== 0 || part.hash.pairs.length !== 0) {
      return null;
    }

    var context = ASTv2.LooseModeResolution.attr();
    var callee = this.ctx.builder.freeVar({
      name: name,
      context: context,
      symbol: this.ctx.table.allocateFree(name, context),
      loc: path.loc
    });
    return {
      expr: this.ctx.builder.deprecatedCall(arg, callee, part.loc),
      trusting: false
    };
  };

  _proto4.arg = function arg(_arg) {
    false && assert(_arg.name[0] === '@', 'An arg name must start with `@`');
    var offsets = this.ctx.loc(_arg.loc);
    var nameSlice = offsets.sliceStartChars({
      chars: _arg.name.length
    }).toSlice(_arg.name);
    var value = this.maybeDeprecatedCall(nameSlice, _arg.value) || this.attrValue(_arg.value);
    return this.ctx.builder.arg({
      name: nameSlice,
      value: value.expr,
      trusting: value.trusting
    }, offsets);
  }
  /**
   * This function classifies the head of an ASTv1.Element into an ASTv2.PathHead (if the
   * element is a component) or `'ElementHead'` (if the element is a simple element).
   *
   * Rules:
   *
   * 1. If the variable is an `@arg`, return an `AtHead`
   * 2. If the variable is `this`, return a `ThisHead`
   * 3. If the variable is in the current scope:
   *   a. If the scope is the root scope, then return a Free `LocalVarHead`
   *   b. Else, return a standard `LocalVarHead`
   * 4. If the tag name is a path and the variable is not in the current scope, Syntax Error
   * 5. If the variable is uppercase return a FreeVar(ResolveAsComponentHead)
   * 6. Otherwise, return `'ElementHead'`
   */
  ;

  _proto4.classifyTag = function classifyTag(variable, tail, loc) {
    var uppercase = isUpperCase(variable);
    var inScope = variable[0] === '@' || variable === 'this' || this.ctx.hasBinding(variable);

    if (this.ctx.strict && !inScope) {
      if (uppercase) {
        throw generateSyntaxError("Attempted to invoke a component that was not in scope in a strict mode template, `<" + variable + ">`. If you wanted to create an element with that name, convert it to lowercase - `<" + variable.toLowerCase() + ">`", loc);
      } // In strict mode, values are always elements unless they are in scope


      return 'ElementHead';
    } // Since the parser handed us the HTML element name as a string, we need
    // to convert it into an ASTv1 path so it can be processed using the
    // expression normalizer.


    var isComponent = inScope || uppercase;
    var variableLoc = loc.sliceStartChars({
      skipStart: 1,
      chars: variable.length
    });
    var tailLength = tail.reduce(function (accum, part) {
      return accum + 1 + part.length;
    }, 0);
    var pathEnd = variableLoc.getEnd().move(tailLength);
    var pathLoc = variableLoc.withEnd(pathEnd);

    if (isComponent) {
      var path = b.path({
        head: b.head(variable, variableLoc),
        tail: tail,
        loc: pathLoc
      });
      var resolution = this.ctx.resolutionFor(path, ComponentSyntaxContext);

      if (resolution.resolution === 'error') {
        throw generateSyntaxError("You attempted to invoke a path (`<" + resolution.path + ">`) but " + resolution.head + " was not in scope", loc);
      }

      return new ExpressionNormalizer(this.ctx).normalize(path, resolution.resolution);
    } // If the tag name wasn't a valid component but contained a `.`, it's
    // a syntax error.


    if (tail.length > 0) {
      throw generateSyntaxError("You used " + variable + "." + tail.join('.') + " as a tag name, but " + variable + " is not in scope", loc);
    }

    return 'ElementHead';
  };

  _createClass(ElementNormalizer, [{
    key: "expr",
    get: function get() {
      return new ExpressionNormalizer(this.ctx);
    }
  }]);

  return ElementNormalizer;
}();

var Children = function Children(loc, children, block) {
  this.loc = loc;
  this.children = children;
  this.block = block;
  this.namedBlocks = children.filter(function (c) {
    return c instanceof ASTv2.NamedBlock;
  });
  this.hasSemanticContent = Boolean(children.filter(function (c) {
    if (c instanceof ASTv2.NamedBlock) {
      return false;
    }

    switch (c.type) {
      case 'GlimmerComment':
      case 'HtmlComment':
        return false;

      case 'HtmlText':
        return !/^\s*$/.exec(c.chars);

      default:
        return true;
    }
  }).length);
  this.nonBlockChildren = children.filter(function (c) {
    return !(c instanceof ASTv2.NamedBlock);
  });
};

var TemplateChildren = /*#__PURE__*/function (_Children) {
  _inheritsLoose(TemplateChildren, _Children);

  function TemplateChildren() {
    return _Children.apply(this, arguments) || this;
  }

  var _proto5 = TemplateChildren.prototype;

  _proto5.assertTemplate = function assertTemplate(table) {
    if (isPresent(this.namedBlocks)) {
      throw generateSyntaxError("Unexpected named block at the top-level of a template", this.loc);
    }

    return this.block.builder.template(table, this.nonBlockChildren, this.block.loc(this.loc));
  };

  return TemplateChildren;
}(Children);

var BlockChildren = /*#__PURE__*/function (_Children2) {
  _inheritsLoose(BlockChildren, _Children2);

  function BlockChildren() {
    return _Children2.apply(this, arguments) || this;
  }

  var _proto6 = BlockChildren.prototype;

  _proto6.assertBlock = function assertBlock(table) {
    if (isPresent(this.namedBlocks)) {
      throw generateSyntaxError("Unexpected named block nested in a normal block", this.loc);
    }

    return this.block.builder.block(table, this.nonBlockChildren, this.loc);
  };

  return BlockChildren;
}(Children);

var ElementChildren = /*#__PURE__*/function (_Children3) {
  _inheritsLoose(ElementChildren, _Children3);

  function ElementChildren(el, loc, children, block) {
    var _this4;

    _this4 = _Children3.call(this, loc, children, block) || this;
    _this4.el = el;
    return _this4;
  }

  var _proto7 = ElementChildren.prototype;

  _proto7.assertNamedBlock = function assertNamedBlock(name, table) {
    if (this.el.base.selfClosing) {
      throw generateSyntaxError("<:" + name.chars + "/> is not a valid named block: named blocks cannot be self-closing", this.loc);
    }

    if (isPresent(this.namedBlocks)) {
      throw generateSyntaxError("Unexpected named block inside <:" + name.chars + "> named block: named blocks cannot contain nested named blocks", this.loc);
    }

    if (!isLowerCase(name.chars)) {
      throw generateSyntaxError("<:" + name.chars + "> is not a valid named block, and named blocks must begin with a lowercase letter", this.loc);
    }

    if (this.el.base.attrs.length > 0 || this.el.base.componentArgs.length > 0 || this.el.base.modifiers.length > 0) {
      throw generateSyntaxError("named block <:" + name.chars + "> cannot have attributes, arguments, or modifiers", this.loc);
    }

    var offsets = SpanList.range(this.nonBlockChildren, this.loc);
    return this.block.builder.namedBlock(name, this.block.builder.block(table, this.nonBlockChildren, offsets), this.loc);
  };

  _proto7.assertElement = function assertElement(name, hasBlockParams) {
    if (hasBlockParams) {
      throw generateSyntaxError("Unexpected block params in <" + name + ">: simple elements cannot have block params", this.loc);
    }

    if (isPresent(this.namedBlocks)) {
      var names = this.namedBlocks.map(function (b) {
        return b.name;
      });

      if (names.length === 1) {
        throw generateSyntaxError("Unexpected named block <:foo> inside <" + name.chars + "> HTML element", this.loc);
      } else {
        var printedNames = names.map(function (n) {
          return "<:" + n.chars + ">";
        }).join(', ');
        throw generateSyntaxError("Unexpected named blocks inside <" + name.chars + "> HTML element (" + printedNames + ")", this.loc);
      }
    }

    return this.el.simple(name, this.nonBlockChildren, this.loc);
  };

  _proto7.assertComponent = function assertComponent(name, table, hasBlockParams) {
    if (isPresent(this.namedBlocks) && this.hasSemanticContent) {
      throw generateSyntaxError("Unexpected content inside <" + name + "> component invocation: when using named blocks, the tag cannot contain other content", this.loc);
    }

    if (isPresent(this.namedBlocks)) {
      if (hasBlockParams) {
        throw generateSyntaxError("Unexpected block params list on <" + name + "> component invocation: when passing named blocks, the invocation tag cannot take block params", this.loc);
      }

      var seenNames = new Set();

      for (var _iterator2 = _createForOfIteratorHelperLoose(this.namedBlocks), _step2; !(_step2 = _iterator2()).done;) {
        var block = _step2.value;
        var _name = block.name.chars;

        if (seenNames.has(_name)) {
          throw generateSyntaxError("Component had two named blocks with the same name, `<:" + _name + ">`. Only one block with a given name may be passed", this.loc);
        }

        if (_name === 'inverse' && seenNames.has('else') || _name === 'else' && seenNames.has('inverse')) {
          throw generateSyntaxError("Component has both <:else> and <:inverse> block. <:inverse> is an alias for <:else>", this.loc);
        }

        seenNames.add(_name);
      }

      return this.namedBlocks;
    } else {
      return [this.block.builder.namedBlock(SourceSlice.synthetic('default'), this.block.builder.block(table, this.nonBlockChildren, this.loc), this.loc)];
    }
  };

  return ElementChildren;
}(Children);

function printPath(node) {
  if (node.type !== 'PathExpression' && node.path.type === 'PathExpression') {
    return printPath(node.path);
  } else {
    return new Printer({
      entityEncoding: 'raw'
    }).print(node);
  }
}

function printHead(node) {
  if (node.type === 'PathExpression') {
    switch (node.head.type) {
      case 'AtHead':
      case 'VarHead':
        return node.head.name;

      case 'ThisHead':
        return 'this';
    }
  } else if (node.path.type === 'PathExpression') {
    return printHead(node.path);
  } else {
    return new Printer({
      entityEncoding: 'raw'
    }).print(node);
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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