decaffeinate-parser/dist/index.js

A better AST for CoffeeScript, inspired by CoffeeScriptRedux.

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  AccessOp: () => AccessOp,
  ArrayInitialiser: () => ArrayInitialiser,
  AssignOp: () => AssignOp,
  AsyncFunction: () => AsyncFunction,
  Await: () => Await,
  AwaitReturn: () => AwaitReturn,
  BareSuperFunctionApplication: () => BareSuperFunctionApplication,
  BaseAssignOp: () => BaseAssignOp,
  BaseFunction: () => BaseFunction,
  BinaryOp: () => BinaryOp,
  BitAndOp: () => BitAndOp,
  BitNotOp: () => BitNotOp,
  BitOrOp: () => BitOrOp,
  BitXorOp: () => BitXorOp,
  Block: () => Block,
  Bool: () => Bool,
  BoundAsyncFunction: () => BoundAsyncFunction,
  BoundFunction: () => BoundFunction,
  BoundGeneratorFunction: () => BoundGeneratorFunction,
  Break: () => Break,
  CSXElement: () => CSXElement,
  ChainedComparisonOp: () => ChainedComparisonOp,
  Class: () => Class,
  ClassProtoAssignOp: () => ClassProtoAssignOp,
  CompoundAssignOp: () => CompoundAssignOp,
  Conditional: () => Conditional,
  Constructor: () => Constructor,
  Continue: () => Continue,
  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
  Debugger: () => Debugger,
  DefaultParam: () => DefaultParam,
  DeleteOp: () => DeleteOp,
  DivideOp: () => DivideOp,
  DoOp: () => DoOp,
  DynamicMemberAccessOp: () => DynamicMemberAccessOp,
  EQOp: () => EQOp,
  Elision: () => Elision,
  ExistsOp: () => ExistsOp,
  ExpOp: () => ExpOp,
  Expansion: () => Expansion,
  ExportAllDeclaration: () => ExportAllDeclaration,
  ExportBindingsDeclaration: () => ExportBindingsDeclaration,
  ExportDefaultDeclaration: () => ExportDefaultDeclaration,
  ExportNamedDeclaration: () => ExportNamedDeclaration,
  ExtendsOp: () => ExtendsOp,
  Float: () => Float,
  FloorDivideOp: () => FloorDivideOp,
  For: () => For,
  ForFrom: () => ForFrom,
  ForIn: () => ForIn,
  ForOf: () => ForOf,
  Function: () => Function,
  FunctionApplication: () => FunctionApplication,
  GTEOp: () => GTEOp,
  GTOp: () => GTOp,
  GeneratorFunction: () => GeneratorFunction,
  Heregex: () => Heregex,
  Identifier: () => Identifier,
  ImportDeclaration: () => ImportDeclaration,
  InOp: () => InOp,
  InstanceofOp: () => InstanceofOp,
  Int: () => Int,
  JavaScript: () => JavaScript,
  LTEOp: () => LTEOp,
  LTOp: () => LTOp,
  LeftShiftOp: () => LeftShiftOp,
  LogicalAndOp: () => LogicalAndOp,
  LogicalNotOp: () => LogicalNotOp,
  LogicalOrOp: () => LogicalOrOp,
  Loop: () => Loop,
  MemberAccessOp: () => MemberAccessOp,
  ModuleSpecifier: () => ModuleSpecifier,
  ModuloOp: () => ModuloOp,
  MultiplyOp: () => MultiplyOp,
  NEQOp: () => NEQOp,
  NewOp: () => NewOp,
  Node: () => Node,
  Null: () => Null,
  Number: () => Number,
  ObjectInitialiser: () => ObjectInitialiser,
  ObjectInitialiserMember: () => ObjectInitialiserMember,
  OfOp: () => OfOp,
  OperatorInfo: () => OperatorInfo,
  PlusOp: () => PlusOp,
  PostDecrementOp: () => PostDecrementOp,
  PostIncrementOp: () => PostIncrementOp,
  PreDecrementOp: () => PreDecrementOp,
  PreIncrementOp: () => PreIncrementOp,
  Program: () => Program,
  ProtoMemberAccessOp: () => ProtoMemberAccessOp,
  Quasi: () => Quasi,
  Range: () => Range,
  Regex: () => Regex,
  RegexFlags: () => RegexFlags,
  RemOp: () => RemOp,
  Rest: () => Rest,
  Return: () => Return,
  SeqOp: () => SeqOp,
  SignedRightShiftOp: () => SignedRightShiftOp,
  Slice: () => Slice,
  SoakedDynamicMemberAccessOp: () => SoakedDynamicMemberAccessOp,
  SoakedFunctionApplication: () => SoakedFunctionApplication,
  SoakedMemberAccessOp: () => SoakedMemberAccessOp,
  SoakedNewOp: () => SoakedNewOp,
  SoakedProtoMemberAccessOp: () => SoakedProtoMemberAccessOp,
  SoakedSlice: () => SoakedSlice,
  Spread: () => Spread,
  String: () => String,
  SubtractOp: () => SubtractOp,
  Super: () => Super,
  Switch: () => Switch,
  SwitchCase: () => SwitchCase,
  TaggedTemplateLiteral: () => TaggedTemplateLiteral,
  This: () => This,
  Throw: () => Throw,
  Try: () => Try,
  TypeofOp: () => TypeofOp,
  UnaryExistsOp: () => UnaryExistsOp,
  UnaryNegateOp: () => UnaryNegateOp,
  UnaryOp: () => UnaryOp,
  UnaryPlusOp: () => UnaryPlusOp,
  Undefined: () => Undefined,
  UnsignedRightShiftOp: () => UnsignedRightShiftOp,
  While: () => While,
  Yield: () => Yield,
  YieldFrom: () => YieldFrom,
  YieldReturn: () => YieldReturn,
  parse: () => parse4,
  traverse: () => traverse
});
module.exports = __toCommonJS(src_exports);

// src/parser.ts
var import_coffee_lex18 = __toESM(require("coffee-lex"));

// src/ext/coffee-script.ts
var import_nodes = require("decaffeinate-coffeescript/lib/coffee-script/nodes.js");
var import_nodes2 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
function patchCoffeeScript() {
  import_nodes.Op.prototype.invert = invert;
  import_nodes.Base.prototype.invert = invert;
  import_nodes2.Op.prototype.invert = invert;
  import_nodes2.Base.prototype.invert = invert;
}
function invert() {
  this.inverted = !this.inverted;
  return this;
}

// src/nodes.ts
var Node = class {
  constructor(type, line, column, start, end, raw) {
    this.type = type;
    this.line = line;
    this.column = column;
    this.start = start;
    this.end = end;
    this.raw = raw;
    this.parentNode = null;
  }
  getChildren() {
    const children = [];
    for (const childField of this.getChildFields()) {
      if (Array.isArray(childField)) {
        children.push(...childField.filter((node) => node !== null));
      } else if (childField) {
        children.push(childField);
      }
    }
    return children;
  }
  getChildFields() {
    return this.getChildNames().map((name) => this[name]);
  }
};
var Identifier = class extends Node {
  constructor(line, column, start, end, raw, data) {
    super("Identifier", line, column, start, end, raw);
    this.data = data;
  }
  getChildNames() {
    return [];
  }
};
var Bool = class extends Node {
  constructor(line, column, start, end, raw, data) {
    super("Bool", line, column, start, end, raw);
    this.data = data;
  }
  static true() {
    return new Bool(0, 0, 0, 0, "", true);
  }
  static false() {
    return new Bool(0, 0, 0, 0, "", false);
  }
  getChildNames() {
    return [];
  }
};
var JavaScript = class extends Node {
  constructor(line, column, start, end, raw, data) {
    super("JavaScript", line, column, start, end, raw);
    this.data = data;
  }
  getChildNames() {
    return [];
  }
};
var Number = class extends Node {
  constructor(type, line, column, start, end, raw, data) {
    super(type, line, column, start, end, raw);
    this.data = data;
  }
  getChildNames() {
    return [];
  }
};
var Float = class extends Number {
  constructor(line, column, start, end, raw, data) {
    super("Float", line, column, start, end, raw, data);
  }
};
var Int = class extends Number {
  constructor(line, column, start, end, raw, data) {
    super("Int", line, column, start, end, raw, data);
  }
};
var AccessOp = class extends Node {
  constructor(type, line, column, start, end, raw, expression) {
    super(type, line, column, start, end, raw);
    this.expression = expression;
  }
};
var MemberAccessOp = class extends AccessOp {
  constructor(line, column, start, end, raw, expression, member) {
    super("MemberAccessOp", line, column, start, end, raw, expression);
    this.member = member;
  }
  getChildNames() {
    return ["expression", "member"];
  }
};
var ProtoMemberAccessOp = class extends AccessOp {
  constructor(line, column, start, end, raw, expression) {
    super("ProtoMemberAccessOp", line, column, start, end, raw, expression);
  }
  getChildNames() {
    return ["expression"];
  }
};
var SoakedMemberAccessOp = class extends AccessOp {
  constructor(line, column, start, end, raw, expression, member) {
    super("SoakedMemberAccessOp", line, column, start, end, raw, expression);
    this.member = member;
  }
  getChildNames() {
    return ["expression", "member"];
  }
};
var SoakedProtoMemberAccessOp = class extends AccessOp {
  constructor(line, column, start, end, raw, expression) {
    super("SoakedProtoMemberAccessOp", line, column, start, end, raw, expression);
  }
  getChildNames() {
    return ["expression"];
  }
};
var DynamicMemberAccessOp = class extends AccessOp {
  constructor(line, column, start, end, raw, expression, indexingExpr) {
    super("DynamicMemberAccessOp", line, column, start, end, raw, expression);
    this.indexingExpr = indexingExpr;
  }
  getChildNames() {
    return ["expression", "indexingExpr"];
  }
};
var SoakedDynamicMemberAccessOp = class extends AccessOp {
  constructor(line, column, start, end, raw, expression, indexingExpr) {
    super("SoakedDynamicMemberAccessOp", line, column, start, end, raw, expression);
    this.indexingExpr = indexingExpr;
  }
  getChildNames() {
    return ["expression", "indexingExpr"];
  }
};
var Quasi = class extends Node {
  constructor(line, column, start, end, raw, data) {
    super("Quasi", line, column, start, end, raw);
    this.data = data;
  }
  getChildNames() {
    return [];
  }
};
var String = class extends Node {
  constructor(line, column, start, end, raw, quasis, expressions) {
    super("String", line, column, start, end, raw);
    this.quasis = quasis;
    this.expressions = expressions;
  }
  getChildNames() {
    return ["quasis", "expressions"];
  }
};
var TaggedTemplateLiteral = class extends Node {
  constructor(line, column, start, end, raw, tag, template) {
    super("TaggedTemplateLiteral", line, column, start, end, raw);
    this.tag = tag;
    this.template = template;
  }
  getChildNames() {
    return ["tag", "template"];
  }
};
var ObjectInitialiser = class extends Node {
  constructor(line, column, start, end, raw, members) {
    super("ObjectInitialiser", line, column, start, end, raw);
    this.members = members;
  }
  getChildNames() {
    return ["members"];
  }
};
var ObjectInitialiserMember = class extends Node {
  constructor(line, column, start, end, raw, key, expression, isComputed) {
    super("ObjectInitialiserMember", line, column, start, end, raw);
    this.key = key;
    this.expression = expression;
    this.isComputed = isComputed;
  }
  getChildNames() {
    return ["key", "expression"];
  }
};
var Conditional = class extends Node {
  constructor(line, column, start, end, raw, condition, consequent, alternate, isUnless) {
    super("Conditional", line, column, start, end, raw);
    this.condition = condition;
    this.consequent = consequent;
    this.alternate = alternate;
    this.isUnless = isUnless;
  }
  getChildNames() {
    return ["condition", "consequent", "alternate"];
  }
};
var Program = class extends Node {
  constructor(line, column, start, end, raw, body, context) {
    super("Program", line, column, start, end, raw);
    this.body = body;
    this.context = context;
  }
  getChildNames() {
    return ["body"];
  }
};
var Block = class extends Node {
  constructor(line, column, start, end, raw, statements, inline) {
    super("Block", line, column, start, end, raw);
    this.statements = statements;
    this.inline = inline;
  }
  getChildNames() {
    return ["statements"];
  }
  withInline(inline) {
    return new Block(this.line, this.column, this.start, this.end, this.raw, this.statements, inline);
  }
};
var Loop = class extends Node {
  constructor(line, column, start, end, raw, body) {
    super("Loop", line, column, start, end, raw);
    this.body = body;
  }
  getChildNames() {
    return ["body"];
  }
};
var While = class extends Node {
  constructor(line, column, start, end, raw, condition, guard, body, isUntil) {
    super("While", line, column, start, end, raw);
    this.condition = condition;
    this.guard = guard;
    this.body = body;
    this.isUntil = isUntil;
  }
  getChildNames() {
    return ["condition", "guard", "body"];
  }
};
var For = class extends Node {
  constructor(type, line, column, start, end, raw, keyAssignee, valAssignee, target, filter, body) {
    super(type, line, column, start, end, raw);
    this.keyAssignee = keyAssignee;
    this.valAssignee = valAssignee;
    this.target = target;
    this.filter = filter;
    this.body = body;
  }
};
var ForOf = class extends For {
  constructor(line, column, start, end, raw, keyAssignee, valAssignee, target, filter, body, isOwn) {
    super("ForOf", line, column, start, end, raw, keyAssignee, valAssignee, target, filter, body);
    this.isOwn = isOwn;
  }
  getChildNames() {
    return ["keyAssignee", "valAssignee", "target", "filter", "body"];
  }
};
var ForIn = class extends For {
  constructor(line, column, start, end, raw, keyAssignee, valAssignee, target, filter, body, step) {
    super("ForIn", line, column, start, end, raw, keyAssignee, valAssignee, target, filter, body);
    this.step = step;
  }
  getChildNames() {
    return ["keyAssignee", "valAssignee", "target", "step", "filter", "body"];
  }
};
var ForFrom = class extends For {
  constructor(line, column, start, end, raw, valAssignee, target, filter, body) {
    super("ForFrom", line, column, start, end, raw, null, valAssignee, target, filter, body);
  }
  getChildNames() {
    return ["keyAssignee", "valAssignee", "target", "filter", "body"];
  }
};
var Switch = class extends Node {
  constructor(line, column, start, end, raw, expression, cases, alternate) {
    super("Switch", line, column, start, end, raw);
    this.expression = expression;
    this.cases = cases;
    this.alternate = alternate;
  }
  getChildNames() {
    return ["expression", "cases", "alternate"];
  }
};
var SwitchCase = class extends Node {
  constructor(line, column, start, end, raw, conditions, consequent) {
    super("SwitchCase", line, column, start, end, raw);
    this.conditions = conditions;
    this.consequent = consequent;
  }
  getChildNames() {
    return ["conditions", "consequent"];
  }
};
var RegexFlags = class {
  constructor(global, ignoreCase, multiline, unicode, sticky) {
    this.global = global;
    this.ignoreCase = ignoreCase;
    this.multiline = multiline;
    this.unicode = unicode;
    this.sticky = sticky;
    this.g = global;
    this.i = ignoreCase;
    this.m = multiline;
    this.u = unicode;
    this.y = sticky;
  }
  static parse(flags) {
    let global = false;
    let ignoreCase = false;
    let multiline = false;
    let unicode = false;
    let sticky = false;
    for (let i = 0; i < flags.length; i++) {
      switch (flags.charCodeAt(i)) {
        case 103:
          global = true;
          break;
        case 105:
          ignoreCase = true;
          break;
        case 109:
          multiline = true;
          break;
        case 117:
          unicode = true;
          break;
        case 121:
          sticky = true;
          break;
        default:
          throw new Error(`invalid regular expression flags: ${flags}`);
      }
    }
    return new RegexFlags(global, ignoreCase, multiline, unicode, sticky);
  }
};
var Heregex = class extends Node {
  constructor(line, column, start, end, raw, quasis, expressions, flags) {
    super("Heregex", line, column, start, end, raw);
    this.quasis = quasis;
    this.expressions = expressions;
    this.flags = flags;
  }
  getChildNames() {
    return ["quasis", "expressions"];
  }
};
var Null = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Null", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Undefined = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Undefined", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Regex = class extends Node {
  constructor(line, column, start, end, raw, pattern, flags) {
    super("Regex", line, column, start, end, raw);
    this.pattern = pattern;
    this.flags = flags;
  }
  getChildNames() {
    return [];
  }
};
var Return = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("Return", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var YieldReturn = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("YieldReturn", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var AwaitReturn = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("AwaitReturn", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var This = class extends Node {
  constructor(line, column, start, end, raw) {
    super("This", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Throw = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("Throw", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var ArrayInitialiser = class extends Node {
  constructor(line, column, start, end, raw, members) {
    super("ArrayInitialiser", line, column, start, end, raw);
    this.members = members;
  }
  getChildNames() {
    return ["members"];
  }
};
var DefaultParam = class extends Node {
  constructor(line, column, start, end, raw, param, defaultValue) {
    super("DefaultParam", line, column, start, end, raw);
    this.param = param;
    this.default = defaultValue;
  }
  getChildNames() {
    return ["param", "default"];
  }
};
var Rest = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("Rest", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var Expansion = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Expansion", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Elision = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Elision", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Break = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Break", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Continue = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Continue", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Debugger = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Debugger", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var Spread = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("Spread", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var Range = class extends Node {
  constructor(line, column, start, end, raw, left, right, isInclusive) {
    super("Range", line, column, start, end, raw);
    this.left = left;
    this.right = right;
    this.isInclusive = isInclusive;
  }
  getChildNames() {
    return ["left", "right"];
  }
};
var BinaryOp = class extends Node {
  constructor(type, line, column, start, end, raw, left, right) {
    super(type, line, column, start, end, raw);
    this.left = left;
    this.right = right;
  }
  getChildNames() {
    return ["left", "right"];
  }
};
var UnaryOp = class extends Node {
  constructor(type, line, column, start, end, raw, expression) {
    super(type, line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var ChainedComparisonOp = class extends Node {
  constructor(line, column, start, end, raw, operands, operators) {
    super("ChainedComparisonOp", line, column, start, end, raw);
    this.operands = operands;
    this.operators = operators;
  }
  getChildNames() {
    return ["operands"];
  }
};
var OperatorInfo = class {
  constructor(operator, token) {
    this.operator = operator;
    this.token = token;
  }
};
var EQOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("EQOp", line, column, start, end, raw, left, right);
  }
};
var NEQOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("NEQOp", line, column, start, end, raw, left, right);
  }
};
var LTOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("LTOp", line, column, start, end, raw, left, right);
  }
};
var LTEOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("LTEOp", line, column, start, end, raw, left, right);
  }
};
var GTOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("GTOp", line, column, start, end, raw, left, right);
  }
};
var GTEOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("GTEOp", line, column, start, end, raw, left, right);
  }
};
var LogicalNotOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("LogicalNotOp", line, column, start, end, raw, expression);
  }
};
var LogicalAndOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("LogicalAndOp", line, column, start, end, raw, left, right);
  }
};
var LogicalOrOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("LogicalOrOp", line, column, start, end, raw, left, right);
  }
};
var SubtractOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("SubtractOp", line, column, start, end, raw, left, right);
  }
};
var PlusOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("PlusOp", line, column, start, end, raw, left, right);
  }
};
var UnaryPlusOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("UnaryPlusOp", line, column, start, end, raw, expression);
  }
};
var MultiplyOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("MultiplyOp", line, column, start, end, raw, left, right);
  }
};
var DivideOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("DivideOp", line, column, start, end, raw, left, right);
  }
};
var FloorDivideOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("FloorDivideOp", line, column, start, end, raw, left, right);
  }
};
var ExistsOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("ExistsOp", line, column, start, end, raw, left, right);
  }
};
var UnaryExistsOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("UnaryExistsOp", line, column, start, end, raw, expression);
  }
};
var UnaryNegateOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("UnaryNegateOp", line, column, start, end, raw, expression);
  }
};
var BitNotOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("BitNotOp", line, column, start, end, raw, expression);
  }
};
var BitAndOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("BitAndOp", line, column, start, end, raw, left, right);
  }
};
var BitOrOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("BitOrOp", line, column, start, end, raw, left, right);
  }
};
var BitXorOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("BitXorOp", line, column, start, end, raw, left, right);
  }
};
var LeftShiftOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("LeftShiftOp", line, column, start, end, raw, left, right);
  }
};
var SignedRightShiftOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("SignedRightShiftOp", line, column, start, end, raw, left, right);
  }
};
var UnsignedRightShiftOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("UnsignedRightShiftOp", line, column, start, end, raw, left, right);
  }
};
var PreDecrementOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("PreDecrementOp", line, column, start, end, raw, expression);
  }
};
var PreIncrementOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("PreIncrementOp", line, column, start, end, raw, expression);
  }
};
var PostDecrementOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("PostDecrementOp", line, column, start, end, raw, expression);
  }
};
var PostIncrementOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("PostIncrementOp", line, column, start, end, raw, expression);
  }
};
var ExpOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("ExpOp", line, column, start, end, raw, left, right);
  }
};
var RemOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("RemOp", line, column, start, end, raw, left, right);
  }
};
var ModuloOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("ModuloOp", line, column, start, end, raw, left, right);
  }
};
var InOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right, isNot) {
    super("InOp", line, column, start, end, raw, left, right);
    this.isNot = isNot;
  }
};
var BaseAssignOp = class extends Node {
  constructor(type, line, column, start, end, raw, assignee, expression) {
    super(type, line, column, start, end, raw);
    this.assignee = assignee;
    this.expression = expression;
  }
  getChildNames() {
    return ["assignee", "expression"];
  }
};
var AssignOp = class extends BaseAssignOp {
  constructor(line, column, start, end, raw, assignee, expression) {
    super("AssignOp", line, column, start, end, raw, assignee, expression);
  }
  withExpression(expression) {
    return new AssignOp(this.line, this.column, this.start, this.end, this.raw, this.assignee, expression);
  }
};
var CompoundAssignOp = class extends BaseAssignOp {
  constructor(line, column, start, end, raw, assignee, expression, op) {
    super("CompoundAssignOp", line, column, start, end, raw, assignee, expression);
    this.op = op;
  }
};
var ExtendsOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("ExtendsOp", line, column, start, end, raw, left, right);
  }
};
var SeqOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right) {
    super("SeqOp", line, column, start, end, raw, left, right);
  }
};
var TypeofOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("TypeofOp", line, column, start, end, raw, expression);
  }
};
var InstanceofOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right, isNot) {
    super("InstanceofOp", line, column, start, end, raw, left, right);
    this.isNot = isNot;
  }
};
var OfOp = class extends BinaryOp {
  constructor(line, column, start, end, raw, left, right, isNot) {
    super("OfOp", line, column, start, end, raw, left, right);
    this.isNot = isNot;
  }
};
var DeleteOp = class extends UnaryOp {
  constructor(line, column, start, end, raw, expression) {
    super("DeleteOp", line, column, start, end, raw, expression);
  }
};
var Yield = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("Yield", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var YieldFrom = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("YieldFrom", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var Await = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("Await", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var Slice = class extends Node {
  constructor(line, column, start, end, raw, expression, left, right, isInclusive) {
    super("Slice", line, column, start, end, raw);
    this.expression = expression;
    this.left = left;
    this.right = right;
    this.isInclusive = isInclusive;
  }
  getChildNames() {
    return ["expression", "left", "right"];
  }
};
var SoakedSlice = class extends Node {
  constructor(line, column, start, end, raw, expression, left, right, isInclusive) {
    super("SoakedSlice", line, column, start, end, raw);
    this.expression = expression;
    this.left = left;
    this.right = right;
    this.isInclusive = isInclusive;
  }
  getChildNames() {
    return ["expression", "left", "right"];
  }
};
var BaseFunction = class extends Node {
  constructor(type, line, column, start, end, raw, parameters, body) {
    super(type, line, column, start, end, raw);
    this.parameters = parameters;
    this.body = body;
  }
  getChildNames() {
    return ["parameters", "body"];
  }
};
var Function = class extends BaseFunction {
  constructor(line, column, start, end, raw, parameters, body) {
    super("Function", line, column, start, end, raw, parameters, body);
  }
  withParameters(parameters) {
    return new Function(this.line, this.column, this.start, this.end, this.raw, parameters, this.body);
  }
};
var BoundFunction = class extends BaseFunction {
  constructor(line, column, start, end, raw, parameters, body) {
    super("BoundFunction", line, column, start, end, raw, parameters, body);
  }
  withParameters(parameters) {
    return new BoundFunction(this.line, this.column, this.start, this.end, this.raw, parameters, this.body);
  }
};
var GeneratorFunction = class extends BaseFunction {
  constructor(line, column, start, end, raw, parameters, body) {
    super("GeneratorFunction", line, column, start, end, raw, parameters, body);
  }
  withParameters(parameters) {
    return new GeneratorFunction(this.line, this.column, this.start, this.end, this.raw, parameters, this.body);
  }
};
var BoundGeneratorFunction = class extends BaseFunction {
  constructor(line, column, start, end, raw, parameters, body) {
    super("BoundGeneratorFunction", line, column, start, end, raw, parameters, body);
  }
  withParameters(parameters) {
    return new BoundGeneratorFunction(this.line, this.column, this.start, this.end, this.raw, parameters, this.body);
  }
};
var AsyncFunction = class extends BaseFunction {
  constructor(line, column, start, end, raw, parameters, body) {
    super("AsyncFunction", line, column, start, end, raw, parameters, body);
  }
  withParameters(parameters) {
    return new AsyncFunction(this.line, this.column, this.start, this.end, this.raw, parameters, this.body);
  }
};
var BoundAsyncFunction = class extends BaseFunction {
  constructor(line, column, start, end, raw, parameters, body) {
    super("BoundAsyncFunction", line, column, start, end, raw, parameters, body);
  }
  withParameters(parameters) {
    return new BoundAsyncFunction(this.line, this.column, this.start, this.end, this.raw, parameters, this.body);
  }
};
var Try = class extends Node {
  constructor(line, column, start, end, raw, body, catchAssignee, catchBody, finallyBody) {
    super("Try", line, column, start, end, raw);
    this.body = body;
    this.catchAssignee = catchAssignee;
    this.catchBody = catchBody;
    this.finallyBody = finallyBody;
  }
  getChildNames() {
    return ["body", "catchAssignee", "catchBody", "finallyBody"];
  }
};
var Constructor = class extends BaseAssignOp {
  constructor(line, column, start, end, raw, assignee, expression) {
    super("Constructor", line, column, start, end, raw, assignee, expression);
  }
};
var ClassProtoAssignOp = class extends BaseAssignOp {
  constructor(line, column, start, end, raw, assignee, expression) {
    super("ClassProtoAssignOp", line, column, start, end, raw, assignee, expression);
  }
};
var Class = class extends Node {
  constructor(line, column, start, end, raw, nameAssignee, name, body, boundMembers, parent, ctor) {
    super("Class", line, column, start, end, raw);
    this.nameAssignee = nameAssignee;
    this.name = name;
    this.body = body;
    this.boundMembers = boundMembers;
    this.parent = parent;
    this.ctor = ctor;
  }
  getChildNames() {
    return ["nameAssignee", "parent", "body"];
  }
};
var FunctionApplication = class extends Node {
  constructor(line, column, start, end, raw, fn, args) {
    super("FunctionApplication", line, column, start, end, raw);
    this.function = fn;
    this.arguments = args;
  }
  getChildNames() {
    return ["function", "arguments"];
  }
};
var SoakedFunctionApplication = class extends Node {
  constructor(line, column, start, end, raw, fn, args) {
    super("SoakedFunctionApplication", line, column, start, end, raw);
    this.function = fn;
    this.arguments = args;
  }
  getChildNames() {
    return ["function", "arguments"];
  }
};
var Super = class extends Node {
  constructor(line, column, start, end, raw) {
    super("Super", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var BareSuperFunctionApplication = class extends Node {
  constructor(line, column, start, end, raw) {
    super("BareSuperFunctionApplication", line, column, start, end, raw);
  }
  getChildNames() {
    return [];
  }
};
var NewOp = class extends Node {
  constructor(line, column, start, end, raw, ctor, args) {
    super("NewOp", line, column, start, end, raw);
    this.ctor = ctor;
    this.arguments = args;
  }
  getChildNames() {
    return ["ctor", "arguments"];
  }
};
var SoakedNewOp = class extends Node {
  constructor(line, column, start, end, raw, ctor, args) {
    super("SoakedNewOp", line, column, start, end, raw);
    this.ctor = ctor;
    this.arguments = args;
  }
  getChildNames() {
    return ["ctor", "arguments"];
  }
};
var DoOp = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("DoOp", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var ImportDeclaration = class extends Node {
  constructor(line, column, start, end, raw, defaultBinding, namespaceImport, namedImports, source) {
    super("ImportDeclaration", line, column, start, end, raw);
    this.defaultBinding = defaultBinding;
    this.namespaceImport = namespaceImport;
    this.namedImports = namedImports;
    this.source = source;
  }
  getChildNames() {
    return ["defaultBinding", "namespaceImport", "namedImports", "source"];
  }
};
var ExportNamedDeclaration = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("ExportNamedDeclaration", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var ExportBindingsDeclaration = class extends Node {
  constructor(line, column, start, end, raw, namedExports, source) {
    super("ExportBindingsDeclaration", line, column, start, end, raw);
    this.namedExports = namedExports;
    this.source = source;
  }
  getChildNames() {
    return ["namedExports", "source"];
  }
};
var ExportDefaultDeclaration = class extends Node {
  constructor(line, column, start, end, raw, expression) {
    super("ExportDefaultDeclaration", line, column, start, end, raw);
    this.expression = expression;
  }
  getChildNames() {
    return ["expression"];
  }
};
var ExportAllDeclaration = class extends Node {
  constructor(line, column, start, end, raw, source) {
    super("ExportAllDeclaration", line, column, start, end, raw);
    this.source = source;
  }
  getChildNames() {
    return ["source"];
  }
};
var ModuleSpecifier = class extends Node {
  constructor(line, column, start, end, raw, original, alias) {
    super("ModuleSpecifier", line, column, start, end, raw);
    this.original = original;
    this.alias = alias;
  }
  getChildNames() {
    return ["original", "alias"];
  }
};
var CSXElement = class extends Node {
  constructor(line, column, start, end, raw, properties, children) {
    super("CSXElement", line, column, start, end, raw);
    this.properties = properties;
    this.children = children;
  }
  getChildNames() {
    return ["properties", "children"];
  }
};

// src/util/isCommentOnlyNode.ts
var import_nodes3 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
function isCommentOnlyNode(base) {
  return base instanceof import_nodes3.Value && base.base instanceof import_nodes3.PassthroughLiteral && base.base.value === "";
}

// src/mappers/mapBlock.ts
var import_coffee_lex14 = require("coffee-lex");
var import_nodes50 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
var import_util8 = require("util");

// src/util/getLocation.ts
var import_coffee_lex = require("coffee-lex");
var import_util = require("util");
function getLocation(context, node) {
  const loc = node.locationData;
  let start = context.linesAndColumns.indexForLocation({
    line: loc.first_line,
    column: loc.first_column
  });
  const last = context.linesAndColumns.indexForLocation({
    line: loc.last_line,
    column: loc.last_column
  });
  if (start === null || last === null) {
    throw new Error(`unable to determine range for location: ${(0, import_util.inspect)(loc)}}`);
  }
  const line = loc.first_line + 1;
  const column = loc.first_column + 1;
  let end = last + 1;
  if (start < 0) {
    start = 0;
  }
  if (end > context.source.length) {
    end = context.source.length;
  }
  const firstTokenOfNode = requireToken(firstSemanticTokenAfter(context, start), node);
  const lastTokenOfNode = requireToken(firstSemanticTokenBefore(context, end), node);
  start = firstTokenOfNode.start;
  end = lastTokenOfNode.end;
  const raw = context.source.slice(start, end);
  return { line, column, start, end, raw };
}
function firstSemanticTokenAfter(context, index) {
  const tokenIndex = context.sourceTokens.indexOfTokenMatchingPredicate((token) => {
    return token.start >= index && token.type !== import_coffee_lex.SourceType.NEWLINE && token.type !== import_coffee_lex.SourceType.COMMENT;
  }, context.sourceTokens.indexOfTokenNearSourceIndex(index));
  return tokenIndex === null ? null : context.sourceTokens.tokenAtIndex(tokenIndex);
}
function firstSemanticTokenBefore(context, index) {
  const tokenIndex = context.sourceTokens.lastIndexOfTokenMatchingPredicate((token) => {
    return token.end <= index && token.type !== import_coffee_lex.SourceType.NEWLINE && token.type !== import_coffee_lex.SourceType.COMMENT;
  }, context.sourceTokens.indexOfTokenNearSourceIndex(index));
  return tokenIndex === null ? null : context.sourceTokens.tokenAtIndex(tokenIndex);
}
function requireToken(token, node) {
  if (token === null) {
    throw new Error(`unable to find token for node: ${(0, import_util.inspect)(node)}`);
  }
  return token;
}

// src/mappers/mapAny.ts
var import_nodes49 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");

// src/util/UnsupportedNodeError.ts
var import_util2 = require("util");
var UnsupportedNodeError = class extends Error {
  constructor(node, message = null) {
    const prefix = message ? `${message}

` : "";
    super(`${prefix}node type '${node.constructor.name}' is not supported: ${(0, import_util2.inspect)(node)}`);
    Object.setPrototypeOf(this, UnsupportedNodeError.prototype);
    this.node = node;
  }
};

// src/mappers/mapArr.ts
function mapArr(context, node) {
  const { line, column, start, end, raw } = getLocation(context, node);
  const members = node.objects.map((object) => mapAny(context, object));
  return new ArrayInitialiser(line, column, start, end, raw, members);
}

// src/mappers/mapAssign.ts
var COMPOUND_ASSIGN_OPS = {
  "-=": SubtractOp.name,
  "+=": PlusOp.name,
  "/=": DivideOp.name,
  "*=": MultiplyOp.name,
  "%=": RemOp.name,
  "||=": LogicalOrOp.name,
  "&&=": LogicalAndOp.name,
  "?=": ExistsOp.name,
  "<<=": LeftShiftOp.name,
  ">>=": SignedRightShiftOp.name,
  ">>>=": UnsignedRightShiftOp.name,
  "&=": BitAndOp.name,
  "^=": BitXorOp.name,
  "|=": BitOrOp.name,
  "**=": ExpOp.name,
  "//=": FloorDivideOp.name,
  "%%=": ModuloOp.name
};
function mapAssign(context, node) {
  if (node.context === "object") {
    throw new UnsupportedNodeError(node, "Unexpected object context when mapping regular assign op.");
  }
  const { line, column, start, end, raw } = getLocation(context, node);
  if (node.context) {
    const opName = COMPOUND_ASSIGN_OPS[node.context];
    if (!opName) {
      throw new UnsupportedNodeError(node, "Unexpected operator context for assign op.");
    }
    return new CompoundAssignOp(line, column, start, end, raw, mapAny(context, node.variable), mapAny(context, node.value), opName);
  } else {
    return new AssignOp(line, column, start, end, raw, mapAny(context, node.variable), mapAny(context, node.value));
  }
}

// src/mappers/mapCall.ts
var import_coffee_lex5 = require("coffee-lex");
var import_nodes12 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
var import_util3 = require("util");

// src/util/isHeregexTemplateNode.ts
var import_coffee_lex2 = require("coffee-lex");
var import_nodes6 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
function isHeregexTemplateNode(node, context) {
  if (!(node instanceof import_nodes6.Call) || !node.variable || !(node.variable instanceof import_nodes6.Value) || !node.variable.base || !(node.variable.base instanceof import_nodes6.Literal) || node.variable.base.value !== "RegExp") {
    return false;
  }
  const { sourceTokens, linesAndColumns } = context;
  const start = linesAndColumns.indexForLocation({
    line: node.locationData.first_line,
    column: node.locationData.first_column
  });
  if (start === null) {
    return false;
  }
  const startTokenIndex = sourceTokens.indexOfTokenContainingSourceIndex(start);
  if (startTokenIndex === null) {
    return false;
  }
  const startToken = sourceTokens.tokenAtIndex(startTokenIndex);
  if (startToken === null) {
    return false;
  }
  return startToken.type === import_coffee_lex2.SourceType.HEREGEXP_START;
}

// src/util/locationsEqual.ts
function locationsEqual(first, second) {
  return first.first_line === second.first_line && first.first_column === second.first_column && first.last_line === second.last_line && first.last_column === second.last_column;
}

// src/util/getTemplateLiteralComponents.ts
var import_coffee_lex4 = require("coffee-lex");
var import_nodes7 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");

// src/util/isPlusTokenBetweenRanges.ts
var import_coffee_lex3 = require("coffee-lex");
function isPlusTokenBetweenRanges(leftRange, rightRange, context) {
  const tokens = context.sourceTokens;
  const leftEnd = tokens.indexOfTokenContainingSourceIndex(leftRange[1] - 1);
  const rightStart = tokens.indexOfTokenContainingSourceIndex(rightRange[0]);
  if (!leftEnd || !rightStart) {
    return false;
  }
  const afterLeftEnd = leftEnd.next();
  if (!afterLeftEnd) {
    return false;
  }
  const tokensBetweenOperands = tokens.slice(afterLeftEnd, rightStart);
  let foundPlusToken = false;
  tokensBetweenOperands.forEach(({ type, start, end }) => {
    if (type === import_coffee_lex3.SourceType.OPERATOR && context.source.slice(start, end) === "+") {
      foundPlusToken = true;
    }
  });
  return foundPlusToken;
}

// src/util/isImplicitPlusOp.ts
function isImplicitPlusOp(op, context) {
  if (op.operator !== "+" || !op.second) {
    return false;
  }
  const firstRange = context.getRange(op.first);
  const secondRange = context.getRange(op.second);
  if (!firstRange || !secondRange) {
    throw new Error("Expected valid location data on plus operation.");
  }
  return !isPlusTokenBetweenRanges(firstRange, secondRange, context);
}

// src/util/parseString.ts
var import_parser = require("@codemod/parser");
function parseString(string) {
  const expressionStatement = (0, import_parser.parse)(`(${string})`).program.body[0];
  const literal = expressionStatement.expression;
  return literal.value;
}

// src/util/getTemplateLiteralComponents.ts
function getTemplateLiteralComponents(context, node) {
  const tokens = context.sourceTokens;
  const quasis = [];
  const unmappedExpressions = [];
  const elements = getElements(node, context);
  const nodeRange = context.getRange(node);
  if (!nodeRange) {
    throw new Error("Expected valid range on template literal node.");
  }
  const { startTokenIndex, startToken } = getStartToken(nodeRange[0], tokens);
  let depth = 0;
  let lastToken = startToken;
  for (let tokenIndex = startTokenIndex; tokenIndex; tokenIndex = tokenIndex.next()) {
    const token = tokens.tokenAtIndex(tokenIndex);
    if (!token) {
      break;
    }
    if (token.type === import_coffee_lex4.SourceType.INTERPOLATION_START || token.type === import_coffee_lex4.SourceType.CSX_OPEN_TAG_START) {
      depth++;
      if (depth === 1) {
        quasis.push(findQuasi(lastToken, token, context, elements));
        lastToken = token;
      }
    } else if (token.type === import_coffee_lex4.SourceType.INTERPOLATION_END || token.type === import_coffee_lex4.SourceType.CSX_SELF_CLOSING_TAG_END || token.type === import_coffee_lex4.SourceType.CSX_CLOSE_TAG_END) {
      depth--;
      if (depth === 0) {
        unmappedExpressions.push(findExpression(lastToken, token, context, elements));
        lastToken = token;
      }
    } else if (depth === 0 && isTemplateLiteralEnd(token)) {
      quasis.push(findQuasi(lastToken, token, context, elements));
      lastToken = token;
      break;
    }
  }
  return {
    quasis,
    unmappedExpressions,
    start: startToken.start,
    end: lastToken.end
  };
}
function getElements(node, context) {
  if (node instanceof import_nodes7.Op && isImplicitPlusOp(node, context)) {
    if (!node.second) {
      throw new Error("Expected second operand on plus op.");
    }
    return [
      ...getElements(node.first, context),
      ...getElements(node.second, context)
    ];
  }
  return [node];
}
function getStartToken(start, tokens) {
  let tokenIndex = tokens.indexOfTokenNearSourceIndex(start);
  for (let i = 0; i < 5; i++) {
    const token = tokens.tokenAtIndex(tokenIndex);
    if (!token) {
      throw new Error("Expected to find a start token in a template literal.");
    }
    if (isTemplateLiteralStart(token)) {
      return { startToken: token, startTokenIndex: tokenIndex };
    }
    const prevToken = tokenIndex.previous();
    if (!prevToken) {
      throw new Error("Expected a previous token when searching for a template start.");
    }
    tokenIndex = prevToken;
  }
  throw new Error("Expected a template literal start token.");
}
function findQuasi(leftToken, rightToken, context, elements) {
  const matchingElements = elements.filter((elem) => {
    const range = context.getRange(elem);
    if (!range) {
      throw new Error("Unexpected invalid range.");
    }
    return range[0] >= leftToken.start && range[1] <= rightToken.end;
  });
  const start = leftToken.end;
  const end = rightToken.start;
  const startLoc = context.linesAndColumns.locationForIndex(leftToken.end);
  if (!startLoc) {
    throw new Error(`Expected to find a location for index ${leftToken.end}.`);
  }
  const raw = context.source.slice(start, end);
  if (matchingElements.length === 0) {
    return new Quasi(startLoc.line + 1, startLoc.column + 1, start, end, raw, "");
  } else if (matchingElements.length === 1) {
    const element = matchingElements[0];
    let literal;
    if (element instanceof import_nodes7.Literal) {
      literal = element;
    } else if (element instanceof import_nodes7.Value && element.properties.length === 0 && element.base instanceof import_nodes7.Literal) {
      literal = element.base;
    } else {
      throw new Error("Expected quasi element to be either a literal or a value containing only a literal.");
    }
    const stringValue = parseString(literal.value);
    return new Quasi(startLoc.line + 1, startLoc.column + 1, start, end, raw, stringValue !== void 0 ? stringValue : literal.value);
  } else {
    throw new Error("Unexpectedly found multiple elements in string interpolation.");
  }
}
function findExpression(leftToken, rightToken, context, elements) {
  const matchingElements = elements.filter((elem) => {
    const range = context.getRange(elem);
    if (!rang