define(['exports', 'module', '../base', '../exception', '../utils', './code-gen'], function (exports, module, _base, _exception, _utils, _codeGen) {
  'use strict';

  // istanbul ignore next

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

  var _Exception = _interopRequireDefault(_exception);

  var _CodeGen = _interopRequireDefault(_codeGen);

  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 nameLookup(parent, name /* , type*/) {
      if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
        return [parent, '.', name];
      } else {
        return [parent, '[', JSON.stringify(name), ']'];
      }
    },
    depthedLookup: function depthedLookup(name) {
      return [this.aliasable('container.lookup'), '(depths, "', name, '")'];
    },

    compilerInfo: function compilerInfo() {
      var revision = _base.COMPILER_REVISION,
          versions = _base.REVISION_CHANGES[revision];
      return [revision, versions];
    },

    appendToBuffer: function appendToBuffer(source, location, explicit) {
      // Force a source as this simplifies the merge logic.
      if (!_utils.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 initializeBuffer() {
      return this.quotedString('');
    },
    // END PUBLIC API

    compile: function 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 = undefined,
          firstLoc = undefined,
          i = undefined,
          l = undefined;

      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 _Exception['default']('Compile completed with content left on stack');
      }

      if (!this.decorators.isEmpty()) {
        this.useDecorators = true;

        this.decorators.prepend('var decorators = container.decorators;\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;
        }

        var _context = this.context;
        var programs = _context.programs;
        var decorators = _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 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 _CodeGen['default'](this.options.srcName);
      this.decorators = new _CodeGen['default'](this.options.srcName);
    },

    createFunctionContext: function createFunctionContext(asObject) {
      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;
      for (var alias in this.aliases) {
        // eslint-disable-line guard-for-in
        var node = this.aliases[alias];

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

      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 mergeSource(varDeclarations) {
      var isSimple = this.environment.isSimple,
          appendOnly = !this.forceBuffer,
          appendFirst = undefined,
          sourceSeen = undefined,
          bufferStart = undefined,
          bufferEnd = undefined;
      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();
    },

    // [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 blockValue(name) {
      var blockHelperMissing = this.aliasable('helpers.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 ambiguousBlockValue() {
      // We're being a bit cheeky and reusing the options value from the prior exec
      var blockHelperMissing = this.aliasable('helpers.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 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 append() {
      if (this.isInline()) {
        this.replaceStack(function (current) {
          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 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 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 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 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 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 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 resolvePath(type, parts, i, falsy, strict) {
      // istanbul ignore next

      var _this = 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 = _this.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 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 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 emptyHash(omitEmpty) {
      if (this.trackIds) {
        this.push('{}'); // hashIds
      }
      if (this.stringParams) {
        this.push('{}'); // hashContexts
        this.push('{}'); // hashTypes
      }
      this.pushStackLiteral(omitEmpty ? 'undefined' : '{}');
    },
    pushHash: function pushHash() {
      if (this.hash) {
        this.hashes.push(this.hash);
      }
      this.hash = { values: [], types: [], contexts: [], ids: [] };
    },
    popHash: function 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 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 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 pushProgram(guid) {
      if (guid != null) {
        this.pushStackLiteral(this.programExpression(guid));
      } else {
        this.pushStackLiteral(null);
      }
    },

    // [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 invokeHelper(paramSize, name, isSimple) {
      var nonHelper = this.popStack(),
          helper = this.setupHelper(paramSize, name),
          simple = isSimple ? [helper.name, ' || '] : '';

      var lookup = ['('].concat(simple, nonHelper);
      if (!this.options.strict) {
        lookup.push(' || ', this.aliasable('helpers.helperMissing'));
      }
      lookup.push(')');

      this.push(this.source.functionCall(lookup, 'call', helper.callParams));
    },

    // [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 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 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('helpers.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 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 assignToHash(key) {
      var value = this.popStack(),
          context = undefined,
          type = undefined,
          id = undefined;

      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 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 compileChildren(environment, options) {
      var children = environment.children,
          child = undefined,
          compiler = undefined;

      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 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 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 useRegister(name) {
      if (!this.registers[name]) {
        this.registers[name] = true;
        this.registers.list.push(name);
      }
    },

    push: function push(expr) {
      if (!(expr instanceof Literal)) {
        expr = this.source.wrap(expr);
      }

      this.inlineStack.push(expr);
      return expr;
    },

    pushStackLiteral: function pushStackLiteral(item) {
      this.push(new Literal(item));
    },

    pushSource: function 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 replaceStack(callback) {
      var prefix = ['('],
          stack = undefined,
          createdStack = undefined,
          usedLiteral = undefined;

      /* istanbul ignore next */
      if (!this.isInline()) {
        throw new _Exception['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 incrStack() {
      this.stackSlot++;
      if (this.stackSlot > this.stackVars.length) {
        this.stackVars.push('stack' + this.stackSlot);
      }
      return this.topStackName();
    },
    topStackName: function topStackName() {
      return 'stack' + this.stackSlot;
    },
    flushInline: function 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 isInline() {
      return this.inlineStack.length;
    },

    popStack: function 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 _Exception['default']('Invalid stack pop');
          }
          this.stackSlot--;
        }
        return item;
      }
    },

    topStack: function 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 contextName(context) {
      if (this.useDepths && context) {
        return 'depths[' + context + ']';
      } else {
        return 'depth' + context;
      }
    },

    quotedString: function quotedString(str) {
      return this.source.quotedString(str);
    },

    objectLiteral: function objectLiteral(obj) {
      return this.source.objectLiteral(obj);
    },

    aliasable: function 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 setupHelper(paramSize, name, blockHelper) {
      var params = [],
          paramsInit = this.setupHelperArgs(name, paramSize, params, blockHelper);
      var foundHelper = this.nameLookup('helpers', name, 'helper'),
          callContext = this.aliasable(this.contextName(0) + ' != null ? ' + this.contextName(0) + ' : (container.nullContext || {})');

      return {
        params: params,
        paramsInit: paramsInit,
        name: foundHelper,
        callParams: [callContext].concat(params)
      };
    },

    setupParams: function setupParams(helper, paramSize, params) {
      var options = {},
          contexts = [],
          types = [],
          ids = [],
          objectArgs = !params,
          param = undefined;

      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 setupHelperArgs(helper, paramSize, params, useRegister) {
      var options = this.setupParams(helper, paramSize, params);
      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;
    }
  })();

  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]), ')'];
    } else {
      return stack;
    }
  }

  module.exports = JavaScriptCompiler;
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../lib/handlebars/compiler/javascript-compiler.js"],"names":[],"mappings":";;;;;;;;;;;AAKA,WAAS,OAAO,CAAC,KAAK,EAAE;AACtB,QAAI,CAAC,KAAK,GAAG,KAAK,CAAC;GACpB;;AAED,WAAS,kBAAkB,GAAG,EAAE;;AAEhC,oBAAkB,CAAC,SAAS,GAAG;;;AAG7B,cAAU,EAAE,oBAAS,MAAM,EAAE,IAAI,cAAa;AAC5C,UAAI,kBAAkB,CAAC,6BAA6B,CAAC,IAAI,CAAC,EAAE;AAC1D,eAAO,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;OAC5B,MAAM;AACL,eAAO,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;OACjD;KACF;AACD,iBAAa,EAAE,uBAAS,IAAI,EAAE;AAC5B,aAAO,CAAC,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;KACvE;;AAED,gBAAY,EAAE,wBAAW;AACvB,UAAM,QAAQ,SA1BT,iBAAiB,AA0BY;UAC5B,QAAQ,GAAG,MA3BO,gBAAgB,CA2BN,QAAQ,CAAC,CAAC;AAC5C,aAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;KAC7B;;AAED,kBAAc,EAAE,wBAAS,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE;;AAEnD,UAAI,CAAC,OA/BD,OAAO,CA+BE,MAAM,CAAC,EAAE;AACpB,cAAM,GAAG,CAAC,MAAM,CAAC,CAAC;OACnB;AACD,YAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;;AAE5C,UAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;AAC7B,eAAO,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;OACjC,MAAM,IAAI,QAAQ,EAAE;;;;AAInB,eAAO,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;OACpC,MAAM;AACL,cAAM,CAAC,cAAc,GAAG,IAAI,CAAC;AAC7B,eAAO,MAAM,CAAC;OACf;KACF;;AAED,oBAAgB,EAAE,4BAAW;AAC3B,aAAO,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;KAC9B;;;AAGD,WAAO,EAAE,iBAAS,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE;AACzD,UAAI,CAAC,WAAW,GAAG,WAAW,CAAC;AAC/B,UAAI,CAAC,OAAO,GAAG,OAAO,CAAC;AACvB,UAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC;AAC9C,UAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;AACtC,UAAI,CAAC,UAAU,GAAG,CAAC,QAAQ,CAAC;;AAE5B,UAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;AAClC,UAAI,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC;AACzB,UAAI,CAAC,OAAO,GAAG,OAAO,IAAI;AACxB,kBAAU,EAAE,EAAE;AACd,gBAAQ,EAAE,EAAE;AACZ,oBAAY,EAAE,EAAE;OACjB,CAAC;;AAEF,UAAI,CAAC,QAAQ,EAAE,CAAC;;AAEhB,UAAI,CAAC,SAAS,GAAG,CAAC,CAAC;AACnB,UAAI,CAAC,SAAS,GAAG,EAAE,CAAC;AACpB,UAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAClB,UAAI,CAAC,SAAS,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;AAC9B,UAAI,CAAC,MAAM,GAAG,EAAE,CAAC;AACjB,UAAI,CAAC,YAAY,GAAG,EAAE,CAAC;AACvB,UAAI,CAAC,WAAW,GAAG,EAAE,CAAC;AACtB,UAAI,CAAC,WAAW,GAAG,EAAE,CAAC;;AAEtB,UAAI,CAAC,eAAe,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;;AAE3C,UAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,WAAW,CAAC,SAAS,IAAI,WAAW,CAAC,aAAa,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;AAC7G,UAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,IAAI,WAAW,CAAC,cAAc,CAAC;;AAExE,UAAI,OAAO,GAAG,WAAW,CAAC,OAAO;UAC7B,MAAM,YAAA;UACN,QAAQ,YAAA;UACR,CAAC,YAAA;UACD,CAAC,YAAA,CAAC;;AAEN,WAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC1C,cAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;;AAEpB,YAAI,CAAC,MAAM,CAAC,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC;AACzC,gBAAQ,GAAG,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC;AAClC,YAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;OAC9C;;;AAGD,UAAI,CAAC,MAAM,CAAC,eAAe,GAAG,QAAQ,CAAC;AACvC,UAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;;;AAGpB,UAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE;AACzE,cAAM,0BAAc,8CAA8C,CAAC,CAAC;OACrE;;AAED,UAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE;AAC9B,YAAI,CAAC,aAAa,GAAG,IAAI,CAAC;;AAE1B,YAAI,CAAC,UAAU,CAAC,OAAO,CAAC,0CAA0C,CAAC,CAAC;AACpE,YAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;;AAEnC,YAAI,QAAQ,EAAE;AACZ,cAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;SAC1I,MAAM;AACL,cAAI,CAAC,UAAU,CAAC,OAAO,CAAC,uEAAuE,CAAC,CAAC;AACjG,cAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC5B,cAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;SAC3C;OACF,MAAM;AACL,YAAI,CAAC,UAAU,GAAG,SAAS,CAAC;OAC7B;;AAED,UAAI,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;AAC9C,UAAI,CAAC,IAAI,CAAC,OAAO,EAAE;AACjB,YAAI,GAAG,GAAG;AACR,kBAAQ,EAAE,IAAI,CAAC,YAAY,EAAE;AAC7B,cAAI,EAAE,EAAE;SACT,CAAC;;AAEF,YAAI,IAAI,CAAC,UAAU,EAAE;AACnB,aAAG,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC;AAC7B,aAAG,CAAC,aAAa,GAAG,IAAI,CAAC;SAC1B;;uBAE4B,IAAI,CAAC,OAAO;YAApC,QAAQ,YAAR,QAAQ;YAAE,UAAU,YAAV,UAAU;;AACzB,aAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC3C,cAAI,QAAQ,CAAC,CAAC,CAAC,EAAE;AACf,eAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AACrB,gBAAI,UAAU,CAAC,CAAC,CAAC,EAAE;AACjB,iBAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;AAC9B,iBAAG,CAAC,aAAa,GAAG,IAAI,CAAC;aAC1B;WACF;SACF;;AAED,YAAI,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE;AAC/B,aAAG,CAAC,UAAU,GAAG,IAAI,CAAC;SACvB;AACD,YAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;AACrB,aAAG,CAAC,OAAO,GAAG,IAAI,CAAC;SACpB;AACD,YAAI,IAAI,CAAC,SAAS,EAAE;AAClB,aAAG,CAAC,SAAS,GAAG,IAAI,CAAC;SACtB;AACD,YAAI,IAAI,CAAC,cAAc,EAAE;AACvB,aAAG,CAAC,cAAc,GAAG,IAAI,CAAC;SAC3B;AACD,YAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACvB,aAAG,CAAC,MAAM,GAAG,IAAI,CAAC;SACnB;;AAED,YAAI,CAAC,QAAQ,EAAE;AACb,aAAG,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;;AAE5C,cAAI,CAAC,MAAM,CAAC,eAAe,GAAG,EAAC,KAAK,EAAE,EAAC,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAC,EAAC,CAAC;AAC5D,aAAG,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;;AAE9B,cAAI,OAAO,CAAC,OAAO,EAAE;AACnB,eAAG,GAAG,GAAG,CAAC,qBAAqB,CAAC,EAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAC,CAAC,CAAC;AAC1D,eAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;WACzC,MAAM;AACL,eAAG,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;WACtB;SACF,MAAM;AACL,aAAG,CAAC,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC;SACpC;;AAED,eAAO,GAAG,CAAC;OACZ,MAAM;AACL,eAAO,EAAE,CAAC;OACX;KACF;;AAED,YAAQ,EAAE,oBAAW;;;AAGnB,UAAI,CAAC,WAAW,GAAG,CAAC,CAAC;AACrB,UAAI,CAAC,MAAM,GAAG,wBAAY,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;AAChD,UAAI,CAAC,UAAU,GAAG,wBAAY,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;KACrD;;AAED,yBAAqB,EAAE,+BAAS,QAAQ,EAAE;AACxC,UAAI,eAAe,GAAG,EAAE,CAAC;;AAEzB,UAAI,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AACxD,UAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;AACrB,uBAAe,IAAI,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OAC7C;;;;;;;;AAQD,UAAI,UAAU,GAAG,CAAC,CAAC;AACnB,WAAK,IAAI,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE;;AAC9B,YAAI,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;;AAE/B,YAAI,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE;AAClF,yBAAe,IAAI,SAAS,GAAI,EAAE,UAAU,AAAC,GAAG,GAAG,GAAG,KAAK,CAAC;AAC5D,cAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,GAAG,UAAU,CAAC;SACzC;OACF;;AAED,UAAI,MAAM,GAAG,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;;AAEpE,UAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,SAAS,EAAE;AACzC,cAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;OAC5B;AACD,UAAI,IAAI,CAAC,SAAS,EAAE;AAClB,cAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;OACvB;;;AAGD,UAAI,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC;;AAE/C,UAAI,QAAQ,EAAE;AACZ,cAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;;AAEpB,eAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;OACrC,MAAM;AACL,eAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;OAClF;KACF;AACD,eAAW,EAAE,qBAAS,eAAe,EAAE;AACrC,UAAI,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ;UACpC,UAAU,GAAG,CAAC,IAAI,CAAC,WAAW;UAC9B,WAAW,YAAA;UAEX,UAAU,YAAA;UACV,WAAW,YAAA;UACX,SAAS,YAAA,CAAC;AACd,UAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAC,IAAI,EAAK;AACzB,YAAI,IAAI,CAAC,cAAc,EAAE;AACvB,cAAI,WAAW,EAAE;AACf,gBAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;WACtB,MAAM;AACL,uBAAW,GAAG,IAAI,CAAC;WACpB;AACD,mBAAS,GAAG,IAAI,CAAC;SAClB,MAAM;AACL,cAAI,WAAW,EAAE;AACf,gBAAI,CAAC,UAAU,EAAE;AACf,yBAAW,GAAG,IAAI,CAAC;aACpB,MAAM;AACL,yBAAW,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;aACnC;AACD,qBAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACnB,uBAAW,GAAG,SAAS,GAAG,SAAS,CAAC;WACrC;;AAED,oBAAU,GAAG,IAAI,CAAC;AAClB,cAAI,CAAC,QAAQ,EAAE;AACb,sBAAU,GAAG,KAAK,CAAC;WACpB;SACF;OACF,CAAC,CAAC;;AAGH,UAAI,UAAU,EAAE;AACd,YAAI,WAAW,EAAE;AACf,qBAAW,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AAC/B,mBAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;SACpB,MAAM,IAAI,CAAC,UAAU,EAAE;AACtB,cAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;SAChC;OACF,MAAM;AACL,uBAAe,IAAI,aAAa,IAAI,WAAW,GAAG,EAAE,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAA,AAAC,CAAC;;AAEhF,YAAI,WAAW,EAAE;AACf,qBAAW,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;AACxC,mBAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;SACpB,MAAM;AACL,cAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;SACpC;OACF;;AAED,UAAI,eAAe,EAAE;AACnB,YAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,WAAW,GAAG,EAAE,GAAG,KAAK,CAAA,AAAC,CAAC,CAAC;OACzF;;AAED,aAAO,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;KAC5B;;;;;;;;;;;AAWD,cAAU,EAAE,oBAAS,IAAI,EAAE;AACzB,UAAI,kBAAkB,GAAG,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;UACjE,MAAM,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AACnC,UAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;;AAEtC,UAAI,SAAS,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AAChC,YAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;;AAE/B,UAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,kBAAkB,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KACzE;;;;;;;;AAQD,uBAAmB,EAAE,+BAAW;;AAE9B,UAAI,kBAAkB,GAAG,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC;UACjE,MAAM,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AACnC,UAAI,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;;AAE1C,UAAI,CAAC,WAAW,EAAE,CAAC;;AAEnB,UAAI,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AAC9B,YAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC;;AAE7B,UAAI,CAAC,UAAU,CAAC,CACZ,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,MAAM,EAC9B,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,kBAAkB,EAAE,MAAM,EAAE,MAAM,CAAC,EAC9E,GAAG,CAAC,CAAC,CAAC;KACX;;;;;;;;AAQD,iBAAa,EAAE,uBAAS,OAAO,EAAE;AAC/B,UAAI,IAAI,CAAC,cAAc,EAAE;AACvB,eAAO,GAAG,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC;OACzC,MAAM;AACL,YAAI,CAAC,eAAe,GAAG,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC;OACpD;;AAED,UAAI,CAAC,cAAc,GAAG,OAAO,CAAC;KAC/B;;;;;;;;;;;AAWD,UAAM,EAAE,kBAAW;AACjB,UAAI,IAAI,CAAC,QAAQ,EAAE,EAAE;AACnB,YAAI,CAAC,YAAY,CAAC,UAAC,OAAO;iBAAK,CAAC,aAAa,EAAE,OAAO,EAAE,OAAO,CAAC;SAAA,CAAC,CAAC;;AAElE,YAAI,CAAC,UAAU,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;OACvD,MAAM;AACL,YAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AAC5B,YAAI,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AACpG,YAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;AAC7B,cAAI,CAAC,UAAU,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;SAChF;OACF;KACF;;;;;;;;AAQD,iBAAa,EAAE,yBAAW;AACxB,UAAI,CAAC,UAAU,CAAC,IAAI,CAAC,cAAc,CAC/B,CAAC,IAAI,CAAC,SAAS,CAAC,4BAA4B,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;KACjF;;;;;;;;;AASD,cAAU,EAAE,oBAAS,KAAK,EAAE;AAC1B,UAAI,CAAC,WAAW,GAAG,KAAK,CAAC;KAC1B;;;;;;;;AAQD,eAAW,EAAE,uBAAW;AACtB,UAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;KAC3D;;;;;;;;;AASD,mBAAe,EAAE,yBAAS,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE;AACtD,UAAI,CAAC,GAAG,CAAC,CAAC;;AAEV,UAAI,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;;;AAGvD,YAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;OAC3C,MAAM;AACL,YAAI,CAAC,WAAW,EAAE,CAAC;OACpB;;AAED,UAAI,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;KACtD;;;;;;;;;AASD,oBAAgB,EAAE,0BAAS,YAAY,EAAE,KAAK,EAAE;AAC9C,UAAI,CAAC,cAAc,GAAG,IAAI,CAAC;;AAE3B,UAAI,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;AACzE,UAAI,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;KACvC;;;;;;;;AAQD,cAAU,EAAE,oBAAS,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE;AACzC,UAAI,CAAC,KAAK,EAAE;AACV,YAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;OAC/B,MAAM;AACL,YAAI,CAAC,gBAAgB,CAAC,uBAAuB,GAAG,KAAK,GAAG,GAAG,CAAC,CAAC;OAC9D;;AAED,UAAI,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;KAClD;;AAED,eAAW,EAAE,qBAAS,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE;;;;;AACnD,UAAI,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE;AACrD,YAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;AAC1E,eAAO;OACR;;AAED,UAAI,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;AACvB,aAAO,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;;AAEnB,YAAI,CAAC,YAAY,CAAC,UAAC,OAAO,EAAK;AAC7B,cAAI,MAAM,GAAG,MAAK,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;;;AAGtD,cAAI,CAAC,KAAK,EAAE;AACV,mBAAO,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;WAChD,MAAM;;AAEL,mBAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;WACzB;SACF,CAAC,CAAC;;OAEJ;KACF;;;;;;;;;AASD,yBAAqB,EAAE,iCAAW;AAChC,UAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;KACvG;;;;;;;;;;AAUD,mBAAe,EAAE,yBAAS,MAAM,EAAE,IAAI,EAAE;AACtC,UAAI,CAAC,WAAW,EAAE,CAAC;AACnB,UAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;;;;AAItB,UAAI,IAAI,KAAK,eAAe,EAAE;AAC5B,YAAI,OAAO,MAAM,KAAK,QAAQ,EAAE;AAC9B,cAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;SACzB,MAAM;AACL,cAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;SAC/B;OACF;KACF;;AAED,aAAS,EAAE,mBAAS,SAAS,EAAE;AAC7B,UAAI,IAAI,CAAC,QAAQ,EAAE;AACjB,YAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OACjB;AACD,UAAI,IAAI,CAAC,YAAY,EAAE;AACrB,YAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,YAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OACjB;AACD,UAAI,CAAC,gBAAgB,CAAC,SAAS,GAAG,WAAW,GAAG,IAAI,CAAC,CAAC;KACvD;AACD,YAAQ,EAAE,oBAAW;AACnB,UAAI,IAAI,CAAC,IAAI,EAAE;AACb,YAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OAC7B;AACD,UAAI,CAAC,IAAI,GAAG,EAAC,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAC,CAAC;KAC5D;AACD,WAAO,EAAE,mBAAW;AAClB,UAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;AACrB,UAAI,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;;AAE9B,UAAI,IAAI,CAAC,QAAQ,EAAE;AACjB,YAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;OACzC;AACD,UAAI,IAAI,CAAC,YAAY,EAAE;AACrB,YAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC7C,YAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;OAC3C;;AAED,UAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;KAC5C;;;;;;;;AAQD,cAAU,EAAE,oBAAS,MAAM,EAAE;AAC3B,UAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;KAClD;;;;;;;;;;AAUD,eAAW,EAAE,qBAAS,KAAK,EAAE;AAC3B,UAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;KAC9B;;;;;;;;;;AAUD,eAAW,EAAE,qBAAS,IAAI,EAAE;AAC1B,UAAI,IAAI,IAAI,IAAI,EAAE;AAChB,YAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;OACrD,MAAM;AACL,YAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;OAC7B;KACF;;;;;;;;;AASD,qBAAiB,EAAA,2BAAC,SAAS,EAAE,IAAI,EAAE;AACjC,UAAI,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,IAAI,EAAE,WAAW,CAAC;UACjE,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;;AAEpD,UAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CACnB,OAAO,EACP,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC,cAAc,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,EACvF,SAAS,CACV,CAAC,CAAC;KACJ;;;;;;;;;;;AAWD,gBAAY,EAAE,sBAAS,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE;AAChD,UAAI,SAAS,GAAG,IAAI,CAAC,QAAQ,EAAE;UAC3B,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC;UAC1C,MAAM,GAAG,QAAQ,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC;;AAEnD,UAAI,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAC7C,UAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACxB,cAAM,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC,CAAC,CAAC;OAC9D;AACD,YAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;;AAEjB,UAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;KACxE;;;;;;;;;AASD,qBAAiB,EAAE,2BAAS,SAAS,EAAE,IAAI,EAAE;AAC3C,UAAI,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;AAC/C,UAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;KAC7E;;;;;;;;;;;;;;AAcD,mBAAe,EAAE,yBAAS,IAAI,EAAE,UAAU,EAAE;AAC1C,UAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;;AAE3B,UAAI,SAAS,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;;AAEhC,UAAI,CAAC,SAAS,EAAE,CAAC;AACjB,UAAI,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC;;AAEnD,UAAI,UAAU,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;;AAE9E,UAAI,MAAM,GAAG,CAAC,GAAG,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC;AACrE,UAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACxB,cAAM,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC;AACzB,cAAM,CAAC,IAAI,CACT,sBAAsB,EACtB,IAAI,CAAC,SAAS,CAAC,uBAAuB,CAAC,CACxC,CAAC;OACH;;AAED,UAAI,CAAC,IAAI,CAAC,CACN,GAAG,EAAE,MAAM,EACV,MAAM,CAAC,UAAU,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,EAAG,IAAI,EAC3D,qBAAqB,EAAE,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE,KAAK,EAC1D,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,UAAU,CAAC,EAAE,aAAa,CAC/E,CAAC,CAAC;KACJ;;;;;;;;;AASD,iBAAa,EAAE,uBAAS,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE;AAC/C,UAAI,MAAM,GAAG,EAAE;UACX,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;;AAEhD,UAAI,SAAS,EAAE;AACb,YAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AACvB,eAAO,OAAO,CAAC,IAAI,CAAC;OACrB;;AAED,UAAI,MAAM,EAAE;AACV,eAAO,CAAC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;OACzC;AACD,aAAO,CAAC,OAAO,GAAG,SAAS,CAAC;AAC5B,aAAO,CAAC,QAAQ,GAAG,UAAU,CAAC;AAC9B,aAAO,CAAC,UAAU,GAAG,sBAAsB,CAAC;;AAE5C,UAAI,CAAC,SAAS,EAAE;AACd,cAAM,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;OAC9D,MAAM;AACL,cAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;OACtB;;AAED,UAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACvB,eAAO,CAAC,MAAM,GAAG,QAAQ,CAAC;OAC3B;AACD,aAAO,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AACtC,YAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;;AAErB,UAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,yBAAyB,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;KAC5E;;;;;;;;AAQD,gBAAY,EAAE,sBAAS,GAAG,EAAE;AAC1B,UAAI,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE;UACvB,OAAO,YAAA;UACP,IAAI,YAAA;UACJ,EAAE,YAAA,CAAC;;AAEP,UAAI,IAAI,CAAC,QAAQ,EAAE;AACjB,UAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;OACtB;AACD,UAAI,IAAI,CAAC,YAAY,EAAE;AACrB,YAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AACvB,eAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;OAC3B;;AAED,UAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;AACrB,UAAI,OAAO,EAAE;AACX,YAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC;OAC9B;AACD,UAAI,IAAI,EAAE;AACR,YAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;OACxB;AACD,UAAI,EAAE,EAAE;AACN,YAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;OACpB;AACD,UAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;KAC1B;;AAED,UAAM,EAAE,gBAAS,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE;AAClC,UAAI,IAAI,KAAK,YAAY,EAAE;AACzB,YAAI,CAAC,gBAAgB,CACjB,cAAc,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,IACjD,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,EAAE,CAAA,AAAC,CAAC,CAAC;OAC3D,MAAM,IAAI,IAAI,KAAK,gBAAgB,EAAE;AACpC,YAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;OACvB,MAAM,IAAI,IAAI,KAAK,eAAe,EAAE;AACnC,YAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;OAC/B,MAAM;AACL,YAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;OAC/B;KACF;;;;AAID,YAAQ,EAAE,kBAAkB;;AAE5B,mBAAe,EAAE,yBAAS,WAAW,EAAE,OAAO,EAAE;AAC9C,UAAI,QAAQ,GAAG,WAAW,CAAC,QAAQ;UAAE,KAAK,YAAA;UAAE,QAAQ,YAAA,CAAC;;AAErD,WAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AAC/C,aAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AACpB,gBAAQ,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;;AAE/B,YAAI,QAAQ,GAAG,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;;AAEhD,YAAI,QAAQ,IAAI,IAAI,EAAE;AACpB,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AAC/B,cAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;AACzC,eAAK,CAAC,KAAK,GAAG,KAAK,CAAC;AACpB,eAAK,CAAC,IAAI,GAAG,SAAS,GAAG,KAAK,CAAC;AAC/B,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAChG,cAAI,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC;AACrD,cAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC;;AAEzC,cAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC;AACtD,cAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,IAAI,QAAQ,CAAC,cAAc,CAAC;AACrE,eAAK,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;AACjC,eAAK,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;SAC5C,MAAM;AACL,eAAK,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;AAC7B,eAAK,CAAC,IAAI,GAAG,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC;;AAExC,cAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC;AACtD,cAAI,CAAC,cAAc,GAAG,IAAI,CAAC,cAAc,IAAI,QAAQ,CAAC,cAAc,CAAC;SACtE;OACF;KACF;AACD,wBAAoB,EAAE,8BAAS,KAAK,EAAE;AACpC,WAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AACpE,YAAI,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AAC/C,YAAI,WAAW,IAAI,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;AAC5C,iBAAO,WAAW,CAAC;SACpB;OACF;KACF;;AAED,qBAAiB,EAAE,2BAAS,IAAI,EAAE;AAChC,UAAI,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC;UACvC,aAAa,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;;AAE7D,UAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,SAAS,EAAE;AACzC,qBAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;OACnC;AACD,UAAI,IAAI,CAAC,SAAS,EAAE;AAClB,qBAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;OAC9B;;AAED,aAAO,oBAAoB,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC;KAC9D;;AAED,eAAW,EAAE,qBAAS,IAAI,EAAE;AAC1B,UAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE;AACzB,YAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAC5B,YAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OAChC;KACF;;AAED,QAAI,EAAE,cAAS,IAAI,EAAE;AACnB,UAAI,EAAE,IAAI,YAAY,OAAO,CAAA,AAAC,EAAE;AAC9B,YAAI,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OAC/B;;AAED,UAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC5B,aAAO,IAAI,CAAC;KACb;;AAED,oBAAgB,EAAE,0BAAS,IAAI,EAAE;AAC/B,UAAI,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;KAC9B;;AAED,cAAU,EAAE,oBAAS,MAAM,EAAE;AAC3B,UAAI,IAAI,CAAC,cAAc,EAAE;AACvB,YAAI,CAAC,MAAM,CAAC,IAAI,CACZ,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;AAC9F,YAAI,CAAC,cAAc,GAAG,SAAS,CAAC;OACjC;;AAED,UAAI,MAAM,EAAE;AACV,YAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;OAC1B;KACF;;AAED,gBAAY,EAAE,sBAAS,QAAQ,EAAE;AAC/B,UAAI,MAAM,GAAG,CAAC,GAAG,CAAC;UACd,KAAK,YAAA;UACL,YAAY,YAAA;UACZ,WAAW,YAAA,CAAC;;;AAGhB,UAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE;AACpB,cAAM,0BAAc,4BAA4B,CAAC,CAAC;OACnD;;;AAGD,UAAI,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;;AAE9B,UAAI,GAAG,YAAY,OAAO,EAAE;;AAE1B,aAAK,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACpB,cAAM,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;AACtB,mBAAW,GAAG,IAAI,CAAC;OACpB,MAAM;;AAEL,oBAAY,GAAG,IAAI,CAAC;AACpB,YAAI,KAAI,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;;AAE5B,cAAM,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,KAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAClD,aAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;OACzB;;AAED,UAAI,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;;AAEtC,UAAI,CAAC,WAAW,EAAE;AAChB,YAAI,CAAC,QAAQ,EAAE,CAAC;OACjB;AACD,UAAI,YAAY,EAAE;AAChB,YAAI,CAAC,SAAS,EAAE,CAAC;OAClB;AACD,UAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC;KACrC;;AAED,aAAS,EAAE,qBAAW;AACpB,UAAI,CAAC,SAAS,EAAE,CAAC;AACjB,UAAI,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;AAAE,YAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;OAAE;AAC9F,aAAO,IAAI,CAAC,YAAY,EAAE,CAAC;KAC5B;AACD,gBAAY,EAAE,wBAAW;AACvB,aAAO,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC;KACjC;AACD,eAAW,EAAE,uBAAW;AACtB,UAAI,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;AACnC,UAAI,CAAC,WAAW,GAAG,EAAE,CAAC;AACtB,WAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AACtD,YAAI,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;;AAE3B,YAAI,KAAK,YAAY,OAAO,EAAE;AAC5B,cAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC/B,MAAM;AACL,cAAI,KAAK,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;AAC7B,cAAI,CAAC,UAAU,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;AAC5C,cAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SAC/B;OACF;KACF;AACD,YAAQ,EAAE,oBAAW;AACnB,aAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;KAChC;;AAED,YAAQ,EAAE,kBAAS,OAAO,EAAE;AAC1B,UAAI,MAAM,GAAG,IAAI,CAAC,QAAQ,EAAE;UACxB,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,CAAA,CAAE,GAAG,EAAE,CAAC;;AAEjE,UAAI,CAAC,OAAO,IAAK,IAAI,YAAY,OAAO,AAAC,EAAE;AACzC,eAAO,IAAI,CAAC,KAAK,CAAC;OACnB,MAAM;AACL,YAAI,CAAC,MAAM,EAAE;;AAEX,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE;AACnB,kBAAM,0BAAc,mBAAmB,CAAC,CAAC;WAC1C;AACD,cAAI,CAAC,SAAS,EAAE,CAAC;SAClB;AACD,eAAO,IAAI,CAAC;OACb;KACF;;AAED,YAAQ,EAAE,oBAAW;AACnB,UAAI,KAAK,GAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,YAAY,AAAC;UAChE,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;;;AAGnC,UAAI,IAAI,YAAY,OAAO,EAAE;AAC3B,eAAO,IAAI,CAAC,KAAK,CAAC;OACnB,MAAM;AACL,eAAO,IAAI,CAAC;OACb;KACF;;AAED,eAAW,EAAE,qBAAS,OAAO,EAAE;AAC7B,UAAI,IAAI,CAAC,SAAS,IAAI,OAAO,EAAE;AAC7B,eAAO,SAAS,GAAG,OAAO,GAAG,GAAG,CAAC;OAClC,MAAM;AACL,eAAO,OAAO,GAAG,OAAO,CAAC;OAC1B;KACF;;AAED,gBAAY,EAAE,sBAAS,GAAG,EAAE;AAC1B,aAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;KACtC;;AAED,iBAAa,EAAE,uBAAS,GAAG,EAAE;AAC3B,aAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;KACvC;;AAED,aAAS,EAAE,mBAAS,IAAI,EAAE;AACxB,UAAI,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC7B,UAAI,GAAG,EAAE;AACP,WAAG,CAAC,cAAc,EAAE,CAAC;AACrB,eAAO,GAAG,CAAC;OACZ;;AAED,SAAG,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAClD,SAAG,CAAC,SAAS,GAAG,IAAI,CAAC;AACrB,SAAG,CAAC,cAAc,GAAG,CAAC,CAAC;;AAEvB,aAAO,GAAG,CAAC;KACZ;;AAED,eAAW,EAAE,qBAAS,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE;AAClD,UAAI,MAAM,GAAG,EAAE;UACX,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;AAC5E,UAAI,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC;UACxD,WAAW,GAAG,IAAI,CAAC,SAAS,CAAI,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,mBAAc,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,sCAAmC,CAAC;;AAE5H,aAAO;AACL,cAAM,EAAE,MAAM;AACd,kBAAU,EAAE,UAAU;AACtB,YAAI,EAAE,WAAW;AACjB,kBAAU,EAAE,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;OACzC,CAAC;KACH;;AAED,eAAW,EAAE,qBAAS,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE;AAC/C,UAAI,OAAO,GAAG,EAAE;UACZ,QAAQ,GAAG,EAAE;UACb,KAAK,GAAG,EAAE;UACV,GAAG,GAAG,EAAE;UACR,UAAU,GAAG,CAAC,MAAM;UACpB,KAAK,YAAA,CAAC;;AAEV,UAAI,UAAU,EAAE;AACd,cAAM,GAAG,EAAE,CAAC;OACb;;AAED,aAAO,CAAC,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;AACzC,aAAO,CAAC,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;;AAE/B,UAAI,IAAI,CAAC,QAAQ,EAAE;AACjB,eAAO,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;OACnC;AACD,UAAI,IAAI,CAAC,YAAY,EAAE;AACrB,eAAO,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AACpC,eAAO,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;OACxC;;AAED,UAAI,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE;UACzB,OAAO,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;;;;AAI9B,UAAI,OAAO,IAAI,OAAO,EAAE;AACtB,eAAO,CAAC,EAAE,GAAG,OAAO,IAAI,gBAAgB,CAAC;AACzC,eAAO,CAAC,OAAO,GAAG,OAAO,IAAI,gBAAgB,CAAC;OAC/C;;;;AAID,UAAI,CAAC,GAAG,SAAS,CAAC;AAClB,aAAO,CAAC,EAAE,EAAE;AACV,aAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AACxB,cAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;;AAElB,YAAI,IAAI,CAAC,QAAQ,EAAE;AACjB,aAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;SAC1B;AACD,YAAI,IAAI,CAAC,YAAY,EAAE;AACrB,eAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;AAC3B,kBAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;SAC/B;OACF;;AAED,UAAI,UAAU,EAAE;AACd,eAAO,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;OAClD;;AAED,UAAI,IAAI,CAAC,QAAQ,EAAE;AACjB,eAAO,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;OAC9C;AACD,UAAI,IAAI,CAAC,YAAY,EAAE;AACrB,eAAO,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;AACjD,eAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;OACxD;;AAED,UAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE;AACrB,eAAO,CAAC,IAAI,GAAG,MAAM,CAAC;OACvB;AACD,UAAI,IAAI,CAAC,cAAc,EAAE;AACvB,eAAO,CAAC,WAAW,GAAG,aAAa,CAAC;OACrC;AACD,aAAO,OAAO,CAAC;KAChB;;AAED,mBAAe,EAAE,yBAAS,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE;AAChE,UAAI,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;AAC1D,aAAO,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AACtC,UAAI,WAAW,EAAE;AACf,YAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;AAC5B,cAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AACvB,eAAO,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;OAC9B,MAAM,IAAI,MAAM,EAAE;AACjB,cAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AACrB,eAAO,EAAE,CAAC;OACX,MAAM;AACL,eAAO,OAAO,CAAC;OAChB;KACF;GACF,CAAC;;AAGF,AAAC,GAAA,YAAW;AACV,QAAM,aAAa,GAAG,CACpB,oBAAoB,GACpB,2BAA2B,GAC3B,yBAAyB,GACzB,8BAA8B,GAC9B,mBAAmB,GACnB,gBAAgB,GAChB,uBAAuB,GACvB,0BAA0B,GAC1B,kCAAkC,GAClC,0BAA0B,GAC1B,iCAAiC,GACjC,6BAA6B,GAC7B,+BAA+B,GAC/B,yCAAyC,GACzC,uCAAuC,GACvC,kBAAkB,CAAA,CAClB,KAAK,CAAC,GAAG,CAAC,CAAC;;AAEb,QAAM,aAAa,GAAG,kBAAkB,CAAC,cAAc,GAAG,EAAE,CAAC;;AAE7D,SAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AACpD,mBAAa,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;KACxC;GACF,CAAA,EAAE,CAAE;;AAEL,oBAAkB,CAAC,6BAA6B,GAAG,UAAS,IAAI,EAAE;AAChE,WAAO,CAAC,kBAAkB,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,AAAC,4BAA4B,CAAE,IAAI,CAAC,IAAI,CAAC,CAAC;GAC9F,CAAC;;AAEF,WAAS,YAAY,CAAC,eAAe,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE;AAC5D,QAAI,KAAK,GAAG,QAAQ,CAAC,QAAQ,EAAE;QAC3B,CAAC,GAAG,CAAC;QACL,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;AACvB,QAAI,eAAe,EAAE;AACnB,SAAG,EAAE,CAAC;KACP;;AAED,WAAO,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;AACnB,WAAK,GAAG,QAAQ,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;KACpD;;AAED,QAAI,eAAe,EAAE;AACnB,aAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,kBAAkB,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;KACzG,MAAM;AACL,aAAO,KAAK,CAAC;KACd;GACF;;mBAEc,kBAAkB","file":"javascript-compiler.js","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    if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {\n      return [parent, '.', name];\n    } else {\n      return [parent, '[', JSON.stringify(name), ']'];\n    }\n  },\n  depthedLookup: function(name) {\n    return [this.aliasable('container.lookup'), '(depths, \"', name, '\")'];\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\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 = this.useDepths || environment.useDepths || environment.useDecorators || 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('var decorators = container.decorators;\\n');\n      this.decorators.push('return fn;');\n\n      if (asObject) {\n        this.decorators = Function.apply(this, ['fn', 'props', 'container', 'depth0', 'data', 'blockParams', 'depths', this.decorators.merge()]);\n      } else {\n        this.decorators.prepend('function(fn, props, container, depth0, data, blockParams, depths) {\\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    for (let alias in this.aliases) {    // eslint-disable-line guard-for-in\n      let node = this.aliases[alias];\n\n      if (this.aliases.hasOwnProperty(alias) && node.children && node.referenceCount > 1) {\n        varDeclarations += ', alias' + (++aliasCount) + '=' + alias;\n        node.children[0] = 'alias' + aliasCount;\n      }\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(['function(', params.join(','), ') {\\n  ', source, '}']);\n    }\n  },\n  mergeSource: function(varDeclarations) {\n    let isSimple = this.environment.isSimple,\n        appendOnly = !this.forceBuffer,\n        appendFirst,\n\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\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 += ', 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('var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\\n'));\n    }\n\n    return this.source.merge();\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('helpers.blockHelperMissing'),\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('helpers.blockHelperMissing'),\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 (!', this.lastHelper, ') { ',\n          current, ' = ', this.source.functionCall(blockHelperMissing, 'call', params),\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(['if (', local, ' != null) { ', this.appendToBuffer(local, undefined, true), ' }']);\n      if (this.environment.isSimple) {\n        this.pushSource(['else { ', this.appendToBuffer(\"''\", undefined, true), ' }']);\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(this.appendToBuffer(\n        [this.aliasable('container.escapeExpression'), '(', this.popStack(), ')']));\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([this.aliasable('container.lambda'), '(', this.popStack(), ', ', this.contextName(0), ')']);\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, '', ['fn', 'props', 'container', options]),\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        simple = isSimple ? [helper.name, ' || '] : '';\n\n    let lookup = ['('].concat(simple, nonHelper);\n    if (!this.options.strict) {\n      lookup.push(' || ', this.aliasable('helpers.helperMissing'));\n    }\n    lookup.push(')');\n\n    this.push(this.source.functionCall(lookup, 'call', helper.callParams));\n  },\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('helpers', name, 'helper');\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('helpers.helperMissing')\n      );\n    }\n\n    this.push([\n        '(', lookup,\n        (helper.paramsInit ? ['),(', helper.paramsInit] : []), '),',\n        '(typeof helper === ', this.aliasable('\"function\"'), ' ? ',\n        this.source.functionCall('helper', 'call', helper.callParams), ' : 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[' + name[0] + '].path[' + name[1] + ']'\n          + (child ? ' + ' + JSON.stringify('.' + child) : ''));\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, child, 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(child, options, this.context, !this.precompile);\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(this.source.quotedString(this.pendingContent), this.pendingLocation));\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) { this.stackVars.push('stack' + this.stackSlot); }\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(`${this.contextName(0)} != null ? ${this.contextName(0)} : (container.nullContext || {})`);\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 = 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\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\nJavaScriptCompiler.isValidJavaScriptVariableName = function(name) {\n  return !JavaScriptCompiler.RESERVED_WORDS[name] && (/^[a-zA-Z_$][0-9a-zA-Z_$]*$/).test(name);\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 [compiler.aliasable('container.strict'), '(', stack, ', ', compiler.quotedString(parts[i]), ')'];\n  } else {\n    return stack;\n  }\n}\n\nexport default JavaScriptCompiler;\n"]}