/*istanbul ignore next*/
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var
/*istanbul ignore next*/
_base = require("../base");

var
/*istanbul ignore next*/
_exception = _interopRequireDefault(require("../exception"));

var
/*istanbul ignore next*/
_utils = require("../utils");

var
/*istanbul ignore next*/
_codeGen = _interopRequireDefault(require("./code-gen"));

/*istanbul ignore next*/ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function Literal(value) {
  this.value = value;
}

function JavaScriptCompiler() {}

JavaScriptCompiler.prototype = {
  // PUBLIC API: You can override these methods in a subclass to provide
  // alternative compiled forms for name lookup and buffering semantics
  nameLookup: function
  /*istanbul ignore next*/
  nameLookup(parent, name
  /*,  type */
  ) {
    return this.internalNameLookup(parent, name);
  },
  depthedLookup: function
  /*istanbul ignore next*/
  depthedLookup(name) {
    return [this.aliasable('container.lookup'), '(depths, ', JSON.stringify(name), ')'];
  },
  compilerInfo: function
  /*istanbul ignore next*/
  compilerInfo() {
    var revision =
    /*istanbul ignore next*/
    _base.
    /*istanbul ignore next*/
    COMPILER_REVISION,
        versions =
    /*istanbul ignore next*/
    _base.
    /*istanbul ignore next*/
    REVISION_CHANGES[revision];
    return [revision, versions];
  },
  appendToBuffer: function
  /*istanbul ignore next*/
  appendToBuffer(source, location, explicit) {
    // Force a source as this simplifies the merge logic.
    if (!
    /*istanbul ignore next*/
    (0,
    /*istanbul ignore next*/
    _utils.
    /*istanbul ignore next*/
    isArray)(source)) {
      source = [source];
    }

    source = this.source.wrap(source, location);

    if (this.environment.isSimple) {
      return ['return ', source, ';'];
    } else if (explicit) {
      // This is a case where the buffer operation occurs as a child of another
      // construct, generally braces. We have to explicitly output these buffer
      // operations to ensure that the emitted code goes in the correct location.
      return ['buffer += ', source, ';'];
    } else {
      source.appendToBuffer = true;
      return source;
    }
  },
  initializeBuffer: function
  /*istanbul ignore next*/
  initializeBuffer() {
    return this.quotedString('');
  },
  // END PUBLIC API
  internalNameLookup: function
  /*istanbul ignore next*/
  internalNameLookup(parent, name) {
    this.lookupPropertyFunctionIsUsed = true;
    return ['lookupProperty(', parent, ',', JSON.stringify(name), ')'];
  },
  lookupPropertyFunctionIsUsed: false,
  compile: function
  /*istanbul ignore next*/
  compile(environment, options, context, asObject) {
    this.environment = environment;
    this.options = options;
    this.stringParams = this.options.stringParams;
    this.trackIds = this.options.trackIds;
    this.precompile = !asObject;
    this.name = this.environment.name;
    this.isChild = !!context;
    this.context = context || {
      decorators: [],
      programs: [],
      environments: []
    };
    this.preamble();
    this.stackSlot = 0;
    this.stackVars = [];
    this.aliases = {};
    this.registers = {
      list: []
    };
    this.hashes = [];
    this.compileStack = [];
    this.inlineStack = [];
    this.blockParams = [];
    this.compileChildren(environment, options);
    this.useDepths = this.useDepths || environment.useDepths || environment.useDecorators || this.options.compat;
    this.useBlockParams = this.useBlockParams || environment.useBlockParams;
    var opcodes = environment.opcodes,
        opcode,
        firstLoc,
        i,
        l;

    for (i = 0, l = opcodes.length; i < l; i++) {
      opcode = opcodes[i];
      this.source.currentLocation = opcode.loc;
      firstLoc = firstLoc || opcode.loc;
      this[opcode.opcode].apply(this, opcode.args);
    } // Flush any trailing content that might be pending.


    this.source.currentLocation = firstLoc;
    this.pushSource('');
    /* istanbul ignore next */

    if (this.stackSlot || this.inlineStack.length || this.compileStack.length) {
      throw new
      /*istanbul ignore next*/
      _exception[
      /*istanbul ignore next*/
      "default"]('Compile completed with content left on stack');
    }

    if (!this.decorators.isEmpty()) {
      this.useDecorators = true;
      this.decorators.prepend(['var decorators = container.decorators, ', this.lookupPropertyFunctionVarDeclaration(), ';\n']);
      this.decorators.push('return fn;');

      if (asObject) {
        this.decorators = Function.apply(this, ['fn', 'props', 'container', 'depth0', 'data', 'blockParams', 'depths', this.decorators.merge()]);
      } else {
        this.decorators.prepend('function(fn, props, container, depth0, data, blockParams, depths) {\n');
        this.decorators.push('}\n');
        this.decorators = this.decorators.merge();
      }
    } else {
      this.decorators = undefined;
    }

    var fn = this.createFunctionContext(asObject);

    if (!this.isChild) {
      var ret = {
        compiler: this.compilerInfo(),
        main: fn
      };

      if (this.decorators) {
        ret.main_d = this.decorators; // eslint-disable-line camelcase

        ret.useDecorators = true;
      }

      /*istanbul ignore next*/
      var _this$context = this.context,
          programs = _this$context.programs,
          decorators = _this$context.decorators;

      for (i = 0, l = programs.length; i < l; i++) {
        if (programs[i]) {
          ret[i] = programs[i];

          if (decorators[i]) {
            ret[i + '_d'] = decorators[i];
            ret.useDecorators = true;
          }
        }
      }

      if (this.environment.usePartial) {
        ret.usePartial = true;
      }

      if (this.options.data) {
        ret.useData = true;
      }

      if (this.useDepths) {
        ret.useDepths = true;
      }

      if (this.useBlockParams) {
        ret.useBlockParams = true;
      }

      if (this.options.compat) {
        ret.compat = true;
      }

      if (!asObject) {
        ret.compiler = JSON.stringify(ret.compiler);
        this.source.currentLocation = {
          start: {
            line: 1,
            column: 0
          }
        };
        ret = this.objectLiteral(ret);

        if (options.srcName) {
          ret = ret.toStringWithSourceMap({
            file: options.destName
          });
          ret.map = ret.map && ret.map.toString();
        } else {
          ret = ret.toString();
        }
      } else {
        ret.compilerOptions = this.options;
      }

      return ret;
    } else {
      return fn;
    }
  },
  preamble: function
  /*istanbul ignore next*/
  preamble() {
    // track the last context pushed into place to allow skipping the
    // getContext opcode when it would be a noop
    this.lastContext = 0;
    this.source = new
    /*istanbul ignore next*/
    _codeGen[
    /*istanbul ignore next*/
    "default"](this.options.srcName);
    this.decorators = new
    /*istanbul ignore next*/
    _codeGen[
    /*istanbul ignore next*/
    "default"](this.options.srcName);
  },
  createFunctionContext: function
  /*istanbul ignore next*/
  createFunctionContext(asObject) {
    /*istanbul ignore next*/
    var _this = this;

    var varDeclarations = '';
    var locals = this.stackVars.concat(this.registers.list);

    if (locals.length > 0) {
      varDeclarations += ', ' + locals.join(', ');
    } // Generate minimizer alias mappings
    //
    // When using true SourceNodes, this will update all references to the given alias
    // as the source nodes are reused in situ. For the non-source node compilation mode,
    // aliases will not be used, but this case is already being run on the client and
    // we aren't concern about minimizing the template size.


    var aliasCount = 0;
    Object.keys(this.aliases).forEach(function (alias) {
      var node = _this.aliases[alias];

      if (node.children && node.referenceCount > 1) {
        varDeclarations += ', alias' + ++aliasCount + '=' + alias;
        node.children[0] = 'alias' + aliasCount;
      }
    });

    if (this.lookupPropertyFunctionIsUsed) {
      varDeclarations += ', ' + this.lookupPropertyFunctionVarDeclaration();
    }

    var params = ['container', 'depth0', 'helpers', 'partials', 'data'];

    if (this.useBlockParams || this.useDepths) {
      params.push('blockParams');
    }

    if (this.useDepths) {
      params.push('depths');
    } // Perform a second pass over the output to merge content when possible


    var source = this.mergeSource(varDeclarations);

    if (asObject) {
      params.push(source);
      return Function.apply(this, params);
    } else {
      return this.source.wrap(['function(', params.join(','), ') {\n  ', source, '}']);
    }
  },
  mergeSource: function
  /*istanbul ignore next*/
  mergeSource(varDeclarations) {
    var isSimple = this.environment.isSimple,
        appendOnly = !this.forceBuffer,
        appendFirst,
        sourceSeen,
        bufferStart,
        bufferEnd;
    this.source.each(function (line) {
      if (line.appendToBuffer) {
        if (bufferStart) {
          line.prepend('  + ');
        } else {
          bufferStart = line;
        }

        bufferEnd = line;
      } else {
        if (bufferStart) {
          if (!sourceSeen) {
            appendFirst = true;
          } else {
            bufferStart.prepend('buffer += ');
          }

          bufferEnd.add(';');
          bufferStart = bufferEnd = undefined;
        }

        sourceSeen = true;

        if (!isSimple) {
          appendOnly = false;
        }
      }
    });

    if (appendOnly) {
      if (bufferStart) {
        bufferStart.prepend('return ');
        bufferEnd.add(';');
      } else if (!sourceSeen) {
        this.source.push('return "";');
      }
    } else {
      varDeclarations += ', buffer = ' + (appendFirst ? '' : this.initializeBuffer());

      if (bufferStart) {
        bufferStart.prepend('return buffer + ');
        bufferEnd.add(';');
      } else {
        this.source.push('return buffer;');
      }
    }

    if (varDeclarations) {
      this.source.prepend('var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\n'));
    }

    return this.source.merge();
  },
  lookupPropertyFunctionVarDeclaration: function
  /*istanbul ignore next*/
  lookupPropertyFunctionVarDeclaration() {
    return (
      /*istanbul ignore next*/
      "\n      lookupProperty = container.lookupProperty || function(parent, propertyName) {\n        if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {\n          return parent[propertyName];\n        }\n        return undefined\n    }\n    ".trim()
    );
  },
  // [blockValue]
  //
  // On stack, before: hash, inverse, program, value
  // On stack, after: return value of blockHelperMissing
  //
  // The purpose of this opcode is to take a block of the form
  // `{{#this.foo}}...{{/this.foo}}`, resolve the value of `foo`, and
  // replace it on the stack with the result of properly
  // invoking blockHelperMissing.
  blockValue: function
  /*istanbul ignore next*/
  blockValue(name) {
    var blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'),
        params = [this.contextName(0)];
    this.setupHelperArgs(name, 0, params);
    var blockName = this.popStack();
    params.splice(1, 0, blockName);
    this.push(this.source.functionCall(blockHelperMissing, 'call', params));
  },
  // [ambiguousBlockValue]
  //
  // On stack, before: hash, inverse, program, value
  // Compiler value, before: lastHelper=value of last found helper, if any
  // On stack, after, if no lastHelper: same as [blockValue]
  // On stack, after, if lastHelper: value
  ambiguousBlockValue: function
  /*istanbul ignore next*/
  ambiguousBlockValue() {
    // We're being a bit cheeky and reusing the options value from the prior exec
    var blockHelperMissing = this.aliasable('container.hooks.blockHelperMissing'),
        params = [this.contextName(0)];
    this.setupHelperArgs('', 0, params, true);
    this.flushInline();
    var current = this.topStack();
    params.splice(1, 0, current);
    this.pushSource(['if (!', this.lastHelper, ') { ', current, ' = ', this.source.functionCall(blockHelperMissing, 'call', params), '}']);
  },
  // [appendContent]
  //
  // On stack, before: ...
  // On stack, after: ...
  //
  // Appends the string value of `content` to the current buffer
  appendContent: function
  /*istanbul ignore next*/
  appendContent(content) {
    if (this.pendingContent) {
      content = this.pendingContent + content;
    } else {
      this.pendingLocation = this.source.currentLocation;
    }

    this.pendingContent = content;
  },
  // [append]
  //
  // On stack, before: value, ...
  // On stack, after: ...
  //
  // Coerces `value` to a String and appends it to the current buffer.
  //
  // If `value` is truthy, or 0, it is coerced into a string and appended
  // Otherwise, the empty string is appended
  append: function
  /*istanbul ignore next*/
  append() {
    if (this.isInline()) {
      this.replaceStack(function (current)
      /*istanbul ignore next*/
      {
        return [' != null ? ', current, ' : ""'];
      });
      this.pushSource(this.appendToBuffer(this.popStack()));
    } else {
      var local = this.popStack();
      this.pushSource(['if (', local, ' != null) { ', this.appendToBuffer(local, undefined, true), ' }']);

      if (this.environment.isSimple) {
        this.pushSource(['else { ', this.appendToBuffer("''", undefined, true), ' }']);
      }
    }
  },
  // [appendEscaped]
  //
  // On stack, before: value, ...
  // On stack, after: ...
  //
  // Escape `value` and append it to the buffer
  appendEscaped: function
  /*istanbul ignore next*/
  appendEscaped() {
    this.pushSource(this.appendToBuffer([this.aliasable('container.escapeExpression'), '(', this.popStack(), ')']));
  },
  // [getContext]
  //
  // On stack, before: ...
  // On stack, after: ...
  // Compiler value, after: lastContext=depth
  //
  // Set the value of the `lastContext` compiler value to the depth
  getContext: function
  /*istanbul ignore next*/
  getContext(depth) {
    this.lastContext = depth;
  },
  // [pushContext]
  //
  // On stack, before: ...
  // On stack, after: currentContext, ...
  //
  // Pushes the value of the current context onto the stack.
  pushContext: function
  /*istanbul ignore next*/
  pushContext() {
    this.pushStackLiteral(this.contextName(this.lastContext));
  },
  // [lookupOnContext]
  //
  // On stack, before: ...
  // On stack, after: currentContext[name], ...
  //
  // Looks up the value of `name` on the current context and pushes
  // it onto the stack.
  lookupOnContext: function
  /*istanbul ignore next*/
  lookupOnContext(parts, falsy, strict, scoped) {
    var i = 0;

    if (!scoped && this.options.compat && !this.lastContext) {
      // The depthed query is expected to handle the undefined logic for the root level that
      // is implemented below, so we evaluate that directly in compat mode
      this.push(this.depthedLookup(parts[i++]));
    } else {
      this.pushContext();
    }

    this.resolvePath('context', parts, i, falsy, strict);
  },
  // [lookupBlockParam]
  //
  // On stack, before: ...
  // On stack, after: blockParam[name], ...
  //
  // Looks up the value of `parts` on the given block param and pushes
  // it onto the stack.
  lookupBlockParam: function
  /*istanbul ignore next*/
  lookupBlockParam(blockParamId, parts) {
    this.useBlockParams = true;
    this.push(['blockParams[', blockParamId[0], '][', blockParamId[1], ']']);
    this.resolvePath('context', parts, 1);
  },
  // [lookupData]
  //
  // On stack, before: ...
  // On stack, after: data, ...
  //
  // Push the data lookup operator
  lookupData: function
  /*istanbul ignore next*/
  lookupData(depth, parts, strict) {
    if (!depth) {
      this.pushStackLiteral('data');
    } else {
      this.pushStackLiteral('container.data(data, ' + depth + ')');
    }

    this.resolvePath('data', parts, 0, true, strict);
  },
  resolvePath: function
  /*istanbul ignore next*/
  resolvePath(type, parts, i, falsy, strict) {
    /*istanbul ignore next*/
    var _this2 = this;

    if (this.options.strict || this.options.assumeObjects) {
      this.push(strictLookup(this.options.strict && strict, this, parts, type));
      return;
    }

    var len = parts.length;

    for (; i < len; i++) {
      /* eslint-disable no-loop-func */
      this.replaceStack(function (current) {
        var lookup = _this2.nameLookup(current, parts[i], type); // We want to ensure that zero and false are handled properly if the context (falsy flag)
        // needs to have the special handling for these values.


        if (!falsy) {
          return [' != null ? ', lookup, ' : ', current];
        } else {
          // Otherwise we can use generic falsy handling
          return [' && ', lookup];
        }
      });
      /* eslint-enable no-loop-func */
    }
  },
  // [resolvePossibleLambda]
  //
  // On stack, before: value, ...
  // On stack, after: resolved value, ...
  //
  // If the `value` is a lambda, replace it on the stack by
  // the return value of the lambda
  resolvePossibleLambda: function
  /*istanbul ignore next*/
  resolvePossibleLambda() {
    this.push([this.aliasable('container.lambda'), '(', this.popStack(), ', ', this.contextName(0), ')']);
  },
  // [pushStringParam]
  //
  // On stack, before: ...
  // On stack, after: string, currentContext, ...
  //
  // This opcode is designed for use in string mode, which
  // provides the string value of a parameter along with its
  // depth rather than resolving it immediately.
  pushStringParam: function
  /*istanbul ignore next*/
  pushStringParam(string, type) {
    this.pushContext();
    this.pushString(type); // If it's a subexpression, the string result
    // will be pushed after this opcode.

    if (type !== 'SubExpression') {
      if (typeof string === 'string') {
        this.pushString(string);
      } else {
        this.pushStackLiteral(string);
      }
    }
  },
  emptyHash: function
  /*istanbul ignore next*/
  emptyHash(omitEmpty) {
    if (this.trackIds) {
      this.push('{}'); // hashIds
    }

    if (this.stringParams) {
      this.push('{}'); // hashContexts

      this.push('{}'); // hashTypes
    }

    this.pushStackLiteral(omitEmpty ? 'undefined' : '{}');
  },
  pushHash: function
  /*istanbul ignore next*/
  pushHash() {
    if (this.hash) {
      this.hashes.push(this.hash);
    }

    this.hash = {
      values: {},
      types: [],
      contexts: [],
      ids: []
    };
  },
  popHash: function
  /*istanbul ignore next*/
  popHash() {
    var hash = this.hash;
    this.hash = this.hashes.pop();

    if (this.trackIds) {
      this.push(this.objectLiteral(hash.ids));
    }

    if (this.stringParams) {
      this.push(this.objectLiteral(hash.contexts));
      this.push(this.objectLiteral(hash.types));
    }

    this.push(this.objectLiteral(hash.values));
  },
  // [pushString]
  //
  // On stack, before: ...
  // On stack, after: quotedString(string), ...
  //
  // Push a quoted version of `string` onto the stack
  pushString: function
  /*istanbul ignore next*/
  pushString(string) {
    this.pushStackLiteral(this.quotedString(string));
  },
  // [pushLiteral]
  //
  // On stack, before: ...
  // On stack, after: value, ...
  //
  // Pushes a value onto the stack. This operation prevents
  // the compiler from creating a temporary variable to hold
  // it.
  pushLiteral: function
  /*istanbul ignore next*/
  pushLiteral(value) {
    this.pushStackLiteral(value);
  },
  // [pushProgram]
  //
  // On stack, before: ...
  // On stack, after: program(guid), ...
  //
  // Push a program expression onto the stack. This takes
  // a compile-time guid and converts it into a runtime-accessible
  // expression.
  pushProgram: function
  /*istanbul ignore next*/
  pushProgram(guid) {
    if (guid != null) {
      this.pushStackLiteral(this.programExpression(guid));
    } else {
      this.pushStackLiteral(null);
    }
  },

  /*istanbul ignore next*/
  // [registerDecorator]
  //
  // On stack, before: hash, program, params..., ...
  // On stack, after: ...
  //
  // Pops off the decorator's parameters, invokes the decorator,
  // and inserts the decorator into the decorators list.
  registerDecorator: function registerDecorator(paramSize, name) {
    var foundDecorator = this.nameLookup('decorators', name, 'decorator'),
        options = this.setupHelperArgs(name, paramSize);
    this.decorators.push(['fn = ', this.decorators.functionCall(foundDecorator, '', ['fn', 'props', 'container', options]), ' || fn;']);
  },
  // [invokeHelper]
  //
  // On stack, before: hash, inverse, program, params..., ...
  // On stack, after: result of helper invocation
  //
  // Pops off the helper's parameters, invokes the helper,
  // and pushes the helper's return value onto the stack.
  //
  // If the helper is not found, `helperMissing` is called.
  invokeHelper: function
  /*istanbul ignore next*/
  invokeHelper(paramSize, name, isSimple) {
    var nonHelper = this.popStack(),
        helper = this.setupHelper(paramSize, name);
    var possibleFunctionCalls = [];

    if (isSimple) {
      // direct call to helper
      possibleFunctionCalls.push(helper.name);
    } // call a function from the input object


    possibleFunctionCalls.push(nonHelper);

    if (!this.options.strict) {
      possibleFunctionCalls.push(this.aliasable('container.hooks.helperMissing'));
    }

    var functionLookupCode = ['(', this.itemsSeparatedBy(possibleFunctionCalls, '||'), ')'];
    var functionCall = this.source.functionCall(functionLookupCode, 'call', helper.callParams);
    this.push(functionCall);
  },
  itemsSeparatedBy: function
  /*istanbul ignore next*/
  itemsSeparatedBy(items, separator) {
    var result = [];
    result.push(items[0]);

    for (var i = 1; i < items.length; i++) {
      result.push(separator, items[i]);
    }

    return result;
  },
  // [invokeKnownHelper]
  //
  // On stack, before: hash, inverse, program, params..., ...
  // On stack, after: result of helper invocation
  //
  // This operation is used when the helper is known to exist,
  // so a `helperMissing` fallback is not required.
  invokeKnownHelper: function
  /*istanbul ignore next*/
  invokeKnownHelper(paramSize, name) {
    var helper = this.setupHelper(paramSize, name);
    this.push(this.source.functionCall(helper.name, 'call', helper.callParams));
  },
  // [invokeAmbiguous]
  //
  // On stack, before: hash, inverse, program, params..., ...
  // On stack, after: result of disambiguation
  //
  // This operation is used when an expression like `{{foo}}`
  // is provided, but we don't know at compile-time whether it
  // is a helper or a path.
  //
  // This operation emits more code than the other options,
  // and can be avoided by passing the `knownHelpers` and
  // `knownHelpersOnly` flags at compile-time.
  invokeAmbiguous: function
  /*istanbul ignore next*/
  invokeAmbiguous(name, helperCall) {
    this.useRegister('helper');
    var nonHelper = this.popStack();
    this.emptyHash();
    var helper = this.setupHelper(0, name, helperCall);
    var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
    var lookup = ['(', '(helper = ', helperName, ' || ', nonHelper, ')'];

    if (!this.options.strict) {
      lookup[0] = '(helper = ';
      lookup.push(' != null ? helper : ', this.aliasable('container.hooks.helperMissing'));
    }

    this.push(['(', lookup, helper.paramsInit ? ['),(', helper.paramsInit] : [], '),', '(typeof helper === ', this.aliasable('"function"'), ' ? ', this.source.functionCall('helper', 'call', helper.callParams), ' : helper))']);
  },
  // [invokePartial]
  //
  // On stack, before: context, ...
  // On stack after: result of partial invocation
  //
  // This operation pops off a context, invokes a partial with that context,
  // and pushes the result of the invocation back.
  invokePartial: function
  /*istanbul ignore next*/
  invokePartial(isDynamic, name, indent) {
    var params = [],
        options = this.setupParams(name, 1, params);

    if (isDynamic) {
      name = this.popStack();
      delete options.name;
    }

    if (indent) {
      options.indent = JSON.stringify(indent);
    }

    options.helpers = 'helpers';
    options.partials = 'partials';
    options.decorators = 'container.decorators';

    if (!isDynamic) {
      params.unshift(this.nameLookup('partials', name, 'partial'));
    } else {
      params.unshift(name);
    }

    if (this.options.compat) {
      options.depths = 'depths';
    }

    options = this.objectLiteral(options);
    params.push(options);
    this.push(this.source.functionCall('container.invokePartial', '', params));
  },
  // [assignToHash]
  //
  // On stack, before: value, ..., hash, ...
  // On stack, after: ..., hash, ...
  //
  // Pops a value off the stack and assigns it to the current hash
  assignToHash: function
  /*istanbul ignore next*/
  assignToHash(key) {
    var value = this.popStack(),
        context,
        type,
        id;

    if (this.trackIds) {
      id = this.popStack();
    }

    if (this.stringParams) {
      type = this.popStack();
      context = this.popStack();
    }

    var hash = this.hash;

    if (context) {
      hash.contexts[key] = context;
    }

    if (type) {
      hash.types[key] = type;
    }

    if (id) {
      hash.ids[key] = id;
    }

    hash.values[key] = value;
  },
  pushId: function
  /*istanbul ignore next*/
  pushId(type, name, child) {
    if (type === 'BlockParam') {
      this.pushStackLiteral('blockParams[' + name[0] + '].path[' + name[1] + ']' + (child ? ' + ' + JSON.stringify('.' + child) : ''));
    } else if (type === 'PathExpression') {
      this.pushString(name);
    } else if (type === 'SubExpression') {
      this.pushStackLiteral('true');
    } else {
      this.pushStackLiteral('null');
    }
  },
  // HELPERS
  compiler: JavaScriptCompiler,
  compileChildren: function
  /*istanbul ignore next*/
  compileChildren(environment, options) {
    var children = environment.children,
        child,
        compiler;

    for (var i = 0, l = children.length; i < l; i++) {
      child = children[i];
      compiler = new this.compiler(); // eslint-disable-line new-cap

      var existing = this.matchExistingProgram(child);

      if (existing == null) {
        this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children

        var index = this.context.programs.length;
        child.index = index;
        child.name = 'program' + index;
        this.context.programs[index] = compiler.compile(child, options, this.context, !this.precompile);
        this.context.decorators[index] = compiler.decorators;
        this.context.environments[index] = child;
        this.useDepths = this.useDepths || compiler.useDepths;
        this.useBlockParams = this.useBlockParams || compiler.useBlockParams;
        child.useDepths = this.useDepths;
        child.useBlockParams = this.useBlockParams;
      } else {
        child.index = existing.index;
        child.name = 'program' + existing.index;
        this.useDepths = this.useDepths || existing.useDepths;
        this.useBlockParams = this.useBlockParams || existing.useBlockParams;
      }
    }
  },
  matchExistingProgram: function
  /*istanbul ignore next*/
  matchExistingProgram(child) {
    for (var i = 0, len = this.context.environments.length; i < len; i++) {
      var environment = this.context.environments[i];

      if (environment && environment.equals(child)) {
        return environment;
      }
    }
  },
  programExpression: function
  /*istanbul ignore next*/
  programExpression(guid) {
    var child = this.environment.children[guid],
        programParams = [child.index, 'data', child.blockParams];

    if (this.useBlockParams || this.useDepths) {
      programParams.push('blockParams');
    }

    if (this.useDepths) {
      programParams.push('depths');
    }

    return 'container.program(' + programParams.join(', ') + ')';
  },
  useRegister: function
  /*istanbul ignore next*/
  useRegister(name) {
    if (!this.registers[name]) {
      this.registers[name] = true;
      this.registers.list.push(name);
    }
  },
  push: function
  /*istanbul ignore next*/
  push(expr) {
    if (!(expr instanceof Literal)) {
      expr = this.source.wrap(expr);
    }

    this.inlineStack.push(expr);
    return expr;
  },
  pushStackLiteral: function
  /*istanbul ignore next*/
  pushStackLiteral(item) {
    this.push(new Literal(item));
  },
  pushSource: function
  /*istanbul ignore next*/
  pushSource(source) {
    if (this.pendingContent) {
      this.source.push(this.appendToBuffer(this.source.quotedString(this.pendingContent), this.pendingLocation));
      this.pendingContent = undefined;
    }

    if (source) {
      this.source.push(source);
    }
  },
  replaceStack: function
  /*istanbul ignore next*/
  replaceStack(callback) {
    var prefix = ['('],
        stack,
        createdStack,
        usedLiteral;
    /* istanbul ignore next */

    if (!this.isInline()) {
      throw new
      /*istanbul ignore next*/
      _exception[
      /*istanbul ignore next*/
      "default"]('replaceStack on non-inline');
    } // We want to merge the inline statement into the replacement statement via ','


    var top = this.popStack(true);

    if (top instanceof Literal) {
      // Literals do not need to be inlined
      stack = [top.value];
      prefix = ['(', stack];
      usedLiteral = true;
    } else {
      // Get or create the current stack name for use by the inline
      createdStack = true;
      var name = this.incrStack();
      prefix = ['((', this.push(name), ' = ', top, ')'];
      stack = this.topStack();
    }

    var item = callback.call(this, stack);

    if (!usedLiteral) {
      this.popStack();
    }

    if (createdStack) {
      this.stackSlot--;
    }

    this.push(prefix.concat(item, ')'));
  },
  incrStack: function
  /*istanbul ignore next*/
  incrStack() {
    this.stackSlot++;

    if (this.stackSlot > this.stackVars.length) {
      this.stackVars.push('stack' + this.stackSlot);
    }

    return this.topStackName();
  },
  topStackName: function
  /*istanbul ignore next*/
  topStackName() {
    return 'stack' + this.stackSlot;
  },
  flushInline: function
  /*istanbul ignore next*/
  flushInline() {
    var inlineStack = this.inlineStack;
    this.inlineStack = [];

    for (var i = 0, len = inlineStack.length; i < len; i++) {
      var entry = inlineStack[i];
      /* istanbul ignore if */

      if (entry instanceof Literal) {
        this.compileStack.push(entry);
      } else {
        var stack = this.incrStack();
        this.pushSource([stack, ' = ', entry, ';']);
        this.compileStack.push(stack);
      }
    }
  },
  isInline: function
  /*istanbul ignore next*/
  isInline() {
    return this.inlineStack.length;
  },
  popStack: function
  /*istanbul ignore next*/
  popStack(wrapped) {
    var inline = this.isInline(),
        item = (inline ? this.inlineStack : this.compileStack).pop();

    if (!wrapped && item instanceof Literal) {
      return item.value;
    } else {
      if (!inline) {
        /* istanbul ignore next */
        if (!this.stackSlot) {
          throw new
          /*istanbul ignore next*/
          _exception[
          /*istanbul ignore next*/
          "default"]('Invalid stack pop');
        }

        this.stackSlot--;
      }

      return item;
    }
  },
  topStack: function
  /*istanbul ignore next*/
  topStack() {
    var stack = this.isInline() ? this.inlineStack : this.compileStack,
        item = stack[stack.length - 1];
    /* istanbul ignore if */

    if (item instanceof Literal) {
      return item.value;
    } else {
      return item;
    }
  },
  contextName: function
  /*istanbul ignore next*/
  contextName(context) {
    if (this.useDepths && context) {
      return 'depths[' + context + ']';
    } else {
      return 'depth' + context;
    }
  },
  quotedString: function
  /*istanbul ignore next*/
  quotedString(str) {
    return this.source.quotedString(str);
  },
  objectLiteral: function
  /*istanbul ignore next*/
  objectLiteral(obj) {
    return this.source.objectLiteral(obj);
  },
  aliasable: function
  /*istanbul ignore next*/
  aliasable(name) {
    var ret = this.aliases[name];

    if (ret) {
      ret.referenceCount++;
      return ret;
    }

    ret = this.aliases[name] = this.source.wrap(name);
    ret.aliasable = true;
    ret.referenceCount = 1;
    return ret;
  },
  setupHelper: function
  /*istanbul ignore next*/
  setupHelper(paramSize, name, blockHelper) {
    var params = [],
        paramsInit = this.setupHelperArgs(name, paramSize, params, blockHelper);
    var foundHelper = this.nameLookup('helpers', name, 'helper'),
        callContext = this.aliasable(
    /*istanbul ignore next*/
    "".concat(this.contextName(0), " != null ? ").concat(this.contextName(0), " : (container.nullContext || {})"));
    return {
      params: params,
      paramsInit: paramsInit,
      name: foundHelper,
      callParams: [callContext].concat(params)
    };
  },
  setupParams: function
  /*istanbul ignore next*/
  setupParams(helper, paramSize, params) {
    var options = {},
        contexts = [],
        types = [],
        ids = [],
        objectArgs = !params,
        param;

    if (objectArgs) {
      params = [];
    }

    options.name = this.quotedString(helper);
    options.hash = this.popStack();

    if (this.trackIds) {
      options.hashIds = this.popStack();
    }

    if (this.stringParams) {
      options.hashTypes = this.popStack();
      options.hashContexts = this.popStack();
    }

    var inverse = this.popStack(),
        program = this.popStack(); // Avoid setting fn and inverse if neither are set. This allows
    // helpers to do a check for `if (options.fn)`

    if (program || inverse) {
      options.fn = program || 'container.noop';
      options.inverse = inverse || 'container.noop';
    } // The parameters go on to the stack in order (making sure that they are evaluated in order)
    // so we need to pop them off the stack in reverse order


    var i = paramSize;

    while (i--) {
      param = this.popStack();
      params[i] = param;

      if (this.trackIds) {
        ids[i] = this.popStack();
      }

      if (this.stringParams) {
        types[i] = this.popStack();
        contexts[i] = this.popStack();
      }
    }

    if (objectArgs) {
      options.args = this.source.generateArray(params);
    }

    if (this.trackIds) {
      options.ids = this.source.generateArray(ids);
    }

    if (this.stringParams) {
      options.types = this.source.generateArray(types);
      options.contexts = this.source.generateArray(contexts);
    }

    if (this.options.data) {
      options.data = 'data';
    }

    if (this.useBlockParams) {
      options.blockParams = 'blockParams';
    }

    return options;
  },
  setupHelperArgs: function
  /*istanbul ignore next*/
  setupHelperArgs(helper, paramSize, params, useRegister) {
    var options = this.setupParams(helper, paramSize, params);
    options.loc = JSON.stringify(this.source.currentLocation);
    options = this.objectLiteral(options);

    if (useRegister) {
      this.useRegister('options');
      params.push('options');
      return ['options=', options];
    } else if (params) {
      params.push(options);
      return '';
    } else {
      return options;
    }
  }
};

(function () {
  var reservedWords = ('break else new var' + ' case finally return void' + ' catch for switch while' + ' continue function this with' + ' default if throw' + ' delete in try' + ' do instanceof typeof' + ' abstract enum int short' + ' boolean export interface static' + ' byte extends long super' + ' char final native synchronized' + ' class float package throws' + ' const goto private transient' + ' debugger implements protected volatile' + ' double import public let yield await' + ' null true false').split(' ');
  var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};

  for (var i = 0, l = reservedWords.length; i < l; i++) {
    compilerWords[reservedWords[i]] = true;
  }
})();
/**
 * @deprecated May be removed in the next major version
 */


JavaScriptCompiler.isValidJavaScriptVariableName = function (name) {
  return !JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name);
};

function strictLookup(requireTerminal, compiler, parts, type) {
  var stack = compiler.popStack(),
      i = 0,
      len = parts.length;

  if (requireTerminal) {
    len--;
  }

  for (; i < len; i++) {
    stack = compiler.nameLookup(stack, parts[i], type);
  }

  if (requireTerminal) {
    return [compiler.aliasable('container.strict'), '(', stack, ', ', compiler.quotedString(parts[i]), ', ', JSON.stringify(compiler.source.currentLocation), ' )'];
  } else {
    return stack;
  }
}

/*istanbul ignore next*/
var _default = JavaScriptCompiler;

/*istanbul ignore next*/
exports["default"] = _default;
module.exports = exports.default;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../lib/handlebars/compiler/javascript-compiler.js"],"names":["Literal","value","JavaScriptCompiler","prototype","nameLookup","parent","name","internalNameLookup","depthedLookup","aliasable","JSON","stringify","compilerInfo","revision","COMPILER_REVISION","versions","REVISION_CHANGES","appendToBuffer","source","location","explicit","isArray","wrap","environment","isSimple","initializeBuffer","quotedString","lookupPropertyFunctionIsUsed","compile","options","context","asObject","stringParams","trackIds","precompile","isChild","decorators","programs","environments","preamble","stackSlot","stackVars","aliases","registers","list","hashes","compileStack","inlineStack","blockParams","compileChildren","useDepths","useDecorators","compat","useBlockParams","opcodes","opcode","firstLoc","i","l","length","currentLocation","loc","apply","args","pushSource","Exception","isEmpty","prepend","lookupPropertyFunctionVarDeclaration","push","Function","merge","undefined","fn","createFunctionContext","ret","compiler","main","main_d","usePartial","data","useData","start","line","column","objectLiteral","srcName","toStringWithSourceMap","file","destName","map","toString","compilerOptions","lastContext","CodeGen","varDeclarations","locals","concat","join","aliasCount","Object","keys","forEach","alias","node","children","referenceCount","params","mergeSource","appendOnly","forceBuffer","appendFirst","sourceSeen","bufferStart","bufferEnd","each","add","substring","trim","blockValue","blockHelperMissing","contextName","setupHelperArgs","blockName","popStack","splice","functionCall","ambiguousBlockValue","flushInline","current","topStack","lastHelper","appendContent","content","pendingContent","pendingLocation","append","isInline","replaceStack","local","appendEscaped","getContext","depth","pushContext","pushStackLiteral","lookupOnContext","parts","falsy","strict","scoped","resolvePath","lookupBlockParam","blockParamId","lookupData","type","assumeObjects","strictLookup","len","lookup","resolvePossibleLambda","pushStringParam","string","pushString","emptyHash","omitEmpty","pushHash","hash","values","types","contexts","ids","popHash","pop","pushLiteral","pushProgram","guid","programExpression","registerDecorator","paramSize","foundDecorator","invokeHelper","nonHelper","helper","setupHelper","possibleFunctionCalls","functionLookupCode","itemsSeparatedBy","callParams","items","separator","result","invokeKnownHelper","invokeAmbiguous","helperCall","useRegister","helperName","paramsInit","invokePartial","isDynamic","indent","setupParams","helpers","partials","unshift","depths","assignToHash","key","id","pushId","child","existing","matchExistingProgram","index","equals","programParams","expr","item","callback","prefix","stack","createdStack","usedLiteral","top","incrStack","call","topStackName","entry","wrapped","inline","str","obj","blockHelper","foundHelper","callContext","objectArgs","param","hashIds","hashTypes","hashContexts","inverse","program","generateArray","reservedWords","split","compilerWords","RESERVED_WORDS","isValidJavaScriptVariableName","test","requireTerminal"],"mappings":"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","sourcesContent":["import { COMPILER_REVISION, REVISION_CHANGES } from '../base';\nimport Exception from '../exception';\nimport { isArray } from '../utils';\nimport CodeGen from './code-gen';\n\nfunction Literal(value) {\n  this.value = value;\n}\n\nfunction JavaScriptCompiler() {}\n\nJavaScriptCompiler.prototype = {\n  // PUBLIC API: You can override these methods in a subclass to provide\n  // alternative compiled forms for name lookup and buffering semantics\n  nameLookup: function(parent, name /*,  type */) {\n    return this.internalNameLookup(parent, name);\n  },\n  depthedLookup: function(name) {\n    return [\n      this.aliasable('container.lookup'),\n      '(depths, ',\n      JSON.stringify(name),\n      ')'\n    ];\n  },\n\n  compilerInfo: function() {\n    const revision = COMPILER_REVISION,\n      versions = REVISION_CHANGES[revision];\n    return [revision, versions];\n  },\n\n  appendToBuffer: function(source, location, explicit) {\n    // Force a source as this simplifies the merge logic.\n    if (!isArray(source)) {\n      source = [source];\n    }\n    source = this.source.wrap(source, location);\n\n    if (this.environment.isSimple) {\n      return ['return ', source, ';'];\n    } else if (explicit) {\n      // This is a case where the buffer operation occurs as a child of another\n      // construct, generally braces. We have to explicitly output these buffer\n      // operations to ensure that the emitted code goes in the correct location.\n      return ['buffer += ', source, ';'];\n    } else {\n      source.appendToBuffer = true;\n      return source;\n    }\n  },\n\n  initializeBuffer: function() {\n    return this.quotedString('');\n  },\n  // END PUBLIC API\n  internalNameLookup: function(parent, name) {\n    this.lookupPropertyFunctionIsUsed = true;\n    return ['lookupProperty(', parent, ',', JSON.stringify(name), ')'];\n  },\n\n  lookupPropertyFunctionIsUsed: false,\n\n  compile: function(environment, options, context, asObject) {\n    this.environment = environment;\n    this.options = options;\n    this.stringParams = this.options.stringParams;\n    this.trackIds = this.options.trackIds;\n    this.precompile = !asObject;\n\n    this.name = this.environment.name;\n    this.isChild = !!context;\n    this.context = context || {\n      decorators: [],\n      programs: [],\n      environments: []\n    };\n\n    this.preamble();\n\n    this.stackSlot = 0;\n    this.stackVars = [];\n    this.aliases = {};\n    this.registers = { list: [] };\n    this.hashes = [];\n    this.compileStack = [];\n    this.inlineStack = [];\n    this.blockParams = [];\n\n    this.compileChildren(environment, options);\n\n    this.useDepths =\n      this.useDepths ||\n      environment.useDepths ||\n      environment.useDecorators ||\n      this.options.compat;\n    this.useBlockParams = this.useBlockParams || environment.useBlockParams;\n\n    let opcodes = environment.opcodes,\n      opcode,\n      firstLoc,\n      i,\n      l;\n\n    for (i = 0, l = opcodes.length; i < l; i++) {\n      opcode = opcodes[i];\n\n      this.source.currentLocation = opcode.loc;\n      firstLoc = firstLoc || opcode.loc;\n      this[opcode.opcode].apply(this, opcode.args);\n    }\n\n    // Flush any trailing content that might be pending.\n    this.source.currentLocation = firstLoc;\n    this.pushSource('');\n\n    /* istanbul ignore next */\n    if (this.stackSlot || this.inlineStack.length || this.compileStack.length) {\n      throw new Exception('Compile completed with content left on stack');\n    }\n\n    if (!this.decorators.isEmpty()) {\n      this.useDecorators = true;\n\n      this.decorators.prepend([\n        'var decorators = container.decorators, ',\n        this.lookupPropertyFunctionVarDeclaration(),\n        ';\\n'\n      ]);\n      this.decorators.push('return fn;');\n\n      if (asObject) {\n        this.decorators = Function.apply(this, [\n          'fn',\n          'props',\n          'container',\n          'depth0',\n          'data',\n          'blockParams',\n          'depths',\n          this.decorators.merge()\n        ]);\n      } else {\n        this.decorators.prepend(\n          'function(fn, props, container, depth0, data, blockParams, depths) {\\n'\n        );\n        this.decorators.push('}\\n');\n        this.decorators = this.decorators.merge();\n      }\n    } else {\n      this.decorators = undefined;\n    }\n\n    let fn = this.createFunctionContext(asObject);\n    if (!this.isChild) {\n      let ret = {\n        compiler: this.compilerInfo(),\n        main: fn\n      };\n\n      if (this.decorators) {\n        ret.main_d = this.decorators; // eslint-disable-line camelcase\n        ret.useDecorators = true;\n      }\n\n      let { programs, decorators } = this.context;\n      for (i = 0, l = programs.length; i < l; i++) {\n        if (programs[i]) {\n          ret[i] = programs[i];\n          if (decorators[i]) {\n            ret[i + '_d'] = decorators[i];\n            ret.useDecorators = true;\n          }\n        }\n      }\n\n      if (this.environment.usePartial) {\n        ret.usePartial = true;\n      }\n      if (this.options.data) {\n        ret.useData = true;\n      }\n      if (this.useDepths) {\n        ret.useDepths = true;\n      }\n      if (this.useBlockParams) {\n        ret.useBlockParams = true;\n      }\n      if (this.options.compat) {\n        ret.compat = true;\n      }\n\n      if (!asObject) {\n        ret.compiler = JSON.stringify(ret.compiler);\n\n        this.source.currentLocation = { start: { line: 1, column: 0 } };\n        ret = this.objectLiteral(ret);\n\n        if (options.srcName) {\n          ret = ret.toStringWithSourceMap({ file: options.destName });\n          ret.map = ret.map && ret.map.toString();\n        } else {\n          ret = ret.toString();\n        }\n      } else {\n        ret.compilerOptions = this.options;\n      }\n\n      return ret;\n    } else {\n      return fn;\n    }\n  },\n\n  preamble: function() {\n    // track the last context pushed into place to allow skipping the\n    // getContext opcode when it would be a noop\n    this.lastContext = 0;\n    this.source = new CodeGen(this.options.srcName);\n    this.decorators = new CodeGen(this.options.srcName);\n  },\n\n  createFunctionContext: function(asObject) {\n    let varDeclarations = '';\n\n    let locals = this.stackVars.concat(this.registers.list);\n    if (locals.length > 0) {\n      varDeclarations += ', ' + locals.join(', ');\n    }\n\n    // Generate minimizer alias mappings\n    //\n    // When using true SourceNodes, this will update all references to the given alias\n    // as the source nodes are reused in situ. For the non-source node compilation mode,\n    // aliases will not be used, but this case is already being run on the client and\n    // we aren't concern about minimizing the template size.\n    let aliasCount = 0;\n    Object.keys(this.aliases).forEach(alias => {\n      let node = this.aliases[alias];\n      if (node.children && node.referenceCount > 1) {\n        varDeclarations += ', alias' + ++aliasCount + '=' + alias;\n        node.children[0] = 'alias' + aliasCount;\n      }\n    });\n\n    if (this.lookupPropertyFunctionIsUsed) {\n      varDeclarations += ', ' + this.lookupPropertyFunctionVarDeclaration();\n    }\n\n    let params = ['container', 'depth0', 'helpers', 'partials', 'data'];\n\n    if (this.useBlockParams || this.useDepths) {\n      params.push('blockParams');\n    }\n    if (this.useDepths) {\n      params.push('depths');\n    }\n\n    // Perform a second pass over the output to merge content when possible\n    let source = this.mergeSource(varDeclarations);\n\n    if (asObject) {\n      params.push(source);\n\n      return Function.apply(this, params);\n    } else {\n      return this.source.wrap([\n        'function(',\n        params.join(','),\n        ') {\\n  ',\n        source,\n        '}'\n      ]);\n    }\n  },\n  mergeSource: function(varDeclarations) {\n    let isSimple = this.environment.isSimple,\n      appendOnly = !this.forceBuffer,\n      appendFirst,\n      sourceSeen,\n      bufferStart,\n      bufferEnd;\n    this.source.each(line => {\n      if (line.appendToBuffer) {\n        if (bufferStart) {\n          line.prepend('  + ');\n        } else {\n          bufferStart = line;\n        }\n        bufferEnd = line;\n      } else {\n        if (bufferStart) {\n          if (!sourceSeen) {\n            appendFirst = true;\n          } else {\n            bufferStart.prepend('buffer += ');\n          }\n          bufferEnd.add(';');\n          bufferStart = bufferEnd = undefined;\n        }\n\n        sourceSeen = true;\n        if (!isSimple) {\n          appendOnly = false;\n        }\n      }\n    });\n\n    if (appendOnly) {\n      if (bufferStart) {\n        bufferStart.prepend('return ');\n        bufferEnd.add(';');\n      } else if (!sourceSeen) {\n        this.source.push('return \"\";');\n      }\n    } else {\n      varDeclarations +=\n        ', buffer = ' + (appendFirst ? '' : this.initializeBuffer());\n\n      if (bufferStart) {\n        bufferStart.prepend('return buffer + ');\n        bufferEnd.add(';');\n      } else {\n        this.source.push('return buffer;');\n      }\n    }\n\n    if (varDeclarations) {\n      this.source.prepend(\n        'var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\\n')\n      );\n    }\n\n    return this.source.merge();\n  },\n\n  lookupPropertyFunctionVarDeclaration: function() {\n    return `\n      lookupProperty = container.lookupProperty || function(parent, propertyName) {\n        if (Object.prototype.hasOwnProperty.call(parent, propertyName)) {\n          return parent[propertyName];\n        }\n        return undefined\n    }\n    `.trim();\n  },\n\n  // [blockValue]\n  //\n  // On stack, before: hash, inverse, program, value\n  // On stack, after: return value of blockHelperMissing\n  //\n  // The purpose of this opcode is to take a block of the form\n  // `{{#this.foo}}...{{/this.foo}}`, resolve the value of `foo`, and\n  // replace it on the stack with the result of properly\n  // invoking blockHelperMissing.\n  blockValue: function(name) {\n    let blockHelperMissing = this.aliasable(\n        'container.hooks.blockHelperMissing'\n      ),\n      params = [this.contextName(0)];\n    this.setupHelperArgs(name, 0, params);\n\n    let blockName = this.popStack();\n    params.splice(1, 0, blockName);\n\n    this.push(this.source.functionCall(blockHelperMissing, 'call', params));\n  },\n\n  // [ambiguousBlockValue]\n  //\n  // On stack, before: hash, inverse, program, value\n  // Compiler value, before: lastHelper=value of last found helper, if any\n  // On stack, after, if no lastHelper: same as [blockValue]\n  // On stack, after, if lastHelper: value\n  ambiguousBlockValue: function() {\n    // We're being a bit cheeky and reusing the options value from the prior exec\n    let blockHelperMissing = this.aliasable(\n        'container.hooks.blockHelperMissing'\n      ),\n      params = [this.contextName(0)];\n    this.setupHelperArgs('', 0, params, true);\n\n    this.flushInline();\n\n    let current = this.topStack();\n    params.splice(1, 0, current);\n\n    this.pushSource([\n      'if (!',\n      this.lastHelper,\n      ') { ',\n      current,\n      ' = ',\n      this.source.functionCall(blockHelperMissing, 'call', params),\n      '}'\n    ]);\n  },\n\n  // [appendContent]\n  //\n  // On stack, before: ...\n  // On stack, after: ...\n  //\n  // Appends the string value of `content` to the current buffer\n  appendContent: function(content) {\n    if (this.pendingContent) {\n      content = this.pendingContent + content;\n    } else {\n      this.pendingLocation = this.source.currentLocation;\n    }\n\n    this.pendingContent = content;\n  },\n\n  // [append]\n  //\n  // On stack, before: value, ...\n  // On stack, after: ...\n  //\n  // Coerces `value` to a String and appends it to the current buffer.\n  //\n  // If `value` is truthy, or 0, it is coerced into a string and appended\n  // Otherwise, the empty string is appended\n  append: function() {\n    if (this.isInline()) {\n      this.replaceStack(current => [' != null ? ', current, ' : \"\"']);\n\n      this.pushSource(this.appendToBuffer(this.popStack()));\n    } else {\n      let local = this.popStack();\n      this.pushSource([\n        'if (',\n        local,\n        ' != null) { ',\n        this.appendToBuffer(local, undefined, true),\n        ' }'\n      ]);\n      if (this.environment.isSimple) {\n        this.pushSource([\n          'else { ',\n          this.appendToBuffer(\"''\", undefined, true),\n          ' }'\n        ]);\n      }\n    }\n  },\n\n  // [appendEscaped]\n  //\n  // On stack, before: value, ...\n  // On stack, after: ...\n  //\n  // Escape `value` and append it to the buffer\n  appendEscaped: function() {\n    this.pushSource(\n      this.appendToBuffer([\n        this.aliasable('container.escapeExpression'),\n        '(',\n        this.popStack(),\n        ')'\n      ])\n    );\n  },\n\n  // [getContext]\n  //\n  // On stack, before: ...\n  // On stack, after: ...\n  // Compiler value, after: lastContext=depth\n  //\n  // Set the value of the `lastContext` compiler value to the depth\n  getContext: function(depth) {\n    this.lastContext = depth;\n  },\n\n  // [pushContext]\n  //\n  // On stack, before: ...\n  // On stack, after: currentContext, ...\n  //\n  // Pushes the value of the current context onto the stack.\n  pushContext: function() {\n    this.pushStackLiteral(this.contextName(this.lastContext));\n  },\n\n  // [lookupOnContext]\n  //\n  // On stack, before: ...\n  // On stack, after: currentContext[name], ...\n  //\n  // Looks up the value of `name` on the current context and pushes\n  // it onto the stack.\n  lookupOnContext: function(parts, falsy, strict, scoped) {\n    let i = 0;\n\n    if (!scoped && this.options.compat && !this.lastContext) {\n      // The depthed query is expected to handle the undefined logic for the root level that\n      // is implemented below, so we evaluate that directly in compat mode\n      this.push(this.depthedLookup(parts[i++]));\n    } else {\n      this.pushContext();\n    }\n\n    this.resolvePath('context', parts, i, falsy, strict);\n  },\n\n  // [lookupBlockParam]\n  //\n  // On stack, before: ...\n  // On stack, after: blockParam[name], ...\n  //\n  // Looks up the value of `parts` on the given block param and pushes\n  // it onto the stack.\n  lookupBlockParam: function(blockParamId, parts) {\n    this.useBlockParams = true;\n\n    this.push(['blockParams[', blockParamId[0], '][', blockParamId[1], ']']);\n    this.resolvePath('context', parts, 1);\n  },\n\n  // [lookupData]\n  //\n  // On stack, before: ...\n  // On stack, after: data, ...\n  //\n  // Push the data lookup operator\n  lookupData: function(depth, parts, strict) {\n    if (!depth) {\n      this.pushStackLiteral('data');\n    } else {\n      this.pushStackLiteral('container.data(data, ' + depth + ')');\n    }\n\n    this.resolvePath('data', parts, 0, true, strict);\n  },\n\n  resolvePath: function(type, parts, i, falsy, strict) {\n    if (this.options.strict || this.options.assumeObjects) {\n      this.push(strictLookup(this.options.strict && strict, this, parts, type));\n      return;\n    }\n\n    let len = parts.length;\n    for (; i < len; i++) {\n      /* eslint-disable no-loop-func */\n      this.replaceStack(current => {\n        let lookup = this.nameLookup(current, parts[i], type);\n        // We want to ensure that zero and false are handled properly if the context (falsy flag)\n        // needs to have the special handling for these values.\n        if (!falsy) {\n          return [' != null ? ', lookup, ' : ', current];\n        } else {\n          // Otherwise we can use generic falsy handling\n          return [' && ', lookup];\n        }\n      });\n      /* eslint-enable no-loop-func */\n    }\n  },\n\n  // [resolvePossibleLambda]\n  //\n  // On stack, before: value, ...\n  // On stack, after: resolved value, ...\n  //\n  // If the `value` is a lambda, replace it on the stack by\n  // the return value of the lambda\n  resolvePossibleLambda: function() {\n    this.push([\n      this.aliasable('container.lambda'),\n      '(',\n      this.popStack(),\n      ', ',\n      this.contextName(0),\n      ')'\n    ]);\n  },\n\n  // [pushStringParam]\n  //\n  // On stack, before: ...\n  // On stack, after: string, currentContext, ...\n  //\n  // This opcode is designed for use in string mode, which\n  // provides the string value of a parameter along with its\n  // depth rather than resolving it immediately.\n  pushStringParam: function(string, type) {\n    this.pushContext();\n    this.pushString(type);\n\n    // If it's a subexpression, the string result\n    // will be pushed after this opcode.\n    if (type !== 'SubExpression') {\n      if (typeof string === 'string') {\n        this.pushString(string);\n      } else {\n        this.pushStackLiteral(string);\n      }\n    }\n  },\n\n  emptyHash: function(omitEmpty) {\n    if (this.trackIds) {\n      this.push('{}'); // hashIds\n    }\n    if (this.stringParams) {\n      this.push('{}'); // hashContexts\n      this.push('{}'); // hashTypes\n    }\n    this.pushStackLiteral(omitEmpty ? 'undefined' : '{}');\n  },\n  pushHash: function() {\n    if (this.hash) {\n      this.hashes.push(this.hash);\n    }\n    this.hash = { values: {}, types: [], contexts: [], ids: [] };\n  },\n  popHash: function() {\n    let hash = this.hash;\n    this.hash = this.hashes.pop();\n\n    if (this.trackIds) {\n      this.push(this.objectLiteral(hash.ids));\n    }\n    if (this.stringParams) {\n      this.push(this.objectLiteral(hash.contexts));\n      this.push(this.objectLiteral(hash.types));\n    }\n\n    this.push(this.objectLiteral(hash.values));\n  },\n\n  // [pushString]\n  //\n  // On stack, before: ...\n  // On stack, after: quotedString(string), ...\n  //\n  // Push a quoted version of `string` onto the stack\n  pushString: function(string) {\n    this.pushStackLiteral(this.quotedString(string));\n  },\n\n  // [pushLiteral]\n  //\n  // On stack, before: ...\n  // On stack, after: value, ...\n  //\n  // Pushes a value onto the stack. This operation prevents\n  // the compiler from creating a temporary variable to hold\n  // it.\n  pushLiteral: function(value) {\n    this.pushStackLiteral(value);\n  },\n\n  // [pushProgram]\n  //\n  // On stack, before: ...\n  // On stack, after: program(guid), ...\n  //\n  // Push a program expression onto the stack. This takes\n  // a compile-time guid and converts it into a runtime-accessible\n  // expression.\n  pushProgram: function(guid) {\n    if (guid != null) {\n      this.pushStackLiteral(this.programExpression(guid));\n    } else {\n      this.pushStackLiteral(null);\n    }\n  },\n\n  // [registerDecorator]\n  //\n  // On stack, before: hash, program, params..., ...\n  // On stack, after: ...\n  //\n  // Pops off the decorator's parameters, invokes the decorator,\n  // and inserts the decorator into the decorators list.\n  registerDecorator(paramSize, name) {\n    let foundDecorator = this.nameLookup('decorators', name, 'decorator'),\n      options = this.setupHelperArgs(name, paramSize);\n\n    this.decorators.push([\n      'fn = ',\n      this.decorators.functionCall(foundDecorator, '', [\n        'fn',\n        'props',\n        'container',\n        options\n      ]),\n      ' || fn;'\n    ]);\n  },\n\n  // [invokeHelper]\n  //\n  // On stack, before: hash, inverse, program, params..., ...\n  // On stack, after: result of helper invocation\n  //\n  // Pops off the helper's parameters, invokes the helper,\n  // and pushes the helper's return value onto the stack.\n  //\n  // If the helper is not found, `helperMissing` is called.\n  invokeHelper: function(paramSize, name, isSimple) {\n    let nonHelper = this.popStack(),\n      helper = this.setupHelper(paramSize, name);\n\n    let possibleFunctionCalls = [];\n\n    if (isSimple) {\n      // direct call to helper\n      possibleFunctionCalls.push(helper.name);\n    }\n    // call a function from the input object\n    possibleFunctionCalls.push(nonHelper);\n    if (!this.options.strict) {\n      possibleFunctionCalls.push(\n        this.aliasable('container.hooks.helperMissing')\n      );\n    }\n\n    let functionLookupCode = [\n      '(',\n      this.itemsSeparatedBy(possibleFunctionCalls, '||'),\n      ')'\n    ];\n    let functionCall = this.source.functionCall(\n      functionLookupCode,\n      'call',\n      helper.callParams\n    );\n    this.push(functionCall);\n  },\n\n  itemsSeparatedBy: function(items, separator) {\n    let result = [];\n    result.push(items[0]);\n    for (let i = 1; i < items.length; i++) {\n      result.push(separator, items[i]);\n    }\n    return result;\n  },\n  // [invokeKnownHelper]\n  //\n  // On stack, before: hash, inverse, program, params..., ...\n  // On stack, after: result of helper invocation\n  //\n  // This operation is used when the helper is known to exist,\n  // so a `helperMissing` fallback is not required.\n  invokeKnownHelper: function(paramSize, name) {\n    let helper = this.setupHelper(paramSize, name);\n    this.push(this.source.functionCall(helper.name, 'call', helper.callParams));\n  },\n\n  // [invokeAmbiguous]\n  //\n  // On stack, before: hash, inverse, program, params..., ...\n  // On stack, after: result of disambiguation\n  //\n  // This operation is used when an expression like `{{foo}}`\n  // is provided, but we don't know at compile-time whether it\n  // is a helper or a path.\n  //\n  // This operation emits more code than the other options,\n  // and can be avoided by passing the `knownHelpers` and\n  // `knownHelpersOnly` flags at compile-time.\n  invokeAmbiguous: function(name, helperCall) {\n    this.useRegister('helper');\n\n    let nonHelper = this.popStack();\n\n    this.emptyHash();\n    let helper = this.setupHelper(0, name, helperCall);\n\n    let helperName = (this.lastHelper = this.nameLookup(\n      'helpers',\n      name,\n      'helper'\n    ));\n\n    let lookup = ['(', '(helper = ', helperName, ' || ', nonHelper, ')'];\n    if (!this.options.strict) {\n      lookup[0] = '(helper = ';\n      lookup.push(\n        ' != null ? helper : ',\n        this.aliasable('container.hooks.helperMissing')\n      );\n    }\n\n    this.push([\n      '(',\n      lookup,\n      helper.paramsInit ? ['),(', helper.paramsInit] : [],\n      '),',\n      '(typeof helper === ',\n      this.aliasable('\"function\"'),\n      ' ? ',\n      this.source.functionCall('helper', 'call', helper.callParams),\n      ' : helper))'\n    ]);\n  },\n\n  // [invokePartial]\n  //\n  // On stack, before: context, ...\n  // On stack after: result of partial invocation\n  //\n  // This operation pops off a context, invokes a partial with that context,\n  // and pushes the result of the invocation back.\n  invokePartial: function(isDynamic, name, indent) {\n    let params = [],\n      options = this.setupParams(name, 1, params);\n\n    if (isDynamic) {\n      name = this.popStack();\n      delete options.name;\n    }\n\n    if (indent) {\n      options.indent = JSON.stringify(indent);\n    }\n    options.helpers = 'helpers';\n    options.partials = 'partials';\n    options.decorators = 'container.decorators';\n\n    if (!isDynamic) {\n      params.unshift(this.nameLookup('partials', name, 'partial'));\n    } else {\n      params.unshift(name);\n    }\n\n    if (this.options.compat) {\n      options.depths = 'depths';\n    }\n    options = this.objectLiteral(options);\n    params.push(options);\n\n    this.push(this.source.functionCall('container.invokePartial', '', params));\n  },\n\n  // [assignToHash]\n  //\n  // On stack, before: value, ..., hash, ...\n  // On stack, after: ..., hash, ...\n  //\n  // Pops a value off the stack and assigns it to the current hash\n  assignToHash: function(key) {\n    let value = this.popStack(),\n      context,\n      type,\n      id;\n\n    if (this.trackIds) {\n      id = this.popStack();\n    }\n    if (this.stringParams) {\n      type = this.popStack();\n      context = this.popStack();\n    }\n\n    let hash = this.hash;\n    if (context) {\n      hash.contexts[key] = context;\n    }\n    if (type) {\n      hash.types[key] = type;\n    }\n    if (id) {\n      hash.ids[key] = id;\n    }\n    hash.values[key] = value;\n  },\n\n  pushId: function(type, name, child) {\n    if (type === 'BlockParam') {\n      this.pushStackLiteral(\n        'blockParams[' +\n          name[0] +\n          '].path[' +\n          name[1] +\n          ']' +\n          (child ? ' + ' + JSON.stringify('.' + child) : '')\n      );\n    } else if (type === 'PathExpression') {\n      this.pushString(name);\n    } else if (type === 'SubExpression') {\n      this.pushStackLiteral('true');\n    } else {\n      this.pushStackLiteral('null');\n    }\n  },\n\n  // HELPERS\n\n  compiler: JavaScriptCompiler,\n\n  compileChildren: function(environment, options) {\n    let children = environment.children,\n      child,\n      compiler;\n\n    for (let i = 0, l = children.length; i < l; i++) {\n      child = children[i];\n      compiler = new this.compiler(); // eslint-disable-line new-cap\n\n      let existing = this.matchExistingProgram(child);\n\n      if (existing == null) {\n        this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children\n        let index = this.context.programs.length;\n        child.index = index;\n        child.name = 'program' + index;\n        this.context.programs[index] = compiler.compile(\n          child,\n          options,\n          this.context,\n          !this.precompile\n        );\n        this.context.decorators[index] = compiler.decorators;\n        this.context.environments[index] = child;\n\n        this.useDepths = this.useDepths || compiler.useDepths;\n        this.useBlockParams = this.useBlockParams || compiler.useBlockParams;\n        child.useDepths = this.useDepths;\n        child.useBlockParams = this.useBlockParams;\n      } else {\n        child.index = existing.index;\n        child.name = 'program' + existing.index;\n\n        this.useDepths = this.useDepths || existing.useDepths;\n        this.useBlockParams = this.useBlockParams || existing.useBlockParams;\n      }\n    }\n  },\n  matchExistingProgram: function(child) {\n    for (let i = 0, len = this.context.environments.length; i < len; i++) {\n      let environment = this.context.environments[i];\n      if (environment && environment.equals(child)) {\n        return environment;\n      }\n    }\n  },\n\n  programExpression: function(guid) {\n    let child = this.environment.children[guid],\n      programParams = [child.index, 'data', child.blockParams];\n\n    if (this.useBlockParams || this.useDepths) {\n      programParams.push('blockParams');\n    }\n    if (this.useDepths) {\n      programParams.push('depths');\n    }\n\n    return 'container.program(' + programParams.join(', ') + ')';\n  },\n\n  useRegister: function(name) {\n    if (!this.registers[name]) {\n      this.registers[name] = true;\n      this.registers.list.push(name);\n    }\n  },\n\n  push: function(expr) {\n    if (!(expr instanceof Literal)) {\n      expr = this.source.wrap(expr);\n    }\n\n    this.inlineStack.push(expr);\n    return expr;\n  },\n\n  pushStackLiteral: function(item) {\n    this.push(new Literal(item));\n  },\n\n  pushSource: function(source) {\n    if (this.pendingContent) {\n      this.source.push(\n        this.appendToBuffer(\n          this.source.quotedString(this.pendingContent),\n          this.pendingLocation\n        )\n      );\n      this.pendingContent = undefined;\n    }\n\n    if (source) {\n      this.source.push(source);\n    }\n  },\n\n  replaceStack: function(callback) {\n    let prefix = ['('],\n      stack,\n      createdStack,\n      usedLiteral;\n\n    /* istanbul ignore next */\n    if (!this.isInline()) {\n      throw new Exception('replaceStack on non-inline');\n    }\n\n    // We want to merge the inline statement into the replacement statement via ','\n    let top = this.popStack(true);\n\n    if (top instanceof Literal) {\n      // Literals do not need to be inlined\n      stack = [top.value];\n      prefix = ['(', stack];\n      usedLiteral = true;\n    } else {\n      // Get or create the current stack name for use by the inline\n      createdStack = true;\n      let name = this.incrStack();\n\n      prefix = ['((', this.push(name), ' = ', top, ')'];\n      stack = this.topStack();\n    }\n\n    let item = callback.call(this, stack);\n\n    if (!usedLiteral) {\n      this.popStack();\n    }\n    if (createdStack) {\n      this.stackSlot--;\n    }\n    this.push(prefix.concat(item, ')'));\n  },\n\n  incrStack: function() {\n    this.stackSlot++;\n    if (this.stackSlot > this.stackVars.length) {\n      this.stackVars.push('stack' + this.stackSlot);\n    }\n    return this.topStackName();\n  },\n  topStackName: function() {\n    return 'stack' + this.stackSlot;\n  },\n  flushInline: function() {\n    let inlineStack = this.inlineStack;\n    this.inlineStack = [];\n    for (let i = 0, len = inlineStack.length; i < len; i++) {\n      let entry = inlineStack[i];\n      /* istanbul ignore if */\n      if (entry instanceof Literal) {\n        this.compileStack.push(entry);\n      } else {\n        let stack = this.incrStack();\n        this.pushSource([stack, ' = ', entry, ';']);\n        this.compileStack.push(stack);\n      }\n    }\n  },\n  isInline: function() {\n    return this.inlineStack.length;\n  },\n\n  popStack: function(wrapped) {\n    let inline = this.isInline(),\n      item = (inline ? this.inlineStack : this.compileStack).pop();\n\n    if (!wrapped && item instanceof Literal) {\n      return item.value;\n    } else {\n      if (!inline) {\n        /* istanbul ignore next */\n        if (!this.stackSlot) {\n          throw new Exception('Invalid stack pop');\n        }\n        this.stackSlot--;\n      }\n      return item;\n    }\n  },\n\n  topStack: function() {\n    let stack = this.isInline() ? this.inlineStack : this.compileStack,\n      item = stack[stack.length - 1];\n\n    /* istanbul ignore if */\n    if (item instanceof Literal) {\n      return item.value;\n    } else {\n      return item;\n    }\n  },\n\n  contextName: function(context) {\n    if (this.useDepths && context) {\n      return 'depths[' + context + ']';\n    } else {\n      return 'depth' + context;\n    }\n  },\n\n  quotedString: function(str) {\n    return this.source.quotedString(str);\n  },\n\n  objectLiteral: function(obj) {\n    return this.source.objectLiteral(obj);\n  },\n\n  aliasable: function(name) {\n    let ret = this.aliases[name];\n    if (ret) {\n      ret.referenceCount++;\n      return ret;\n    }\n\n    ret = this.aliases[name] = this.source.wrap(name);\n    ret.aliasable = true;\n    ret.referenceCount = 1;\n\n    return ret;\n  },\n\n  setupHelper: function(paramSize, name, blockHelper) {\n    let params = [],\n      paramsInit = this.setupHelperArgs(name, paramSize, params, blockHelper);\n    let foundHelper = this.nameLookup('helpers', name, 'helper'),\n      callContext = this.aliasable(\n        `${this.contextName(0)} != null ? ${this.contextName(\n          0\n        )} : (container.nullContext || {})`\n      );\n\n    return {\n      params: params,\n      paramsInit: paramsInit,\n      name: foundHelper,\n      callParams: [callContext].concat(params)\n    };\n  },\n\n  setupParams: function(helper, paramSize, params) {\n    let options = {},\n      contexts = [],\n      types = [],\n      ids = [],\n      objectArgs = !params,\n      param;\n\n    if (objectArgs) {\n      params = [];\n    }\n\n    options.name = this.quotedString(helper);\n    options.hash = this.popStack();\n\n    if (this.trackIds) {\n      options.hashIds = this.popStack();\n    }\n    if (this.stringParams) {\n      options.hashTypes = this.popStack();\n      options.hashContexts = this.popStack();\n    }\n\n    let inverse = this.popStack(),\n      program = this.popStack();\n\n    // Avoid setting fn and inverse if neither are set. This allows\n    // helpers to do a check for `if (options.fn)`\n    if (program || inverse) {\n      options.fn = program || 'container.noop';\n      options.inverse = inverse || 'container.noop';\n    }\n\n    // The parameters go on to the stack in order (making sure that they are evaluated in order)\n    // so we need to pop them off the stack in reverse order\n    let i = paramSize;\n    while (i--) {\n      param = this.popStack();\n      params[i] = param;\n\n      if (this.trackIds) {\n        ids[i] = this.popStack();\n      }\n      if (this.stringParams) {\n        types[i] = this.popStack();\n        contexts[i] = this.popStack();\n      }\n    }\n\n    if (objectArgs) {\n      options.args = this.source.generateArray(params);\n    }\n\n    if (this.trackIds) {\n      options.ids = this.source.generateArray(ids);\n    }\n    if (this.stringParams) {\n      options.types = this.source.generateArray(types);\n      options.contexts = this.source.generateArray(contexts);\n    }\n\n    if (this.options.data) {\n      options.data = 'data';\n    }\n    if (this.useBlockParams) {\n      options.blockParams = 'blockParams';\n    }\n    return options;\n  },\n\n  setupHelperArgs: function(helper, paramSize, params, useRegister) {\n    let options = this.setupParams(helper, paramSize, params);\n    options.loc = JSON.stringify(this.source.currentLocation);\n    options = this.objectLiteral(options);\n    if (useRegister) {\n      this.useRegister('options');\n      params.push('options');\n      return ['options=', options];\n    } else if (params) {\n      params.push(options);\n      return '';\n    } else {\n      return options;\n    }\n  }\n};\n\n(function() {\n  const reservedWords = (\n    'break else new var' +\n    ' case finally return void' +\n    ' catch for switch while' +\n    ' continue function this with' +\n    ' default if throw' +\n    ' delete in try' +\n    ' do instanceof typeof' +\n    ' abstract enum int short' +\n    ' boolean export interface static' +\n    ' byte extends long super' +\n    ' char final native synchronized' +\n    ' class float package throws' +\n    ' const goto private transient' +\n    ' debugger implements protected volatile' +\n    ' double import public let yield await' +\n    ' null true false'\n  ).split(' ');\n\n  const compilerWords = (JavaScriptCompiler.RESERVED_WORDS = {});\n\n  for (let i = 0, l = reservedWords.length; i < l; i++) {\n    compilerWords[reservedWords[i]] = true;\n  }\n})();\n\n/**\n * @deprecated May be removed in the next major version\n */\nJavaScriptCompiler.isValidJavaScriptVariableName = function(name) {\n  return (\n    !JavaScriptCompiler.RESERVED_WORDS[name] &&\n    /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name)\n  );\n};\n\nfunction strictLookup(requireTerminal, compiler, parts, type) {\n  let stack = compiler.popStack(),\n    i = 0,\n    len = parts.length;\n  if (requireTerminal) {\n    len--;\n  }\n\n  for (; i < len; i++) {\n    stack = compiler.nameLookup(stack, parts[i], type);\n  }\n\n  if (requireTerminal) {\n    return [\n      compiler.aliasable('container.strict'),\n      '(',\n      stack,\n      ', ',\n      compiler.quotedString(parts[i]),\n      ', ',\n      JSON.stringify(compiler.source.currentLocation),\n      ' )'\n    ];\n  } else {\n    return stack;\n  }\n}\n\nexport default JavaScriptCompiler;\n"]}