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

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.normalize = normalize;
exports.BlockContext = void 0;

var _util = require("@glimmer/util");

var _printer = _interopRequireDefault(require("../generation/printer"));

var _tokenizerEventHandlers = require("../parser/tokenizer-event-handlers");

var _slice = require("../source/slice");

var _spanList = require("../source/span-list");

var _symbolTable = require("../symbol-table");

var _syntaxError = require("../syntax-error");

var _utils = require("../utils");

var _parserBuilders = _interopRequireDefault(require("../v1/parser-builders"));

var ASTv2 = _interopRequireWildcard(require("./api"));

var _builders = require("./builders");

var _looseResolution = require("./loose-resolution");

function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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;
}

function normalize(source, options) {
  if (options === void 0) {
    options = {};
  }

  var _a;

  var ast = (0, _tokenizerEventHandlers.preprocess)(source, options);
  var normalizeOptions = (0, _util.assign)({
    strictMode: false,
    locals: []
  }, options);

  var top = _symbolTable.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.
 */


var BlockContext = /*#__PURE__*/function () {
  function BlockContext(source, options, table) {
    this.source = source;
    this.options = options;
    this.table = table;
    this.builder = new _builders.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.
 */


exports.BlockContext = BlockContext;

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, _looseResolution.SexpSyntaxContext);

          if (_resolution.resolution === 'error') {
            throw (0, _syntaxError.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 _slice.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.SpanList.range(paramList, callee.loc.collapse('end'));

    var namedLoc = this.block.loc(hash.loc);

    var argsLoc = _spanList.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 _slice.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
    }, (0, _looseResolution.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, _looseResolution.BlockSyntaxContext);

    if (resolution.resolution === 'error') {
      throw (0, _syntaxError.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((0, _util.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, _looseResolution.ModifierSyntaxContext);

    if (resolution.resolution === 'error') {
      throw (0, _syntaxError.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, (0, _looseResolution.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 && (0, _util.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 && (0, _util.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 = (0, _utils.isUpperCase)(variable);
    var inScope = variable[0] === '@' || variable === 'this' || this.ctx.hasBinding(variable);

    if (this.ctx.strict && !inScope) {
      if (uppercase) {
        throw (0, _syntaxError.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 = _parserBuilders.default.path({
        head: _parserBuilders.default.head(variable, variableLoc),
        tail: tail,
        loc: pathLoc
      });

      var resolution = this.ctx.resolutionFor(path, _looseResolution.ComponentSyntaxContext);

      if (resolution.resolution === 'error') {
        throw (0, _syntaxError.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 (0, _syntaxError.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 ((0, _util.isPresent)(this.namedBlocks)) {
      throw (0, _syntaxError.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 ((0, _util.isPresent)(this.namedBlocks)) {
      throw (0, _syntaxError.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 (0, _syntaxError.generateSyntaxError)("<:" + name.chars + "/> is not a valid named block: named blocks cannot be self-closing", this.loc);
    }

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

    if (!(0, _utils.isLowerCase)(name.chars)) {
      throw (0, _syntaxError.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 (0, _syntaxError.generateSyntaxError)("named block <:" + name.chars + "> cannot have attributes, arguments, or modifiers", this.loc);
    }

    var offsets = _spanList.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 (0, _syntaxError.generateSyntaxError)("Unexpected block params in <" + name + ">: simple elements cannot have block params", this.loc);
    }

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

      if (names.length === 1) {
        throw (0, _syntaxError.generateSyntaxError)("Unexpected named block <:foo> inside <" + name.chars + "> HTML element", this.loc);
      } else {
        var printedNames = names.map(function (n) {
          return "<:" + n.chars + ">";
        }).join(', ');
        throw (0, _syntaxError.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 ((0, _util.isPresent)(this.namedBlocks) && this.hasSemanticContent) {
      throw (0, _syntaxError.generateSyntaxError)("Unexpected content inside <" + name + "> component invocation: when using named blocks, the tag cannot contain other content", this.loc);
    }

    if ((0, _util.isPresent)(this.namedBlocks)) {
      if (hasBlockParams) {
        throw (0, _syntaxError.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 (0, _syntaxError.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 (0, _syntaxError.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(_slice.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.default({
      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.default({
      entityEncoding: 'raw'
    }).print(node);
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL0BnbGltbWVyL3N5bnRheC9saWIvdjItYS9ub3JtYWxpemUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFDQTs7QUFFQTs7QUFDQTs7QUFFQTs7QUFHQTs7QUFDQTs7QUFDQTs7QUFDQTs7QUFFQTs7QUFDQTs7QUFDQTs7QUFDQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFVTSxTQUFBLFNBQUEsQ0FBQSxNQUFBLEVBQUEsT0FBQSxFQUUyQjtBQUFBLE1BQS9CLE9BQStCLEtBQUEsS0FBQSxDQUFBLEVBQUE7QUFBL0IsSUFBQSxPQUErQixHQUYzQixFQUVKO0FBQStCOzs7O0FBRS9CLE1BQUksR0FBRyxHQUFHLHdDQUFVLE1BQVYsRUFBVixPQUFVLENBQVY7QUFFQSxNQUFJLGdCQUFnQixHQUFHLGtCQUNyQjtBQUNFLElBQUEsVUFBVSxFQURaLEtBQUE7QUFFRSxJQUFBLE1BQU0sRUFBRTtBQUZWLEdBRHFCLEVBQXZCLE9BQXVCLENBQXZCOztBQVFBLE1BQUksR0FBRyxHQUFHLHlCQUFBLEdBQUEsQ0FDUixnQkFBZ0IsQ0FEUixNQUFBLEVBQ2UsQ0FBQSxFQUFBLEdBQ3ZCO0FBQ0EsRUFBQSxPQUFPLENBRmdCLHNCQUFBLE1BQUEsSUFBQSxJQUVPLEVBQUEsS0FBQSxLQUZQLENBQUEsR0FBQSxFQUFBLEdBRWEsVUFBRCxJQUFDLEVBQUQ7QUFBQSxXQUhyQyxJQUdxQztBQUhyQyxHQUFVLENBQVY7O0FBS0EsTUFBSSxLQUFLLEdBQUcsSUFBQSxZQUFBLENBQUEsTUFBQSxFQUFBLGdCQUFBLEVBQVosR0FBWSxDQUFaO0FBQ0EsTUFBSSxVQUFVLEdBQUcsSUFBQSxtQkFBQSxDQUFqQixLQUFpQixDQUFqQjtBQUVBLE1BQUksS0FBSyxHQUFHLElBQUEsZ0JBQUEsQ0FDVixLQUFLLENBQUwsR0FBQSxDQUFVLEdBQUcsQ0FESCxHQUNWLENBRFUsRUFFVixHQUFHLENBQUgsSUFBQSxDQUFBLEdBQUEsQ0FBYyxVQUFELENBQUMsRUFBRDtBQUFBLFdBQU8sVUFBVSxDQUFWLFNBQUEsQ0FGVixDQUVVLENBQVA7QUFGSCxHQUVWLENBRlUsRUFBQSxLQUFBLEVBQUEsY0FBQSxDQUFaLEdBQVksQ0FBWjtBQU1BLE1BQUksTUFBTSxHQUFHLEdBQUcsQ0FBaEIscUJBQWEsRUFBYjtBQUVBLFNBQU8sQ0FBQSxLQUFBLEVBQVAsTUFBTyxDQUFQO0FBQ0Q7QUFFRDs7Ozs7Ozs7Ozs7OztBQVdBLElBQU0sWUFBTixHQUFBLGFBQUEsWUFBQTtBQUdFLFdBQUEsWUFBQSxDQUFBLE1BQUEsRUFBQSxPQUFBLEVBQUEsS0FBQSxFQUd1QjtBQUZaLFNBQUEsTUFBQSxHQUFBLE1BQUE7QUFDUSxTQUFBLE9BQUEsR0FBQSxPQUFBO0FBQ1IsU0FBQSxLQUFBLEdBQUEsS0FBQTtBQUVULFNBQUEsT0FBQSxHQUFlLElBQWYsaUJBQWUsRUFBZjtBQUNEOztBQVRILE1BQUEsTUFBQSxHQUFBLFlBQUEsQ0FBQSxTQUFBOztBQUFBLEVBQUEsTUFBQSxDQUFBLEdBQUEsR0FlRSxTQUFBLEdBQUEsQ0FBQSxJQUFBLEVBQXVCO0FBQ3JCLFdBQU8sS0FBQSxNQUFBLENBQUEsT0FBQSxDQUFQLElBQU8sQ0FBUDtBQWhCSixHQUFBOztBQUFBLEVBQUEsTUFBQSxDQUFBLGFBQUEsR0FtQkUsU0FBQSxhQUFBLENBQUEsSUFBQSxFQUFBLFVBQUEsRUFFMkI7QUFFekIsUUFBSSxLQUFKLE1BQUEsRUFBaUI7QUFDZixhQUFPO0FBQUUsUUFBQSxVQUFVLEVBQUUsS0FBSyxDQUFDO0FBQXBCLE9BQVA7QUFDRDs7QUFFRCxRQUFJLEtBQUEsU0FBQSxDQUFKLElBQUksQ0FBSixFQUEwQjtBQUN4QixVQUFJLENBQUMsR0FBRyxVQUFVLENBQWxCLElBQWtCLENBQWxCOztBQUVBLFVBQUksQ0FBQyxLQUFMLElBQUEsRUFBZ0I7QUFDZCxlQUFPO0FBQ0wsVUFBQSxVQUFVLEVBREwsT0FBQTtBQUVMLFVBQUEsSUFBSSxFQUFFLFNBQVMsQ0FGVixJQUVVLENBRlY7QUFHTCxVQUFBLElBQUksRUFBRSxTQUFTLENBQUEsSUFBQTtBQUhWLFNBQVA7QUFLRDs7QUFFRCxhQUFPO0FBQUUsUUFBQSxVQUFVLEVBQUU7QUFBZCxPQUFQO0FBWEYsS0FBQSxNQVlPO0FBQ0wsYUFBTztBQUFFLFFBQUEsVUFBVSxFQUFFLEtBQUssQ0FBQztBQUFwQixPQUFQO0FBQ0Q7QUF6Q0wsR0FBQTs7QUFBQSxFQUFBLE1BQUEsQ0FBQSxTQUFBLEdBNENVLFNBQUEsU0FBQSxDQUFBLE1BQUEsRUFBdUQ7QUFDN0QsUUFBSSxNQUFNLENBQU4sSUFBQSxLQUFKLGdCQUFBLEVBQXNDO0FBQ3BDLFVBQUksTUFBTSxDQUFOLElBQUEsQ0FBQSxJQUFBLEtBQUosU0FBQSxFQUFvQztBQUNsQyxlQUFBLEtBQUE7QUFDRDs7QUFFRCxhQUFPLENBQUMsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLE1BQU0sQ0FBTixJQUFBLENBQXZCLElBQVEsQ0FBUjtBQUxGLEtBQUEsTUFNTyxJQUFJLE1BQU0sQ0FBTixJQUFBLENBQUEsSUFBQSxLQUFKLGdCQUFBLEVBQTJDO0FBQ2hELGFBQU8sS0FBQSxTQUFBLENBQWUsTUFBTSxDQUE1QixJQUFPLENBQVA7QUFESyxLQUFBLE1BRUE7QUFDTCxhQUFBLEtBQUE7QUFDRDtBQXZETCxHQUFBOztBQUFBLEVBQUEsTUFBQSxDQUFBLFVBQUEsR0EwREUsU0FBQSxVQUFBLENBQUEsSUFBQSxFQUF1QjtBQUNyQixXQUFPLEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBUCxJQUFPLENBQVA7QUEzREosR0FBQTs7QUFBQSxFQUFBLE1BQUEsQ0FBQSxLQUFBLEdBOERFLFNBQUEsS0FBQSxDQUFBLFdBQUEsRUFBMkI7QUFDekIsV0FBTyxJQUFBLFlBQUEsQ0FBaUIsS0FBakIsTUFBQSxFQUE4QixLQUE5QixPQUFBLEVBQTRDLEtBQUEsS0FBQSxDQUFBLEtBQUEsQ0FBbkQsV0FBbUQsQ0FBNUMsQ0FBUDtBQS9ESixHQUFBOztBQUFBLEVBQUEsTUFBQSxDQUFBLHNCQUFBLEdBa0VFLFNBQUEsc0JBQUEsQ0FBQSxLQUFBLEVBQW9DO0FBQ2xDLFFBQUksS0FBQSxPQUFBLENBQUosc0JBQUEsRUFBeUM7QUFDdkMsYUFBTyxLQUFBLE9BQUEsQ0FBQSxzQkFBQSxDQUFQLEtBQU8sQ0FBUDtBQURGLEtBQUEsTUFFTztBQUNMLGFBQUEsS0FBQTtBQUNEO0FBdkVMLEdBQUE7O0FBQUEsRUFBQSxZQUFBLENBQUEsWUFBQSxFQUFBLENBQUE7QUFBQSxJQUFBLEdBQUEsRUFBQSxRQUFBO0FBQUEsSUFBQSxHQUFBLEVBQUEsU0FBQSxHQUFBLEdBV1k7QUFDUixhQUFPLEtBQUEsT0FBQSxDQUFBLFVBQUEsSUFBUCxLQUFBO0FBQ0Q7QUFiSCxHQUFBLENBQUEsQ0FBQTs7QUFBQSxTQUFBLFlBQUE7QUFBQSxDQUFBLEVBQUE7QUEyRUE7Ozs7Ozs7OztJQUtBLG9CO0FBQ0UsV0FBQSxvQkFBQSxDQUFBLEtBQUEsRUFBdUM7QUFBbkIsU0FBQSxLQUFBLEdBQUEsS0FBQTtBQUF1Qjs7OztVQWUzQyxTLEdBQUEsU0FBQSxTQUFBLENBQUEsSUFBQSxFQUFBLFVBQUEsRUFFcUM7QUFFbkMsWUFBUSxJQUFJLENBQVosSUFBQTtBQUNFLFdBQUEsYUFBQTtBQUNBLFdBQUEsZ0JBQUE7QUFDQSxXQUFBLGVBQUE7QUFDQSxXQUFBLGVBQUE7QUFDQSxXQUFBLGtCQUFBO0FBQ0UsZUFBTyxLQUFBLEtBQUEsQ0FBQSxPQUFBLENBQUEsT0FBQSxDQUEyQixJQUFJLENBQS9CLEtBQUEsRUFBdUMsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FBakUsR0FBOEMsQ0FBdkMsQ0FBUDs7QUFDRixXQUFBLGdCQUFBO0FBQ0UsZUFBTyxLQUFBLElBQUEsQ0FBQSxJQUFBLEVBQVAsVUFBTyxDQUFQOztBQUNGLFdBQUEsZUFBQTtBQUFzQjtBQUNwQixjQUFJLFdBQVUsR0FBRyxLQUFBLEtBQUEsQ0FBQSxhQUFBLENBQUEsSUFBQSxFQUFqQixrQ0FBaUIsQ0FBakI7O0FBRUEsY0FBSSxXQUFVLENBQVYsVUFBQSxLQUFKLE9BQUEsRUFBdUM7QUFDckMsa0JBQU0sc0NBQW1CLHNDQUNjLFdBQVUsQ0FEeEIsSUFBQSxHQUFBLFNBQUEsR0FDd0MsV0FBVSxDQURsRCxJQUFBLEdBQUEsbUJBQW5CLEVBRUosSUFBSSxDQUZOLEdBQU0sQ0FBTjtBQUlEOztBQUVELGlCQUFPLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxJQUFBLENBQ0wsS0FBQSxTQUFBLENBQUEsSUFBQSxFQUFxQixXQUFVLENBRDFCLFVBQ0wsQ0FESyxFQUVMLEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBRnJCLEdBRUUsQ0FGSyxDQUFQO0FBSUQ7QUF2Qkg7OztVQTJCTSxJLEdBQUEsU0FBQSxJQUFBLENBQUEsSUFBQSxFQUFBLFVBQUEsRUFFNkI7QUFFbkMsUUFBSSxXQUFXLEdBQUcsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FBSixJQUFBLENBQWpDLEdBQWtCLENBQWxCO0FBRUEsUUFBSSxJQUFJLEdBSjJCLEVBSW5DLENBSm1DLENBTW5DOztBQUNBLFFBQUksTUFBTSxHQUFWLFdBQUE7O0FBRUEsU0FBQSxJQUFBLFNBQUEsR0FBQSwrQkFBQSxDQUFpQixJQUFJLENBQXJCLElBQUEsQ0FBQSxFQUFBLEtBQUEsRUFBQSxDQUFBLENBQUEsS0FBQSxHQUFBLFNBQUEsRUFBQSxFQUFBLElBQUEsR0FBNEI7QUFBQSxVQUE1QixJQUE0QixHQUFBLEtBQUEsQ0FBQSxLQUFBO0FBQzFCLE1BQUEsTUFBTSxHQUFHLE1BQU0sQ0FBTixlQUFBLENBQXVCO0FBQUUsUUFBQSxLQUFLLEVBQUUsSUFBSSxDQUFiLE1BQUE7QUFBc0IsUUFBQSxTQUFTLEVBQUU7QUFBakMsT0FBdkIsQ0FBVDtBQUNBLE1BQUEsSUFBSSxDQUFKLElBQUEsQ0FDRSxJQUFBLGtCQUFBLENBQWdCO0FBQ2QsUUFBQSxHQUFHLEVBRFcsTUFBQTtBQUVkLFFBQUEsS0FBSyxFQUFFO0FBRk8sT0FBaEIsQ0FERjtBQU1EOztBQUVELFdBQU8sS0FBQSxLQUFBLENBQUEsT0FBQSxDQUFBLElBQUEsQ0FBd0IsS0FBQSxHQUFBLENBQVMsSUFBSSxDQUFiLElBQUEsRUFBeEIsVUFBd0IsQ0FBeEIsRUFBQSxJQUFBLEVBQStELEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBQXpGLEdBQXNFLENBQS9ELENBQVA7QUFDRDtBQUVEOzs7Ozs7VUFJQSxTLEdBQUEsU0FBQSxTQUFBLENBQUEsS0FBQSxFQUFBLE9BQUEsRUFBa0U7QUFBQSxRQUFBLEtBQUEsR0FBQSxJQUFBOztBQUFBLFFBQzVELElBRDRELEdBQ2hFLEtBRGdFLENBQUEsSUFBQTtBQUFBLFFBQzVELE1BRDRELEdBQ2hFLEtBRGdFLENBQUEsTUFBQTtBQUFBLFFBQzVDLElBRDRDLEdBQ2hFLEtBRGdFLENBQUEsSUFBQTtBQUdoRSxRQUFJLE1BQU0sR0FBRyxLQUFBLFNBQUEsQ0FBQSxJQUFBLEVBQWIsT0FBYSxDQUFiO0FBQ0EsUUFBSSxTQUFTLEdBQUcsTUFBTSxDQUFOLEdBQUEsQ0FBWSxVQUFELENBQUMsRUFBRDtBQUFBLGFBQU8sS0FBQSxDQUFBLFNBQUEsQ0FBQSxDQUFBLEVBQWtCLEtBQUssQ0FBekQsbUJBQWtDLENBQVA7QUFBM0IsS0FBZ0IsQ0FBaEI7O0FBQ0EsUUFBSSxRQUFRLEdBQUcsbUJBQUEsS0FBQSxDQUFBLFNBQUEsRUFBMEIsTUFBTSxDQUFOLEdBQUEsQ0FBQSxRQUFBLENBQXpDLEtBQXlDLENBQTFCLENBQWY7O0FBQ0EsUUFBSSxRQUFRLEdBQUcsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FBbEMsR0FBZSxDQUFmOztBQUNBLFFBQUksT0FBTyxHQUFHLG1CQUFBLEtBQUEsQ0FBZSxDQUFBLFFBQUEsRUFBN0IsUUFBNkIsQ0FBZixDQUFkOztBQUVBLFFBQUksVUFBVSxHQUFHLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxVQUFBLENBQ2YsTUFBTSxDQUFOLEdBQUEsQ0FBWSxVQUFELENBQUMsRUFBRDtBQUFBLGFBQU8sS0FBQSxDQUFBLFNBQUEsQ0FBQSxDQUFBLEVBQWtCLEtBQUssQ0FEMUIsbUJBQ0csQ0FBUDtBQURJLEtBQ2YsQ0FEZSxFQUFqQixRQUFpQixDQUFqQjtBQUtBLFFBQUksS0FBSyxHQUFHLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxLQUFBLENBQ1YsSUFBSSxDQUFKLEtBQUEsQ0FBQSxHQUFBLENBQWdCLFVBQUQsQ0FBQyxFQUFEO0FBQUEsYUFBTyxLQUFBLENBQUEsYUFBQSxDQURaLENBQ1ksQ0FBUDtBQURMLEtBQ1YsQ0FEVSxFQUVWLEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBRnJCLEdBRUUsQ0FGVSxDQUFaO0FBS0EsV0FBTztBQUNMLE1BQUEsTUFESyxFQUFBLE1BQUE7QUFFTCxNQUFBLElBQUksRUFBRSxLQUFBLEtBQUEsQ0FBQSxPQUFBLENBQUEsSUFBQSxDQUFBLFVBQUEsRUFBQSxLQUFBLEVBQUEsT0FBQTtBQUZELEtBQVA7OztVQU1NLGEsR0FBQSxTQUFBLGFBQUEsQ0FBQSxJQUFBLEVBQWtDO0FBQ3hDLFFBQUksT0FBTyxHQUFHLEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBQWpDLEdBQWMsQ0FBZDtBQUVBLFFBQUksVUFBVSxHQUFHLE9BQU8sQ0FBUCxlQUFBLENBQXdCO0FBQUUsTUFBQSxLQUFLLEVBQUUsSUFBSSxDQUFKLEdBQUEsQ0FBUztBQUFsQixLQUF4QixDQUFqQjtBQUVBLFdBQU8sS0FBQSxLQUFBLENBQUEsT0FBQSxDQUFBLGFBQUEsQ0FDTCxJQUFBLGtCQUFBLENBQWdCO0FBQUUsTUFBQSxLQUFLLEVBQUUsSUFBSSxDQUFiLEdBQUE7QUFBbUIsTUFBQSxHQUFHLEVBQUU7QUFBeEIsS0FBaEIsQ0FESyxFQUVMLEtBQUEsU0FBQSxDQUFlLElBQUksQ0FBbkIsS0FBQSxFQUEyQixLQUFLLENBRmxDLG1CQUVFLENBRkssQ0FBUDtBQUlEO0FBRUQ7Ozs7Ozs7Ozs7OztVQVVRLEcsR0FBQSxTQUFBLEdBQUEsQ0FBQSxJQUFBLEVBQUEsVUFBQSxFQUE2RDtBQUFBLFFBQzdELEtBRDZELEdBQUEsS0FBQSxLQUFBO0FBQUEsUUFFL0QsT0FGK0QsR0FFbkUsS0FGbUUsQ0FBQSxPQUFBO0FBQUEsUUFFcEQsS0FGb0QsR0FFbkUsS0FGbUUsQ0FBQSxLQUFBO0FBR25FLFFBQUksT0FBTyxHQUFHLEtBQUssQ0FBTCxHQUFBLENBQVUsSUFBSSxDQUE1QixHQUFjLENBQWQ7O0FBRUEsWUFBUSxJQUFJLENBQVosSUFBQTtBQUNFLFdBQUEsVUFBQTtBQUNFLGVBQU8sT0FBTyxDQUFQLElBQUEsQ0FBUCxPQUFPLENBQVA7O0FBQ0YsV0FBQSxRQUFBO0FBQWU7QUFDYixjQUFJLE1BQU0sR0FBRyxLQUFLLENBQUwsYUFBQSxDQUFvQixJQUFJLENBQXJDLElBQWEsQ0FBYjtBQUNBLGlCQUFPLE9BQU8sQ0FBUCxFQUFBLENBQVcsSUFBSSxDQUFmLElBQUEsRUFBQSxNQUFBLEVBQVAsT0FBTyxDQUFQO0FBQ0Q7O0FBQ0QsV0FBQSxTQUFBO0FBQWdCO0FBQ2QsY0FBSSxLQUFLLENBQUwsVUFBQSxDQUFpQixJQUFJLENBQXpCLElBQUksQ0FBSixFQUFpQztBQUFBLGdCQUFBLFVBQUEsR0FDUixLQUFLLENBQUwsR0FBQSxDQUFVLElBQUksQ0FETixJQUNSLENBRFE7QUFBQSxnQkFDM0IsT0FEMkIsR0FBQSxVQUFBLENBQUEsQ0FBQSxDQUFBO0FBQUEsZ0JBQzNCLE1BRDJCLEdBQUEsVUFBQSxDQUFBLENBQUEsQ0FBQTs7QUFHL0IsbUJBQU8sS0FBSyxDQUFMLE9BQUEsQ0FBQSxRQUFBLENBQXVCLElBQUksQ0FBM0IsSUFBQSxFQUFBLE9BQUEsRUFBQSxNQUFBLEVBQVAsT0FBTyxDQUFQO0FBSEYsV0FBQSxNQUlPO0FBQ0wsZ0JBQUksT0FBTyxHQUFHLEtBQUssQ0FBTCxNQUFBLEdBQWUsS0FBSyxDQUFwQixpQkFBQSxHQUFkLFVBQUE7O0FBQ0EsZ0JBQUksUUFBTSxHQUFHLEtBQUssQ0FBTCxLQUFBLENBQUEsWUFBQSxDQUF5QixJQUFJLENBQTdCLElBQUEsRUFBYixPQUFhLENBQWI7O0FBRUEsbUJBQU8sS0FBSyxDQUFMLE9BQUEsQ0FBQSxPQUFBLENBQXNCO0FBQzNCLGNBQUEsSUFBSSxFQUFFLElBQUksQ0FEaUIsSUFBQTtBQUUzQixjQUFBLE9BRjJCLEVBQUEsT0FBQTtBQUczQixjQUFBLE1BSDJCLEVBQUEsUUFBQTtBQUkzQixjQUFBLEdBQUcsRUFBRTtBQUpzQixhQUF0QixDQUFQO0FBTUQ7QUFDRjtBQXZCSDs7Ozs7QUE0Qko7Ozs7O0lBR0EsbUI7QUFDRSxXQUFBLG1CQUFBLENBQUEsS0FBQSxFQUFnRDtBQUFuQixTQUFBLEtBQUEsR0FBQSxLQUFBO0FBQXVCOzs7O1VBRXBELFMsR0FBQSxTQUFBLFNBQUEsQ0FBQSxJQUFBLEVBQStCO0FBQzdCLFlBQVEsSUFBSSxDQUFaLElBQUE7QUFDRSxXQUFBLGtCQUFBO0FBQ0UsY0FBTSxJQUFOLEtBQU0sQ0FBTixpRUFBTSxDQUFOOztBQUNGLFdBQUEsZ0JBQUE7QUFDRSxlQUFPLEtBQUEsY0FBQSxDQUFQLElBQU8sQ0FBUDs7QUFDRixXQUFBLGFBQUE7QUFDRSxlQUFPLElBQUEsaUJBQUEsQ0FBc0IsS0FBdEIsS0FBQSxFQUFBLFdBQUEsQ0FBUCxJQUFPLENBQVA7O0FBQ0YsV0FBQSxtQkFBQTtBQUNFLGVBQU8sS0FBQSxpQkFBQSxDQUFQLElBQU8sQ0FBUDtBQUVGOztBQUNBLFdBQUEsMEJBQUE7QUFDRSxlQUFPLEtBQUEsd0JBQUEsQ0FBUCxJQUFPLENBQVA7O0FBRUYsV0FBQSxrQkFBQTtBQUF5QjtBQUN2QixjQUFJLEdBQUcsR0FBRyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsSUFBSSxDQUE3QixHQUFVLENBQVY7QUFDQSxpQkFBTyxJQUFJLEtBQUssQ0FBVCxXQUFBLENBQXNCO0FBQzNCLFlBQUEsR0FEMkIsRUFBQSxHQUFBO0FBRTNCLFlBQUEsSUFBSSxFQUFFLEdBQUcsQ0FBSCxLQUFBLENBQVU7QUFBRSxjQUFBLFNBQVMsRUFBWCxDQUFBO0FBQWdCLGNBQUEsT0FBTyxFQUFFO0FBQXpCLGFBQVYsRUFBQSxPQUFBLENBQWdELElBQUksQ0FBcEQsS0FBQTtBQUZxQixXQUF0QixDQUFQO0FBSUQ7O0FBRUQsV0FBQSxVQUFBO0FBQ0UsZUFBTyxJQUFJLEtBQUssQ0FBVCxRQUFBLENBQW1CO0FBQ3hCLFVBQUEsR0FBRyxFQUFFLEtBQUEsS0FBQSxDQUFBLEdBQUEsQ0FBZSxJQUFJLENBREEsR0FDbkIsQ0FEbUI7QUFFeEIsVUFBQSxLQUFLLEVBQUUsSUFBSSxDQUFDO0FBRlksU0FBbkIsQ0FBUDtBQXZCSjs7O1VBOEJGLHdCLEdBQUEsU0FBQSx3QkFBQSxDQUFBLElBQUEsRUFBNkQ7QUFDM0QsUUFBSSxHQUFHLEdBQUcsS0FBQSxLQUFBLENBQUEsR0FBQSxDQUFlLElBQUksQ0FBN0IsR0FBVSxDQUFWO0FBQ0EsUUFBQSxPQUFBOztBQUVBLFFBQUksR0FBRyxDQUFILFFBQUEsR0FBQSxLQUFBLENBQUEsQ0FBQSxFQUFBLENBQUEsTUFBSixPQUFBLEVBQTRDO0FBQzFDLE1BQUEsT0FBTyxHQUFHLEdBQUcsQ0FBSCxLQUFBLENBQVU7QUFBRSxRQUFBLFNBQVMsRUFBWCxDQUFBO0FBQWdCLFFBQUEsT0FBTyxFQUFFO0FBQXpCLE9BQVYsQ0FBVjtBQURGLEtBQUEsTUFFTztBQUNMLE1BQUEsT0FBTyxHQUFHLEdBQUcsQ0FBSCxLQUFBLENBQVU7QUFBRSxRQUFBLFNBQVMsRUFBWCxDQUFBO0FBQWdCLFFBQUEsT0FBTyxFQUFFO0FBQXpCLE9BQVYsQ0FBVjtBQUNEOztBQUVELFdBQU8sSUFBSSxLQUFLLENBQVQsY0FBQSxDQUF5QjtBQUM5QixNQUFBLEdBRDhCLEVBQUEsR0FBQTtBQUU5QixNQUFBLElBQUksRUFBRSxPQUFPLENBQVAsT0FBQSxDQUFnQixJQUFJLENBQXBCLEtBQUE7QUFGd0IsS0FBekIsQ0FBUDtBQUlEO0FBRUQ7Ozs7O1VBR0EsaUIsR0FBQSxTQUFBLGlCQUFBLENBQUEsUUFBQSxFQUFtRDtBQUFBLFFBQzNDLE9BRDJDLEdBQ2pELFFBRGlELENBQUEsT0FBQTtBQUVqRCxRQUFJLEdBQUcsR0FBRyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsUUFBUSxDQUZnQixHQUV2QyxDQUFWLENBRmlELENBSWpEOztBQUNBLFFBQUksU0FBUyxHQUFHLEtBQUEsSUFBQSxDQUFBLFNBQUEsQ0FDZDtBQUNFLE1BQUEsSUFBSSxFQUFFLFFBQVEsQ0FEaEIsSUFBQTtBQUVFLE1BQUEsTUFBTSxFQUFFLFFBQVEsQ0FGbEIsTUFBQTtBQUdFLE1BQUEsSUFBSSxFQUFFLFFBQVEsQ0FBQztBQUhqQixLQURjLEVBTWQsMENBTkYsUUFNRSxDQU5jLENBQWhCO0FBU0EsUUFBSSxLQUFLLEdBQUcsU0FBUyxDQUFULElBQUEsQ0FBQSxPQUFBLEtBQ1IsU0FBUyxDQURELE1BQUEsR0FFUixLQUFBLEtBQUEsQ0FBQSxPQUFBLENBQUEsSUFBQSxDQUFBLFNBQUEsRUFGSixHQUVJLENBRko7QUFJQSxXQUFPLEtBQUEsS0FBQSxDQUFBLE9BQUEsQ0FBQSxNQUFBLENBQ0w7QUFDRSxNQUFBLEtBQUssRUFBRSxLQUFBLEtBQUEsQ0FEVCxLQUFBO0FBRUUsTUFBQSxRQUFRLEVBQUUsQ0FGWixPQUFBO0FBR0UsTUFBQSxLQUFBLEVBQUE7QUFIRixLQURLLEVBQVAsR0FBTyxDQUFQO0FBUUQ7QUFFRDs7Ozs7VUFHQSxjLEdBQUEsU0FBQSxjQUFBLENBQUEsS0FBQSxFQUEwQztBQUFBLFFBQ3BDLE9BRG9DLEdBQ3hDLEtBRHdDLENBQUEsT0FBQTtBQUFBLFFBQ3pCLE9BRHlCLEdBQ3hDLEtBRHdDLENBQUEsT0FBQTtBQUV4QyxRQUFJLEdBQUcsR0FBRyxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBQWUsS0FBSyxDQUE5QixHQUFVLENBQVY7QUFFQSxRQUFJLFVBQVUsR0FBRyxLQUFBLEtBQUEsQ0FBQSxhQUFBLENBQUEsS0FBQSxFQUFqQixtQ0FBaUIsQ0FBakI7O0FBRUEsUUFBSSxVQUFVLENBQVYsVUFBQSxLQUFKLE9BQUEsRUFBdUM7QUFDckMsWUFBTSxzQ0FBbUIseUNBQ2lCLFVBQVUsQ0FEM0IsSUFBQSxHQUFBLFdBQUEsR0FDNkMsVUFBVSxDQUR2RCxJQUFBLEdBQUEsbUJBQW5CLEVBQU4sR0FBTSxDQUFOO0FBSUQ7O0FBRUQsUUFBSSxTQUFTLEdBQUcsS0FBQSxJQUFBLENBQUEsU0FBQSxDQUFBLEtBQUEsRUFBMkIsVUFBVSxDQUFyRCxVQUFnQixDQUFoQjtBQUVBLFdBQU8sS0FBQSxLQUFBLENBQUEsT0FBQSxDQUFBLGNBQUEsQ0FDTCxrQkFDRTtBQUNFLE1BQUEsT0FBTyxFQUFFLEtBQUEsS0FBQSxDQURYLEtBQUE7QUFFRSxNQUFBLE9BQU8sRUFBRSxLQUFBLEtBQUEsQ0FGWCxPQUVXLENBRlg7QUFHRSxNQUFBLE9BQU8sRUFBRSxPQUFPLEdBQUcsS0FBQSxLQUFBLENBQUgsT0FBRyxDQUFILEdBQXlCO0FBSDNDLEtBREYsRUFESyxTQUNMLENBREssRUFBUCxHQUFPLENBQVA7OztVQWFGLEssR0FBQSxTQUFBLEtBQUEsQ0FBQSxJQUFBLEVBQTZDO0FBQUEsUUFBdkMsSUFBdUMsR0FBQSxJQUFBLENBQXZDLElBQXVDO0FBQUEsUUFBdkMsR0FBdUMsR0FBQSxJQUFBLENBQXZDLEdBQXVDO0FBQUEsUUFBMUIsV0FBMEIsR0FBQSxJQUFBLENBQTFCLFdBQTBCO0FBQzNDLFFBQUksS0FBSyxHQUFHLEtBQUEsS0FBQSxDQUFBLEtBQUEsQ0FBWixXQUFZLENBQVo7QUFDQSxRQUFJLFVBQVUsR0FBRyxJQUFBLG1CQUFBLENBQWpCLEtBQWlCLENBQWpCO0FBQ0EsV0FBTyxJQUFBLGFBQUEsQ0FDTCxLQUFBLEtBQUEsQ0FBQSxHQUFBLENBREssR0FDTCxDQURLLEVBRUwsSUFBSSxDQUFKLEdBQUEsQ0FBVSxVQUFELENBQUMsRUFBRDtBQUFBLGFBQU8sVUFBVSxDQUFWLFNBQUEsQ0FGWCxDQUVXLENBQVA7QUFGSixLQUVMLENBRkssRUFHTCxLQUhLLEtBQUEsRUFBQSxXQUFBLENBSU8sS0FBSyxDQUpuQixLQUFPLENBQVA7Ozs7O3dCQU9jO0FBQ2QsYUFBTyxJQUFBLG9CQUFBLENBQXlCLEtBQWhDLEtBQU8sQ0FBUDtBQUNEOzs7Ozs7SUFHSCxpQjtBQUNFLFdBQUEsaUJBQUEsQ0FBQSxHQUFBLEVBQThDO0FBQWpCLFNBQUEsR0FBQSxHQUFBLEdBQUE7QUFBcUI7QUFFbEQ7Ozs7Ozs7Ozs7Ozs7Ozs7OztVQWNBLFcsR0FBQSxTQUFBLFdBQUEsQ0FBQSxPQUFBLEVBQXNDO0FBQUEsUUFBQSxNQUFBLEdBQUEsSUFBQTs7QUFBQSxRQUNoQyxHQURnQyxHQUNwQyxPQURvQyxDQUFBLEdBQUE7QUFBQSxRQUNoQyxXQURnQyxHQUNwQyxPQURvQyxDQUFBLFdBQUE7QUFBQSxRQUNaLFFBRFksR0FDcEMsT0FEb0MsQ0FBQSxRQUFBO0FBRXBDLFFBQUksR0FBRyxHQUFHLEtBQUEsR0FBQSxDQUFBLEdBQUEsQ0FBYSxPQUFPLENBQTlCLEdBQVUsQ0FBVjs7QUFGb0MsUUFBQSxVQUFBLEdBSVgsR0FBRyxDQUFILEtBQUEsQ0FKVyxHQUlYLENBSlc7QUFBQSxRQUloQyxPQUpnQyxHQUFBLFVBQUEsQ0FBQSxDQUFBLENBQUE7QUFBQSxRQUloQyxJQUpnQyxHQUFBLFVBQUEsQ0FBQSxLQUFBLENBQUEsQ0FBQSxDQUFBLENBQUEsQ0FNcEM7OztBQUNBLFFBQUksSUFBSSxHQUFHLEtBQUEsV0FBQSxDQUFBLE9BQUEsRUFBQSxJQUFBLEVBQWdDLE9BQU8sQ0FBbEQsR0FBVyxDQUFYO0FBRUEsUUFBSSxLQUFLLEdBQUcsT0FBTyxDQUFQLFVBQUEsQ0FBQSxNQUFBLENBQTJCLFVBQUQsQ0FBQyxFQUFEO0FBQUEsYUFBTyxDQUFDLENBQUQsSUFBQSxDQUFBLENBQUEsTUFBakMsR0FBMEI7QUFBMUIsS0FBQSxFQUFBLEdBQUEsQ0FBeUQsVUFBRCxDQUFDLEVBQUQ7QUFBQSxhQUFPLE1BQUEsQ0FBQSxJQUFBLENBQTNFLENBQTJFLENBQVA7QUFBcEUsS0FBWSxDQUFaO0FBQ0EsUUFBSSxJQUFJLEdBQUcsT0FBTyxDQUFQLFVBQUEsQ0FBQSxNQUFBLENBQTJCLFVBQUQsQ0FBQyxFQUFEO0FBQUEsYUFBTyxDQUFDLENBQUQsSUFBQSxDQUFBLENBQUEsTUFBakMsR0FBMEI7QUFBMUIsS0FBQSxFQUFBLEdBQUEsQ0FBeUQsVUFBRCxDQUFDLEVBQUQ7QUFBQSxhQUFPLE1BQUEsQ0FBQSxHQUFBLENBQTFFLENBQTBFLENBQVA7QUFBbkUsS0FBVyxDQUFYO0FBRUEsUUFBSSxTQUFTLEdBQUcsT0FBTyxDQUFQLFNBQUEsQ0FBQSxHQUFBLENBQXVCLFVBQUQsQ0FBQyxFQUFEO0FBQUEsYUFBTyxNQUFBLENBQUEsUUFBQSxDQVpULENBWVMsQ0FBUDtBQVpGLEtBWXBCLENBQWhCLENBWm9DLENBY3BDOztBQUNBLFFBQUksS0FBSyxHQUFHLEtBQUEsR0FBQSxDQUFBLEtBQUEsQ0FBZSxPQUFPLENBQWxDLFdBQVksQ0FBWjtBQUNBLFFBQUksVUFBVSxHQUFHLElBQUEsbUJBQUEsQ0FBakIsS0FBaUIsQ0FBakI7QUFFQSxRQUFJLFVBQVUsR0FBRyxPQUFPLENBQVAsUUFBQSxDQUFBLEdBQUEsQ0FBc0IsVUFBRCxDQUFDLEVBQUQ7QUFBQSxhQUFPLFVBQVUsQ0FBVixTQUFBLENBQTdDLENBQTZDLENBQVA7QUFBdEMsS0FBaUIsQ0FBakI7QUFFQSxRQUFJLEVBQUUsR0FBRyxLQUFBLEdBQUEsQ0FBQSxPQUFBLENBQUEsT0FBQSxDQUF5QjtBQUNoQyxNQUFBLFdBRGdDLEVBQUEsV0FBQTtBQUVoQyxNQUFBLEtBRmdDLEVBQUEsS0FBQTtBQUdoQyxNQUFBLGFBQWEsRUFIbUIsSUFBQTtBQUloQyxNQUFBLFNBSmdDLEVBQUEsU0FBQTtBQUtoQyxNQUFBLFFBQVEsRUFBRSxRQUFRLENBQVIsR0FBQSxDQUFjLFVBQUQsQ0FBQyxFQUFEO0FBQUEsZUFBTyxJQUFBLG1CQUFBLENBQXdCLE1BQUEsQ0FBeEIsR0FBQSxFQUFBLHdCQUFBLENBQXBCLENBQW9CLENBQVA7QUFBYixPQUFBO0FBTHNCLEtBQXpCLENBQVQ7QUFRQSxRQUFJLFFBQVEsR0FBRyxJQUFBLGVBQUEsQ0FBQSxFQUFBLEVBQUEsR0FBQSxFQUFBLFVBQUEsRUFBeUMsS0FBeEQsR0FBZSxDQUFmO0FBRUEsUUFBSSxPQUFPLEdBQUcsS0FBQSxHQUFBLENBQUEsR0FBQSxDQUFhLE9BQU8sQ0FBbEMsR0FBYyxDQUFkO0FBQ0EsUUFBSSxVQUFVLEdBQUcsT0FBTyxDQUFQLGVBQUEsQ0FBd0I7QUFBRSxNQUFBLEtBQUssRUFBRSxHQUFHLENBQVosTUFBQTtBQUFxQixNQUFBLFNBQVMsRUFBRTtBQUFoQyxLQUF4QixDQUFqQjs7QUFFQSxRQUFJLElBQUksS0FBUixhQUFBLEVBQTRCO0FBQzFCLFVBQUksR0F