wice_grid 6.1.3 → 7.1.0

data/node_modules/decaffeinate-parser/dist/index.js

@@ -0,0 +1,3458 @@
+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 (!range) {
+      throw new Error("Unexpected invalid range.");
+    }
+    return range[0] >= leftToken.start && range[1] <= rightToken.end;
+  });
+  if (matchingElements.length === 0) {
+    return null;
+  } else if (matchingElements.length === 1) {
+    return matchingElements[0];
+  } else {
+    throw new Error("Unexpectedly found multiple elements in string interpolation.");
+  }
+}
+function isTemplateLiteralStart(token) {
+  return [
+    import_coffee_lex4.SourceType.DSTRING_START,
+    import_coffee_lex4.SourceType.SSTRING_START,
+    import_coffee_lex4.SourceType.TDSTRING_START,
+    import_coffee_lex4.SourceType.TSSTRING_START,
+    import_coffee_lex4.SourceType.HEREGEXP_START,
+    import_coffee_lex4.SourceType.CSX_OPEN_TAG_END
+  ].indexOf(token.type) >= 0;
+}
+function isTemplateLiteralEnd(token) {
+  return [
+    import_coffee_lex4.SourceType.DSTRING_END,
+    import_coffee_lex4.SourceType.SSTRING_END,
+    import_coffee_lex4.SourceType.TDSTRING_END,
+    import_coffee_lex4.SourceType.TSSTRING_END,
+    import_coffee_lex4.SourceType.HEREGEXP_END,
+    import_coffee_lex4.SourceType.CSX_CLOSE_TAG_START
+  ].indexOf(token.type) >= 0;
+}
+
+// src/util/makeHeregex.ts
+function makeHeregex(context, node, flags) {
+  const { quasis, unmappedExpressions, start, end } = getTemplateLiteralComponents(context, node);
+  const startLoc = context.linesAndColumns.locationForIndex(start);
+  if (!startLoc) {
+    throw new Error(`Expected to find a location for index ${start}.`);
+  }
+  const raw = context.source.slice(start, end);
+  return new Heregex(startLoc.line + 1, startLoc.column + 1, start, end, raw, quasis, unmappedExpressions.map((expr) => expr ? mapAny(context, expr) : null), RegexFlags.parse(flags));
+}
+
+// src/mappers/mapCSX.ts
+var import_nodes10 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+function mapCSX(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const [properties, children] = node.args;
+  const mappedProperties = mapCSXProperties(context, properties);
+  const mappedChildren = mapCSXChildren(context, children);
+  return new CSXElement(line, column, start, end, raw, mappedProperties, mappedChildren);
+}
+function mapCSXProperties(context, properties) {
+  if (!(properties instanceof import_nodes10.Value) || !(properties.base instanceof import_nodes10.Arr)) {
+    throw new Error("Expected a value for the CSX properties arg.");
+  }
+  const values = properties.base.objects;
+  const resultProperties = [];
+  for (const value of values) {
+    if (!(value instanceof import_nodes10.Value)) {
+      throw new Error("Expected value for CSX property.");
+    }
+    if (value.base instanceof import_nodes10.Obj) {
+      for (const propertyAssignment of value.base.objects) {
+        if (propertyAssignment instanceof import_nodes10.Splat) {
+          resultProperties.push(mapAny(context, propertyAssignment));
+        } else if (propertyAssignment instanceof import_nodes10.Assign) {
+          if (!(propertyAssignment.value instanceof import_nodes10.Value)) {
+            throw new Error("Unexpected property assignment value.");
+          }
+          if (!(propertyAssignment.value.base instanceof import_nodes10.StringLiteral)) {
+            resultProperties.push(mapAny(context, propertyAssignment.value));
+          }
+        } else {
+          throw new Error("Unexpected property assignment object field in CSX.");
+        }
+      }
+    } else if (value.base instanceof import_nodes10.IdentifierLiteral) {
+    } else {
+      throw new Error("Unexpected property assignment in CSX.");
+    }
+  }
+  return resultProperties;
+}
+function mapCSXChildren(context, children) {
+  if (!children) {
+    return [];
+  }
+  if (!(children instanceof import_nodes10.Value)) {
+    throw new Error("Expected a value for the CSX children arg.");
+  }
+  if (children.base instanceof import_nodes10.StringLiteral) {
+    return [];
+  } else if (!(children.base instanceof import_nodes10.StringWithInterpolations)) {
+    throw new Error("Expected a valid CSX children arg.");
+  }
+  const childInterpolatedString = children.base.body.expressions[0];
+  const { unmappedExpressions } = getTemplateLiteralComponents(context, childInterpolatedString);
+  return unmappedExpressions.map((child) => child ? mapAny(context, child) : null);
+}
+
+// src/mappers/mapCall.ts
+function mapCall(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (node.csx) {
+    return mapCSX(context, node);
+  }
+  if (isHeregexTemplateNode(node, context)) {
+    const firstArg = node.args[0];
+    if (!(firstArg instanceof import_nodes12.Value) || !(firstArg.base instanceof import_nodes12.StringWithInterpolations)) {
+      throw new Error("Expected a valid first heregex arg in the AST.");
+    }
+    const strNode = firstArg.base.body.expressions[0];
+    let flags;
+    if (node.args.length > 1) {
+      const secondArg = node.args[1];
+      if (!(secondArg instanceof import_nodes12.Value) || !(secondArg.base instanceof import_nodes12.Literal)) {
+        throw new Error("Expected a string flags value in the heregex AST.");
+      }
+      flags = parseString(secondArg.base.value);
+    } else {
+      flags = "";
+    }
+    return makeHeregex(context, strNode, flags);
+  }
+  const args = node.args.map((arg) => mapAny(context, arg));
+  if (node instanceof import_nodes12.SuperCall) {
+    if (node.args.length === 1 && node.args[0] instanceof import_nodes12.Splat && locationsEqual(node.args[0].locationData, node.locationData)) {
+      return new BareSuperFunctionApplication(line, column, start, end, raw);
+    }
+    const superIndex = context.sourceTokens.indexOfTokenStartingAtSourceIndex(start);
+    const superToken = superIndex && context.sourceTokens.tokenAtIndex(superIndex);
+    if (!superToken || superToken.type !== import_coffee_lex5.SourceType.SUPER) {
+      throw new Error(`unable to find SUPER token in 'super' function call: ${(0, import_util3.inspect)(node)}`);
+    }
+    const superLocation = context.linesAndColumns.locationForIndex(superToken.start);
+    if (!superLocation) {
+      throw new Error(`unable to locate SUPER token for 'super' function call: ${(0, import_util3.inspect)(node)}`);
+    }
+    return new FunctionApplication(line, column, start, end, raw, new Super(superLocation.line + 1, superLocation.column + 1, superToken.start, superToken.end, context.source.slice(superToken.start, superToken.end)), args);
+  }
+  if (!node.variable) {
+    throw new Error("Expected non-super call to have a variable defined.");
+  }
+  const callee = mapAny(context, node.variable);
+  if (node.isNew) {
+    return mapNewOp(context, node);
+  }
+  if (node.soak) {
+    return new SoakedFunctionApplication(line, column, start, end, raw, callee, args);
+  }
+  if (node.do) {
+    return mapDoOp(context, node);
+  }
+  return new FunctionApplication(line, column, start, end, raw, callee, args);
+}
+function mapNewOp(context, node) {
+  if (!node.variable) {
+    throw new UnsupportedNodeError(node);
+  }
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const callee = mapAny(context, node.variable);
+  const args = node.args.map((arg) => mapAny(context, arg));
+  if (node.soak) {
+    return new SoakedNewOp(line, column, start, end, raw, callee, args);
+  } else {
+    return new NewOp(line, column, start, end, raw, callee, args);
+  }
+}
+function mapDoOp(context, node) {
+  if (!node.variable) {
+    throw new UnsupportedNodeError(node);
+  }
+  const { line, column, start, end, raw } = getLocation(context, node);
+  let expression = mapAny(context, node.variable);
+  const args = node.args.map((arg) => mapAny(context, arg));
+  if (expression instanceof BaseFunction) {
+    expression = augmentDoFunctionWithArgs(context, expression, args);
+  } else if (expression instanceof AssignOp && expression.expression instanceof BaseFunction) {
+    const newRhs = augmentDoFunctionWithArgs(context, expression.expression, args);
+    expression = expression.withExpression(newRhs);
+  }
+  return new DoOp(line, column, start, end, raw, expression);
+}
+function augmentDoFunctionWithArgs(context, func, args) {
+  const newParameters = func.parameters.map((param, i) => {
+    const arg = args[i];
+    if (arg instanceof Identifier && param instanceof Identifier && arg.data === param.data && arg.start === param.start && arg.end === param.end) {
+      return param;
+    }
+    return new DefaultParam(param.line, param.column, param.start, arg.end, context.source.slice(param.start, arg.end), param, arg);
+  });
+  return func.withParameters(newParameters);
+}
+
+// src/mappers/mapClass.ts
+function mapClass(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const nameAssignee = node.variable ? mapAny(context, node.variable) : null;
+  const parent = node.parent ? mapAny(context, node.parent) : null;
+  const childContext = context.updateState((s) => s.pushCurrentClass());
+  const body = mapPossiblyEmptyBlock(childContext, node.body);
+  const boundMethods = childContext.parseState.currentClassBoundMethods;
+  if (!boundMethods) {
+    throw new Error("Expected a non-null bound method name array.");
+  }
+  return new Class(line, column, start, end, raw, nameAssignee, nameAssignee, body, boundMethods, parent, childContext.parseState.currentClassCtor);
+}
+
+// src/mappers/mapCode.ts
+function mapCode(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const Node12 = getNodeTypeForCode(node);
+  const childContext = context.updateState((s) => s.dropCurrentClass());
+  return new Node12(line, column, start, end, raw, node.params.map((param) => mapAny(childContext, param)), mapPossiblyEmptyBlock(childContext, node.body));
+}
+function getNodeTypeForCode(node) {
+  if (node.isGenerator) {
+    if (node.bound) {
+      return BoundGeneratorFunction;
+    } else {
+      return GeneratorFunction;
+    }
+  } else if (node.isAsync) {
+    if (node.bound) {
+      return BoundAsyncFunction;
+    } else {
+      return AsyncFunction;
+    }
+  } else {
+    if (node.bound) {
+      return BoundFunction;
+    } else {
+      return Function;
+    }
+  }
+}
+
+// src/mappers/mapComputedPropertyName.ts
+function mapComputedPropertyName(context, node) {
+  return mapAny(context, node.value);
+}
+
+// src/mappers/mapElision.ts
+function mapElision(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  return new Elision(line, column, start, end, raw);
+}
+
+// src/mappers/mapExistence.ts
+function mapExistence(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  return new UnaryExistsOp(line, column, start, end, raw, mapAny(context, node.expression));
+}
+
+// src/mappers/mapExpansion.ts
+function mapExpansion(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  return new Expansion(line, column, start, end, raw);
+}
+
+// src/mappers/mapExtends.ts
+function mapExtends(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  return new ExtendsOp(line, column, start, end, raw, mapAny(context, node.child), mapAny(context, node.parent));
+}
+
+// src/mappers/mapFor.ts
+function mapFor(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const keyAssignee = node.index ? mapAny(context, node.index) : null;
+  const valAssignee = node.name ? mapAny(context, node.name) : null;
+  let body = mapPossiblyEmptyBlock(context, node.body);
+  const target = mapAny(context, node.source);
+  const filter = node.guard ? mapAny(context, node.guard) : null;
+  if (body && body.start < target.start) {
+    body = body.withInline(true);
+  }
+  if (node.object) {
+    const isOwn = node.own;
+    return new ForOf(line, column, start, end, raw, keyAssignee, valAssignee, target, filter, body, isOwn);
+  } else {
+    if (node.from) {
+      if (keyAssignee) {
+        throw new Error("Unexpected key assignee in for...from.");
+      }
+      return new ForFrom(line, column, start, end, raw, valAssignee, target, filter, body);
+    } else {
+      const step = node.step ? mapAny(context, node.step) : null;
+      return new ForIn(line, column, start, end, raw, keyAssignee, valAssignee, target, filter, body, step);
+    }
+  }
+}
+
+// src/mappers/mapIf.ts
+var import_coffee_lex6 = require("coffee-lex");
+function mapIf(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const condition = mapAny(context, node.condition);
+  let consequent = mapPossiblyEmptyBlock(context, node.body);
+  const alternate = mapPossiblyEmptyBlock(context, node.elseBody);
+  let isUnless = false;
+  let left = null;
+  let right = null;
+  if (consequent && consequent.start < condition.start) {
+    consequent = consequent.withInline(true);
+    left = context.sourceTokens.indexOfTokenEndingAtSourceIndex(consequent.end);
+    right = context.sourceTokens.indexOfTokenStartingAtSourceIndex(condition.start);
+  } else {
+    left = context.sourceTokens.indexOfTokenStartingAtSourceIndex(start);
+    right = context.sourceTokens.indexOfTokenStartingAtSourceIndex(condition.start);
+  }
+  if (left && right) {
+    isUnless = context.sourceTokens.indexOfTokenMatchingPredicate((token) => token.type === import_coffee_lex6.SourceType.IF && context.source.slice(token.start, token.end) === "unless", left, right) !== null;
+  }
+  return new Conditional(line, column, start, end, raw, condition, consequent, alternate, isUnless);
+}
+
+// src/mappers/mapIn.ts
+var import_coffee_lex7 = require("coffee-lex");
+function mapIn(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const left = mapAny(context, node.object);
+  const right = mapAny(context, node.array);
+  let isNot = false;
+  const lastTokenIndexOfLeft = context.sourceTokens.indexOfTokenEndingAtSourceIndex(left.end);
+  const firstTokenIndexOfRight = context.sourceTokens.indexOfTokenStartingAtSourceIndex(right.start);
+  const relationTokenIndex = context.sourceTokens.indexOfTokenMatchingPredicate((token) => token.type === import_coffee_lex7.SourceType.RELATION, lastTokenIndexOfLeft, firstTokenIndexOfRight);
+  if (relationTokenIndex) {
+    const relationToken = context.sourceTokens.tokenAtIndex(relationTokenIndex);
+    if (relationToken) {
+      isNot = context.source.slice(relationToken.start, relationToken.end) !== "in";
+      return new InOp(line, column, start, end, raw, left, right, isNot);
+    }
+  }
+  throw new Error(`unable to find RELATION token between operands`);
+}
+
+// src/mappers/mapLiteral.ts
+var import_nodes23 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+
+// src/util/makeString.ts
+function makeString(context, node) {
+  const { quasis, unmappedExpressions, start, end } = getTemplateLiteralComponents(context, node);
+  const startLoc = context.linesAndColumns.locationForIndex(start);
+  if (!startLoc) {
+    throw new Error(`Expected to find a location for index ${start}.`);
+  }
+  const raw = context.source.slice(start, end);
+  return new String(startLoc.line + 1, startLoc.column + 1, start, end, raw, quasis, unmappedExpressions.map((expr) => expr ? mapAny(context, expr) : null));
+}
+
+// src/util/parseNumber.ts
+var import_parser2 = require("@codemod/parser");
+function parseNumber(string) {
+  const expressionStatement = (0, import_parser2.parse)(`(${string})`).program.body[0];
+  const literal = expressionStatement.expression;
+  return literal.value;
+}
+
+// src/util/parseRegExp.ts
+var import_parser3 = require("@codemod/parser");
+function parseRegExp(string) {
+  const expressionStatement = (0, import_parser3.parse)(`(${string})`).program.body[0];
+  const literal = expressionStatement.expression;
+  return literal;
+}
+
+// src/mappers/mapLiteral.ts
+var HEREGEX_PATTERN = /^\/\/\/((?:.|\s)*)\/\/\/([gimuy]*)$/;
+function mapLiteral(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (node instanceof import_nodes23.ThisLiteral) {
+    return new This(line, column, start, end, raw);
+  } else if (node instanceof import_nodes23.NullLiteral) {
+    return new Null(line, column, start, end, raw);
+  } else if (node instanceof import_nodes23.UndefinedLiteral) {
+    return new Undefined(line, column, start, end, raw);
+  } else if (node instanceof import_nodes23.BooleanLiteral) {
+    return new Bool(line, column, start, end, raw, JSON.parse(node.value));
+  } else if (node instanceof import_nodes23.IdentifierLiteral || node instanceof import_nodes23.PropertyName) {
+    const value = node.value.valueOf();
+    return new Identifier(line, column, start, end, raw, value);
+  } else if (node instanceof import_nodes23.PassthroughLiteral) {
+    return new JavaScript(line, column, start, end, raw, node.value);
+  } else if (node instanceof import_nodes23.NumberLiteral) {
+    if (raw.includes(".")) {
+      return new Float(line, column, start, end, raw, parseNumber(node.value));
+    } else {
+      return new Int(line, column, start, end, raw, parseNumber(node.value));
+    }
+  } else if (node instanceof import_nodes23.RegexLiteral) {
+    const heregexMatch = raw.match(HEREGEX_PATTERN);
+    if (heregexMatch) {
+      const flags = heregexMatch[2];
+      return makeHeregex(context, node, flags);
+    } else {
+      const regExp = parseRegExp(node.value);
+      return new Regex(line, column, start, end, raw, regExp.pattern, RegexFlags.parse(regExp.flags || ""));
+    }
+  } else if (node instanceof import_nodes23.StringLiteral) {
+    return makeString(context, node);
+  } else if (node instanceof import_nodes23.StatementLiteral) {
+    if (node.value === "break") {
+      return new Break(line, column, start, end, raw);
+    } else if (node.value === "continue") {
+      return new Continue(line, column, start, end, raw);
+    } else if (node.value === "debugger") {
+      return new Debugger(line, column, start, end, raw);
+    }
+  }
+  throw new Error(`Unexpected literal: ${JSON.stringify(node)}`);
+}
+
+// src/mappers/mapModuleDeclaration.ts
+var import_nodes25 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+
+// src/util/notNull.ts
+function notNull(value) {
+  if (typeof value === "undefined" || value === null) {
+    throw new Error(`expected value not to be null/undefined: ${value}`);
+  }
+  return value;
+}
+
+// src/mappers/mapModuleDeclaration.ts
+function mapModuleDeclaration(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (node instanceof import_nodes25.ImportDeclaration) {
+    const clause = node.clause;
+    let defaultBinding = null;
+    let namespaceImport = null;
+    let namedImports = null;
+    if (clause) {
+      defaultBinding = clause.defaultBinding && mapIdentifierSpecifier(context, clause.defaultBinding);
+      if (clause.namedImports instanceof import_nodes25.ImportNamespaceSpecifier) {
+        namespaceImport = mapStarSpecifier(context, clause.namedImports);
+      } else if (clause.namedImports instanceof import_nodes25.ImportSpecifierList) {
+        namedImports = clause.namedImports.specifiers.map((specifier) => mapSpecifier(context, specifier));
+      }
+    }
+    if (!node.source) {
+      throw new Error("Expected non-null source for import.");
+    }
+    const source = mapSource(context, node.source);
+    return new ImportDeclaration(line, column, start, end, raw, defaultBinding, namespaceImport, namedImports, source);
+  } else if (node instanceof import_nodes25.ExportNamedDeclaration) {
+    if (node.clause instanceof import_nodes25.ExportSpecifierList) {
+      const namedExports = node.clause.specifiers.map((specifier) => mapSpecifier(context, specifier));
+      const source = node.source ? mapSource(context, node.source) : null;
+      return new ExportBindingsDeclaration(line, column, start, end, raw, namedExports, source);
+    } else {
+      const expression = mapAny(context, notNull(node.clause));
+      return new ExportNamedDeclaration(line, column, start, end, raw, expression);
+    }
+  } else if (node instanceof import_nodes25.ExportDefaultDeclaration) {
+    const expression = mapAny(context, notNull(node.clause));
+    return new ExportDefaultDeclaration(line, column, start, end, raw, expression);
+  } else if (node instanceof import_nodes25.ExportAllDeclaration) {
+    if (!node.source) {
+      throw new Error("Expected non-null source for star export.");
+    }
+    const source = mapSource(context, node.source);
+    return new ExportAllDeclaration(line, column, start, end, raw, source);
+  } else {
+    throw new UnsupportedNodeError(node);
+  }
+}
+function mapSource(context, coffeeSource) {
+  const source = mapLiteral(context, coffeeSource);
+  if (!(source instanceof String)) {
+    throw new Error("Expected string literal as import source.");
+  }
+  return source;
+}
+function mapIdentifierSpecifier(context, specifier) {
+  if (specifier.alias) {
+    throw new Error("Expected no alias for identifier specifier.");
+  }
+  return mapLiteralToIdentifier(context, specifier.original);
+}
+function mapStarSpecifier(context, specifier) {
+  if (specifier.original.value !== "*") {
+    throw new Error("Expected a star on the LHS of a star specifier.");
+  }
+  if (!specifier.alias) {
+    throw new Error("Expected node on the RHS of star specifier.");
+  }
+  return mapLiteralToIdentifier(context, specifier.alias);
+}
+function mapSpecifier(context, specifier) {
+  const { line, column, start, end, raw } = getLocation(context, specifier);
+  const original = mapLiteralToIdentifier(context, specifier.original);
+  const alias = specifier.alias ? mapLiteralToIdentifier(context, specifier.alias) : null;
+  return new ModuleSpecifier(line, column, start, end, raw, original, alias);
+}
+function mapLiteralToIdentifier(context, literal) {
+  if (literal instanceof import_nodes25.IdentifierLiteral) {
+    return mapLiteral(context, literal);
+  } else if (literal.constructor === import_nodes25.Literal) {
+    const { line, column, start, end, raw } = getLocation(context, literal);
+    return new Identifier(line, column, start, end, raw, literal.value);
+  } else {
+    throw new Error("Expected identifier in module declaration.");
+  }
+}
+
+// src/mappers/mapObj.ts
+var import_nodes28 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+
+// src/mappers/mapValue.ts
+var import_coffee_lex8 = require("coffee-lex");
+var import_nodes26 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+var import_util4 = require("util");
+function mapValue(context, node) {
+  const location = getLocation(context, node);
+  return node.properties.reduce((reduced, property) => reduceProperty(context, location, reduced, property), mapAny(context, node.base));
+}
+function reduceProperty(context, location, reduced, property) {
+  if (property instanceof import_nodes26.Access) {
+    const name = property.name;
+    if (!(name instanceof import_nodes26.Literal)) {
+      throw new Error(`unexpected non-Literal property access name: ${(0, import_util4.inspect)(name)}`);
+    }
+    let startTokenIndex = tokenIndexAtLocation(context, property.locationData);
+    let startToken = startTokenIndex && context.sourceTokens.tokenAtIndex(startTokenIndex);
+    if (startToken && property.soak) {
+      if (startToken.type !== import_coffee_lex8.SourceType.EXISTENCE) {
+        throw new Error(`expected EXISTENCE token ('?') but got ${import_coffee_lex8.SourceType[startToken.type]}: ${(0, import_util4.inspect)(startToken)}`);
+      }
+      startTokenIndex = startTokenIndex && startTokenIndex.next();
+      startToken = startTokenIndex && context.sourceTokens.tokenAtIndex(startTokenIndex);
+    }
+    if (!startToken) {
+      throw new Error(`cannot find token at start of property: ${(0, import_util4.inspect)(property)}`);
+    }
+    const last = context.linesAndColumns.indexForLocation({
+      line: property.locationData.last_line,
+      column: property.locationData.last_column
+    });
+    if (last === null) {
+      throw new Error(`cannot find offset of last character of property: ${(0, import_util4.inspect)(property)}`);
+    }
+    const isPrototypeAccess = startToken.type === import_coffee_lex8.SourceType.PROTO;
+    if (isPrototypeAccess) {
+      const AccessOp2 = property.soak ? SoakedProtoMemberAccessOp : ProtoMemberAccessOp;
+      return new AccessOp2(location.line, location.column, location.start, last + 1, context.source.slice(location.start, last + 1), reduced);
+    } else {
+      const member = mapAny(context, name);
+      if (!(member instanceof Identifier)) {
+        throw new Error(`unexpected non-Identifier access member: ${(0, import_util4.inspect)(member)}`);
+      }
+      const AccessOp2 = property.soak ? SoakedMemberAccessOp : MemberAccessOp;
+      return new AccessOp2(location.line, location.column, location.start, last + 1, context.source.slice(location.start, last + 1), reduced, member);
+    }
+  } else if (property instanceof import_nodes26.Index) {
+    const NodeClass = property.soak ? SoakedDynamicMemberAccessOp : DynamicMemberAccessOp;
+    const last = context.linesAndColumns.indexForLocation({
+      line: property.locationData.last_line,
+      column: property.locationData.last_column
+    });
+    if (last === null) {
+      throw new Error(`cannot find offset of last character of index: ${(0, import_util4.inspect)(property)}`);
+    }
+    return new NodeClass(location.line, location.column, location.start, last + 1, context.source.slice(location.start, last + 1), reduced, mapAny(context, property.index));
+  } else if (property instanceof import_nodes26.Slice) {
+    const last = context.linesAndColumns.indexForLocation({
+      line: property.locationData.last_line,
+      column: property.locationData.last_column
+    });
+    if (last === null) {
+      throw new Error(`cannot find offset of last character of slice: ${(0, import_util4.inspect)(property)}`);
+    }
+    const SliceClass = property.soak ? SoakedSlice : Slice;
+    return new SliceClass(location.line, location.column, location.start, last + 1, context.source.slice(location.start, last + 1), reduced, property.range.from ? mapAny(context, property.range.from) : null, property.range.to ? mapAny(context, property.range.to) : null, !property.range.exclusive);
+  } else {
+    throw new UnsupportedNodeError(property, "Unexpected property access.");
+  }
+}
+function tokenIndexAtLocation(context, location) {
+  const start = context.linesAndColumns.indexForLocation({
+    line: location.first_line,
+    column: location.first_column
+  });
+  if (start === null) {
+    return null;
+  }
+  return context.sourceTokens.indexOfTokenContainingSourceIndex(start);
+}
+
+// src/mappers/mapObj.ts
+function mapObj(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const members = [];
+  for (const property of node.properties) {
+    if (isCommentOnlyNode(property)) {
+      continue;
+    }
+    const { line: line2, column: column2, start: start2, end: end2, raw: raw2 } = getLocation(context, property);
+    if (property instanceof import_nodes28.Value) {
+      const value = mapValue(context, property);
+      const isComputed = property.base instanceof import_nodes28.ComputedPropertyName;
+      members.push(new ObjectInitialiserMember(line2, column2, start2, end2, raw2, value, null, isComputed));
+    } else if (property instanceof import_nodes28.Assign && property.context === "object") {
+      const key = mapAny(context, property.variable);
+      const expression = mapAny(context, property.value);
+      const isComputed = property.variable instanceof import_nodes28.Value && property.variable.base instanceof import_nodes28.ComputedPropertyName;
+      members.push(new ObjectInitialiserMember(line2, column2, start2, end2, raw2, key, expression, isComputed));
+    } else if (property instanceof import_nodes28.Assign) {
+      const assignee = mapAny(context, property.variable);
+      const expression = mapAny(context, property.value);
+      members.push(new AssignOp(line2, column2, start2, end2, raw2, assignee, expression));
+    } else if (property instanceof import_nodes28.Splat) {
+      members.push(new Spread(line2, column2, start2, end2, raw2, mapAny(context, property.name)));
+    } else {
+      throw new UnsupportedNodeError(property, "Unexpected object member.");
+    }
+  }
+  return new ObjectInitialiser(line, column, start, end, raw, members);
+}
+
+// src/mappers/mapOp.ts
+var import_coffee_lex10 = require("coffee-lex");
+var import_nodes34 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+var import_util6 = require("util");
+
+// src/util/getOperatorInfoInRange.ts
+var import_coffee_lex9 = require("coffee-lex");
+function getOperatorInfoInRange(context, start, end) {
+  const startIndex = context.sourceTokens.indexOfTokenNearSourceIndex(start);
+  const endIndex = context.sourceTokens.indexOfTokenNearSourceIndex(end);
+  if (!startIndex || !endIndex) {
+    throw new Error(`cannot find token indexes of range bounds: [${start}, ${end}]`);
+  }
+  const operatorIndex = context.sourceTokens.indexOfTokenMatchingPredicate((token) => token.type !== import_coffee_lex9.SourceType.LPAREN && token.type !== import_coffee_lex9.SourceType.RPAREN, startIndex.next(), endIndex);
+  const operatorToken = operatorIndex && context.sourceTokens.tokenAtIndex(operatorIndex);
+  if (!operatorToken) {
+    throw new Error(`cannot find operator token in range: [${start}, ${end}]`);
+  }
+  return new OperatorInfo(context.source.slice(operatorToken.start, operatorToken.end), operatorToken);
+}
+
+// src/util/isChainedComparison.ts
+var import_nodes32 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+
+// src/util/isComparisonOperator.ts
+var import_nodes31 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+function isComparisonOperator(node) {
+  if (!(node instanceof import_nodes31.Op)) {
+    return false;
+  }
+  switch (node.operator) {
+    case "<":
+    case ">":
+    case "<=":
+    case ">=":
+    case "===":
+    case "!==":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/util/isChainedComparison.ts
+function isChainedComparison(node) {
+  if (node instanceof import_nodes32.Op && isComparisonOperator(node)) {
+    return isComparisonOperator(node.first) || (node.second ? isComparisonOperator(node.second) : false);
+  } else {
+    return false;
+  }
+}
+
+// src/util/unwindChainedComparison.ts
+var import_nodes33 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+var import_util5 = require("util");
+function unwindChainedComparison(node) {
+  let operands = [];
+  for (let link = node; ; ) {
+    if (link instanceof import_nodes33.Op && isComparisonOperator(link)) {
+      const { first, second } = link;
+      if (!second) {
+        throw new Error(`unexpected unary operator inside chained comparison: ${(0, import_util5.inspect)(node)}`);
+      }
+      operands = [second, ...operands];
+      link = first;
+    } else {
+      operands = [link, ...operands];
+      break;
+    }
+  }
+  return operands;
+}
+
+// src/mappers/mapOp.ts
+function mapOp(context, node) {
+  if (isChainedComparison(node)) {
+    return mapChainedComparisonOp(context, node);
+  } else {
+    return mapOpWithoutChainedComparison(context, node);
+  }
+}
+function mapChainedComparisonOp(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const coffeeOperands = unwindChainedComparison(node);
+  const operands = coffeeOperands.map((operand) => mapAny(context, operand));
+  const operators = [];
+  for (let i = 0; i < operands.length - 1; i++) {
+    const left = operands[i];
+    const right = operands[i + 1];
+    operators.push(getOperatorInfoInRange(context, left.end - 1, right.start));
+  }
+  return new ChainedComparisonOp(line, column, start, end, raw, operands, operators);
+}
+function mapOpWithoutChainedComparison(context, node) {
+  switch (node.operator) {
+    case "===":
+      return mapBinaryOp(context, node, EQOp);
+    case "!==":
+      return mapBinaryOp(context, node, NEQOp);
+    case "!":
+      return mapUnaryOp(context, node, LogicalNotOp);
+    case "+":
+      return mapPlusOp(context, node);
+    case "-":
+      return mapBinaryOrUnaryOp(context, node, SubtractOp, UnaryNegateOp);
+    case "&&":
+      return mapBinaryOp(context, node, LogicalAndOp);
+    case "||":
+      return mapBinaryOp(context, node, LogicalOrOp);
+    case "*":
+      return mapBinaryOp(context, node, MultiplyOp);
+    case "/":
+      return mapBinaryOp(context, node, DivideOp);
+    case "//":
+      return mapBinaryOp(context, node, FloorDivideOp);
+    case "?":
+      return mapBinaryOp(context, node, ExistsOp);
+    case "<":
+      return mapBinaryOp(context, node, LTOp);
+    case "<=":
+      return mapBinaryOp(context, node, LTEOp);
+    case ">":
+      return mapBinaryOp(context, node, GTOp);
+    case ">=":
+      return mapBinaryOp(context, node, GTEOp);
+    case "++":
+      return mapUnaryOp(context, node, node.flip ? PostIncrementOp : PreIncrementOp);
+    case "--":
+      return mapUnaryOp(context, node, node.flip ? PostDecrementOp : PreDecrementOp);
+    case "typeof":
+      return mapUnaryOp(context, node, TypeofOp);
+    case "instanceof":
+      return mapNegateableBinaryOp(context, node, InstanceofOp);
+    case "delete":
+      return mapUnaryOp(context, node, DeleteOp);
+    case "in":
+      return mapNegateableBinaryOp(context, node, OfOp);
+    case "new":
+      return mapNewOp2(context, node);
+    case "**":
+      return mapBinaryOp(context, node, ExpOp);
+    case "%":
+      return mapBinaryOp(context, node, RemOp);
+    case "%%":
+      return mapBinaryOp(context, node, ModuloOp);
+    case "&":
+      return mapBinaryOp(context, node, BitAndOp);
+    case "|":
+      return mapBinaryOp(context, node, BitOrOp);
+    case "^":
+      return mapBinaryOp(context, node, BitXorOp);
+    case "<<":
+      return mapBinaryOp(context, node, LeftShiftOp);
+    case ">>":
+      return mapBinaryOp(context, node, SignedRightShiftOp);
+    case ">>>":
+      return mapBinaryOp(context, node, UnsignedRightShiftOp);
+    case "~":
+      return mapUnaryOp(context, node, BitNotOp);
+    case "yield":
+      return mapYieldOp(context, node);
+    case "yield*":
+      return mapUnaryOp(context, node, YieldFrom);
+    case "await":
+      return mapUnaryOp(context, node, Await);
+  }
+  throw new UnsupportedNodeError(node);
+}
+function mapPlusOp(context, node) {
+  if (node.second) {
+    if (isImplicitPlusOp(node, context)) {
+      return makeString(context, node);
+    } else {
+      return mapBinaryOp(context, node, PlusOp);
+    }
+  }
+  return mapUnaryOp(context, node, UnaryPlusOp);
+}
+function mapNewOp2(context, node) {
+  if (node.second) {
+    throw new Error(`unexpected 'new' operator with multiple operands: ${(0, import_util6.inspect)(node)}`);
+  }
+  const { line, column, start, end, raw } = getLocation(context, node);
+  return new NewOp(line, column, start, end, raw, mapAny(context, node.first), []);
+}
+function mapYieldOp(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (isBareYield(node)) {
+    return new Yield(line, column, start, end, raw, null);
+  } else {
+    return new Yield(line, column, start, end, raw, mapAny(context, node.first));
+  }
+}
+function isBareYield(node) {
+  return node.first instanceof import_nodes34.Value && node.first.base instanceof import_nodes34.Literal && node.first.base.value === "";
+}
+function mapBinaryOp(context, node, Op10) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (!node.second) {
+    throw new Error(`unexpected '${node.operator}' operator with only one operand: ${(0, import_util6.inspect)(node)}`);
+  }
+  return new Op10(line, column, start, end, raw, mapAny(context, node.first), mapAny(context, node.second));
+}
+function mapUnaryOp(context, node, Op10) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (node.second) {
+    throw new Error(`unexpected '${node.operator}' operator with two operands: ${(0, import_util6.inspect)(node)}`);
+  }
+  return new Op10(line, column, start, end, raw, mapAny(context, node.first));
+}
+function mapBinaryOrUnaryOp(context, node, BinaryOp2, UnaryOp3) {
+  if (node.second) {
+    return mapBinaryOp(context, node, BinaryOp2);
+  } else {
+    return mapUnaryOp(context, node, UnaryOp3);
+  }
+}
+var TemporaryBinaryOp = class extends BinaryOp {
+  constructor(line, column, start, end, raw, left, right) {
+    super("TEMPORARY", line, column, start, end, raw, left, right);
+  }
+};
+function tokenStartsWith(prefix, context, token) {
+  return context.source.slice(token.start, token.start + prefix.length) === prefix;
+}
+function mapNegateableBinaryOp(context, node, Op10) {
+  const { line, column, start, end, raw, left, right } = mapBinaryOp(context, node, TemporaryBinaryOp);
+  const lastTokenIndexOfLeft = context.sourceTokens.indexOfTokenEndingAtSourceIndex(left.end);
+  const firstTokenIndexOfRight = context.sourceTokens.indexOfTokenStartingAtSourceIndex(right.start);
+  let isNot = false;
+  if (lastTokenIndexOfLeft) {
+    for (let i = lastTokenIndexOfLeft.next(); i && i !== firstTokenIndexOfRight; i = i.next()) {
+      const token = context.sourceTokens.tokenAtIndex(i);
+      if (token && (token.type === import_coffee_lex10.SourceType.OPERATOR || token.type === import_coffee_lex10.SourceType.RELATION)) {
+        isNot = tokenStartsWith("not", context, token) || tokenStartsWith("!", context, token);
+        break;
+      }
+    }
+  }
+  return new Op10(line, column, start, end, raw, left, right, isNot);
+}
+
+// src/mappers/mapParam.ts
+function mapParam(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const param = mapAny(context, node.name);
+  if (node.value) {
+    const value = mapAny(context, node.value);
+    return new DefaultParam(line, column, start, end, raw, param, value);
+  }
+  if (node.splat) {
+    return new Rest(line, column, start, end, raw, param);
+  }
+  return param;
+}
+
+// src/mappers/mapParens.ts
+var import_nodes37 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+function mapParens(context, node) {
+  if (!(node.body instanceof import_nodes37.Block)) {
+    return mapAny(context, node.body);
+  }
+  let { expressions } = node.body;
+  expressions = expressions.filter((expr) => !isCommentOnlyNode(expr));
+  if (expressions.length === 1) {
+    return mapAny(context, expressions[0]);
+  }
+  return expressions.map((expression) => mapAny(context, expression)).reduceRight((right, left) => new SeqOp(left.line, left.column, left.start, right.end, context.source.slice(left.start, right.end), left, right));
+}
+
+// src/mappers/mapRange.ts
+var import_util7 = require("util");
+function mapRange(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (!node.from || !node.to) {
+    throw new Error(`'from' or 'to' unexpectedly missing: ${(0, import_util7.inspect)(node)}`);
+  }
+  return new Range(line, column, start, end, raw, mapAny(context, node.from), mapAny(context, node.to), !node.exclusive);
+}
+
+// src/mappers/mapReturn.ts
+var import_nodes40 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+function mapReturn(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const argument = node.expression ? mapAny(context, node.expression) : null;
+  if (node instanceof import_nodes40.YieldReturn) {
+    return new YieldReturn(line, column, start, end, raw, argument);
+  } else if (node instanceof import_nodes40.AwaitReturn) {
+    return new AwaitReturn(line, column, start, end, raw, argument);
+  } else {
+    return new Return(line, column, start, end, raw, argument);
+  }
+}
+
+// src/mappers/mapSplat.ts
+function mapSplat(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  return new Spread(line, column, start, end, raw, mapAny(context, node.name));
+}
+
+// src/mappers/mapSuper.ts
+var import_coffee_lex11 = require("coffee-lex");
+function mapSuper(context, node) {
+  const location = getLocation(context, node);
+  const { line, column, start } = location;
+  const superTokenIndex = context.sourceTokens.indexOfTokenStartingAtSourceIndex(start);
+  if (!superTokenIndex) {
+    throw new Error("Expected token at the start of super node.");
+  }
+  const superToken = context.sourceTokens.tokenAtIndex(superTokenIndex);
+  if (!superToken || superToken.type !== import_coffee_lex11.SourceType.SUPER) {
+    throw new Error("Expected super token at the start of super node.");
+  }
+  const superNode = new Super(line, column, start, superToken.end, context.source.slice(superToken.start, superToken.end));
+  return reduceProperty(context, location, superNode, node.accessor);
+}
+
+// src/mappers/mapSwitch.ts
+var import_coffee_lex12 = require("coffee-lex");
+function mapSwitch(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const expression = node.subject ? mapAny(context, node.subject) : null;
+  const cases = node.cases.map(([conditions, body]) => {
+    if (!Array.isArray(conditions)) {
+      conditions = [conditions];
+    }
+    const switchConditions = conditions.map((condition) => mapAny(context, condition));
+    const consequent = mapPossiblyEmptyBlock(context, body);
+    const whenToken = getWhenTokenBeforeOffset(context, switchConditions[0].start, start);
+    const locationForIndex = context.linesAndColumns.locationForIndex(whenToken.start);
+    if (!locationForIndex) {
+      throw new Error(`cannot map WHEN token start to line/column: ${whenToken.start}`);
+    }
+    const { line: caseLine, column: caseColumn } = locationForIndex;
+    const { end: end2 } = getLocation(context, body);
+    return new SwitchCase(caseLine + 1, caseColumn + 1, whenToken.start, end2, context.source.slice(whenToken.start, end2), switchConditions, consequent);
+  });
+  return new Switch(line, column, start, end, raw, expression, cases, mapPossiblyEmptyBlock(context, node.otherwise));
+}
+function getWhenTokenBeforeOffset(context, offset, lowerBound) {
+  const offsetTokenIndex = context.sourceTokens.indexOfTokenNearSourceIndex(offset);
+  const lowerBoundTokenIndex = context.sourceTokens.indexOfTokenNearSourceIndex(lowerBound);
+  const whenTokenIndex = context.sourceTokens.lastIndexOfTokenMatchingPredicate((token) => token.type === import_coffee_lex12.SourceType.WHEN, offsetTokenIndex, lowerBoundTokenIndex);
+  if (whenTokenIndex) {
+    const whenToken = context.sourceTokens.tokenAtIndex(whenTokenIndex);
+    if (whenToken) {
+      return whenToken;
+    }
+  }
+  throw new Error(`unable to find WHEN token before ${offset} (lower bound: ${lowerBound})`);
+}
+
+// src/mappers/mapTaggedTemplateCall.ts
+function mapTaggedTemplateCall(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  if (!node.variable) {
+    throw new Error("Expected tag in tagged template literal.");
+  }
+  const tag = mapAny(context, node.variable);
+  if (node.args.length !== 1) {
+    throw new Error("Expected tagged template literal call to have exactly one argument.");
+  }
+  const template = mapAny(context, node.args[0]);
+  if (!(template instanceof String)) {
+    throw new Error("Expected tagged template literal argument to be a string.");
+  }
+  return new TaggedTemplateLiteral(line, column, start, end, raw, tag, template);
+}
+
+// src/mappers/mapThrow.ts
+function mapThrow(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const expression = node.expression ? mapAny(context, node.expression) : null;
+  return new Throw(line, column, start, end, raw, expression);
+}
+
+// src/mappers/mapTry.ts
+function mapTry(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  return new Try(line, column, start, end, raw, mapPossiblyEmptyBlock(context, node.attempt), node.errorVariable ? mapAny(context, node.errorVariable) : null, mapPossiblyEmptyBlock(context, node.recovery), mapPossiblyEmptyBlock(context, node.ensure));
+}
+
+// src/mappers/mapWhile.ts
+var import_coffee_lex13 = require("coffee-lex");
+function mapWhile(context, node) {
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const startTokenIndex = context.sourceTokens.indexOfTokenStartingAtSourceIndex(start);
+  const startToken = startTokenIndex && context.sourceTokens.tokenAtIndex(startTokenIndex);
+  if (startToken && startToken.type === import_coffee_lex13.SourceType.LOOP) {
+    return new Loop(line, column, start, end, raw, mapPossiblyEmptyBlock(context, node.body));
+  }
+  const condition = mapAny(context, node.condition);
+  const guard = node.guard ? mapAny(context, node.guard) : null;
+  let body = mapPossiblyEmptyBlock(context, node.body);
+  if (body instanceof Block && body.start < condition.start) {
+    body = body.withInline(true);
+  }
+  return new While(line, column, start, end, raw, condition, guard, body, node.condition.inverted === true);
+}
+
+// src/mappers/mapAny.ts
+function mapAny(context, node) {
+  if (node instanceof import_nodes49.Value) {
+    return mapValue(context, node);
+  }
+  if (node instanceof import_nodes49.ComputedPropertyName) {
+    return mapComputedPropertyName(context, node);
+  }
+  if (node instanceof import_nodes49.Literal) {
+    return mapLiteral(context, node);
+  }
+  if (node instanceof import_nodes49.Op) {
+    return mapOp(context, node);
+  }
+  if (node instanceof import_nodes49.TaggedTemplateCall) {
+    return mapTaggedTemplateCall(context, node);
+  }
+  if (node instanceof import_nodes49.Call) {
+    return mapCall(context, node);
+  }
+  if (node instanceof import_nodes49.Super) {
+    return mapSuper(context, node);
+  }
+  if (node instanceof import_nodes49.Arr) {
+    return mapArr(context, node);
+  }
+  if (node instanceof import_nodes49.Assign) {
+    return mapAssign(context, node);
+  }
+  if (node instanceof import_nodes49.Param) {
+    return mapParam(context, node);
+  }
+  if (node instanceof import_nodes49.Return) {
+    return mapReturn(context, node);
+  }
+  if (node instanceof import_nodes49.If) {
+    return mapIf(context, node);
+  }
+  if (node instanceof import_nodes49.Obj) {
+    return mapObj(context, node);
+  }
+  if (node instanceof import_nodes49.Parens || node instanceof import_nodes49.StringWithInterpolations) {
+    return mapParens(context, node);
+  }
+  if (node instanceof import_nodes49.For) {
+    return mapFor(context, node);
+  }
+  if (node instanceof import_nodes49.Throw) {
+    return mapThrow(context, node);
+  }
+  if (node instanceof import_nodes49.Block) {
+    return mapBlock(context, node);
+  }
+  if (node instanceof import_nodes49.Code) {
+    return mapCode(context, node);
+  }
+  if (node instanceof import_nodes49.While && !(node instanceof import_nodes49.For)) {
+    return mapWhile(context, node);
+  }
+  if (node instanceof import_nodes49.Try) {
+    return mapTry(context, node);
+  }
+  if (node instanceof import_nodes49.Existence) {
+    return mapExistence(context, node);
+  }
+  if (node instanceof import_nodes49.Class) {
+    return mapClass(context, node);
+  }
+  if (node instanceof import_nodes49.Splat) {
+    return mapSplat(context, node);
+  }
+  if (node instanceof import_nodes49.Expansion) {
+    return mapExpansion(context, node);
+  }
+  if (node instanceof import_nodes49.Elision) {
+    return mapElision(context, node);
+  }
+  if (node instanceof import_nodes49.Switch) {
+    return mapSwitch(context, node);
+  }
+  if (node instanceof import_nodes49.In) {
+    return mapIn(context, node);
+  }
+  if (node instanceof import_nodes49.Range) {
+    return mapRange(context, node);
+  }
+  if (node instanceof import_nodes49.Extends) {
+    return mapExtends(context, node);
+  }
+  if (node instanceof import_nodes49.ModuleDeclaration) {
+    return mapModuleDeclaration(context, node);
+  }
+  throw new UnsupportedNodeError(node);
+}
+
+// src/mappers/mapBlock.ts
+function mapBlock(context, node) {
+  let childContext = context;
+  if (context.parseState.isInClassBody()) {
+    const hasProtoAssignChild = node.expressions.some((child) => child instanceof import_nodes50.Value && child.isObject(true));
+    if (hasProtoAssignChild) {
+      childContext = childContext.updateState((s) => s.dropCurrentClass());
+    }
+  }
+  const { line, column, start, end, raw } = getLocation(context, node);
+  const previousTokenIndex = context.sourceTokens.indexOfTokenNearSourceIndex(start).previous();
+  const previousToken = previousTokenIndex ? context.sourceTokens.tokenAtIndex(previousTokenIndex) : null;
+  const inline = previousToken ? previousToken.type !== import_coffee_lex14.SourceType.NEWLINE : false;
+  return new Block(line, column, start, end, raw, node.expressions.filter((expression) => !isCommentOnlyNode(expression)).map((expression) => mapChild(context, childContext, expression)).reduce((arr, current) => arr.concat(current), []), inline);
+}
+function mapChild(blockContext, childContext, node) {
+  if (blockContext.parseState.isInClassBody() && node instanceof import_nodes50.Value && node.isObject(true)) {
+    const obj = node.base;
+    if (!(obj instanceof import_nodes50.Obj)) {
+      throw new Error("Expected isObject node to be an object.");
+    }
+    const statements = [];
+    for (const property of obj.properties) {
+      if (isCommentOnlyNode(property)) {
+        continue;
+      }
+      if (property instanceof import_nodes50.Assign) {
+        const { line, column, start, end, raw } = getLocation(childContext, property);
+        const key = mapAny(childContext, property.variable);
+        const value = mapAny(childContext, property.value);
+        let Node12 = ClassProtoAssignOp;
+        if (key instanceof Identifier && key.data === "constructor") {
+          Node12 = Constructor;
+        } else if (key instanceof MemberAccessOp && key.expression instanceof This) {
+          Node12 = AssignOp;
+        }
+        const assignment = new Node12(line, column, start, end, raw, key, value);
+        statements.push(assignment);
+        if (assignment instanceof ClassProtoAssignOp && (assignment.expression instanceof BoundFunction || assignment.expression instanceof BoundGeneratorFunction || assignment.expression instanceof BoundAsyncFunction)) {
+          blockContext.parseState.recordBoundMethod(assignment);
+        }
+        if (assignment instanceof Constructor) {
+          blockContext.parseState.recordConstructor(assignment);
+        }
+      } else {
+        throw new Error(`unexpected class assignment: ${(0, import_util8.inspect)(property)}`);
+      }
+    }
+    return statements;
+  }
+  return [mapAny(childContext, node)];
+}
+
+// src/mappers/mapPossiblyEmptyBlock.ts
+function mapPossiblyEmptyBlock(context, node) {
+  if (!node) {
+    return null;
+  }
+  if (node.expressions.every((expression) => isCommentOnlyNode(expression))) {
+    return null;
+  }
+  const lastSourceIndex = context.linesAndColumns.indexForLocation({
+    line: node.locationData.last_line,
+    column: node.locationData.last_column
+  });
+  if (lastSourceIndex === null) {
+    throw new Error("Expected to find last source index of block.");
+  }
+  if (context.source[lastSourceIndex] === ";") {
+    return mapBlock(context, node);
+  }
+  if (node.expressions.length === 0) {
+    return null;
+  }
+  return mapBlock(context, node);
+}
+
+// src/mappers/mapProgram.ts
+function mapProgram(context) {
+  return new Program(1, 1, 0, context.source.length, context.source, mapPossiblyEmptyBlock(context, context.ast), context);
+}
+
+// src/parseCS1AsCS2.ts
+var import_decaffeinate_coffeescript = require("decaffeinate-coffeescript");
+var import_nodes53 = require("decaffeinate-coffeescript/lib/coffee-script/nodes.js");
+var import_nodes54 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+var nodeTypeMap = /* @__PURE__ */ new Map();
+nodeTypeMap.set(import_nodes53.Base, import_nodes54.Base);
+nodeTypeMap.set(import_nodes53.Block, import_nodes54.Block);
+nodeTypeMap.set(import_nodes53.Literal, import_nodes54.Literal);
+nodeTypeMap.set(import_nodes53.NumberLiteral, import_nodes54.NumberLiteral);
+nodeTypeMap.set(import_nodes53.InfinityLiteral, import_nodes54.InfinityLiteral);
+nodeTypeMap.set(import_nodes53.NaNLiteral, import_nodes54.NaNLiteral);
+nodeTypeMap.set(import_nodes53.StringLiteral, import_nodes54.StringLiteral);
+nodeTypeMap.set(import_nodes53.RegexLiteral, import_nodes54.RegexLiteral);
+nodeTypeMap.set(import_nodes53.PassthroughLiteral, import_nodes54.PassthroughLiteral);
+nodeTypeMap.set(import_nodes53.IdentifierLiteral, import_nodes54.IdentifierLiteral);
+nodeTypeMap.set(import_nodes53.PropertyName, import_nodes54.PropertyName);
+nodeTypeMap.set(import_nodes53.StatementLiteral, import_nodes54.StatementLiteral);
+nodeTypeMap.set(import_nodes53.ThisLiteral, import_nodes54.ThisLiteral);
+nodeTypeMap.set(import_nodes53.UndefinedLiteral, import_nodes54.UndefinedLiteral);
+nodeTypeMap.set(import_nodes53.NullLiteral, import_nodes54.NullLiteral);
+nodeTypeMap.set(import_nodes53.BooleanLiteral, import_nodes54.BooleanLiteral);
+nodeTypeMap.set(import_nodes53.Return, import_nodes54.Return);
+nodeTypeMap.set(import_nodes53.YieldReturn, import_nodes54.YieldReturn);
+nodeTypeMap.set(import_nodes53.Value, import_nodes54.Value);
+nodeTypeMap.set(import_nodes53.Call, import_nodes54.Call);
+nodeTypeMap.set(import_nodes53.SuperCall, import_nodes54.SuperCall);
+nodeTypeMap.set(import_nodes53.RegexWithInterpolations, import_nodes54.RegexWithInterpolations);
+nodeTypeMap.set(import_nodes53.TaggedTemplateCall, import_nodes54.TaggedTemplateCall);
+nodeTypeMap.set(import_nodes53.Extends, import_nodes54.Extends);
+nodeTypeMap.set(import_nodes53.Access, import_nodes54.Access);
+nodeTypeMap.set(import_nodes53.Index, import_nodes54.Index);
+nodeTypeMap.set(import_nodes53.Range, import_nodes54.Range);
+nodeTypeMap.set(import_nodes53.Slice, import_nodes54.Slice);
+nodeTypeMap.set(import_nodes53.Obj, import_nodes54.Obj);
+nodeTypeMap.set(import_nodes53.Arr, import_nodes54.Arr);
+nodeTypeMap.set(import_nodes53.Class, import_nodes54.Class);
+nodeTypeMap.set(import_nodes53.ModuleDeclaration, import_nodes54.ModuleDeclaration);
+nodeTypeMap.set(import_nodes53.ImportDeclaration, import_nodes54.ImportDeclaration);
+nodeTypeMap.set(import_nodes53.ImportClause, import_nodes54.ImportClause);
+nodeTypeMap.set(import_nodes53.ExportDeclaration, import_nodes54.ExportDeclaration);
+nodeTypeMap.set(import_nodes53.ExportNamedDeclaration, import_nodes54.ExportNamedDeclaration);
+nodeTypeMap.set(import_nodes53.ExportDefaultDeclaration, import_nodes54.ExportDefaultDeclaration);
+nodeTypeMap.set(import_nodes53.ExportAllDeclaration, import_nodes54.ExportAllDeclaration);
+nodeTypeMap.set(import_nodes53.ModuleSpecifierList, import_nodes54.ModuleSpecifierList);
+nodeTypeMap.set(import_nodes53.ImportSpecifierList, import_nodes54.ImportSpecifierList);
+nodeTypeMap.set(import_nodes53.ExportSpecifierList, import_nodes54.ExportSpecifierList);
+nodeTypeMap.set(import_nodes53.ModuleSpecifier, import_nodes54.ModuleSpecifier);
+nodeTypeMap.set(import_nodes53.ImportSpecifier, import_nodes54.ImportSpecifier);
+nodeTypeMap.set(import_nodes53.ImportDefaultSpecifier, import_nodes54.ImportDefaultSpecifier);
+nodeTypeMap.set(import_nodes53.ImportNamespaceSpecifier, import_nodes54.ImportNamespaceSpecifier);
+nodeTypeMap.set(import_nodes53.ExportSpecifier, import_nodes54.ExportSpecifier);
+nodeTypeMap.set(import_nodes53.Assign, import_nodes54.Assign);
+nodeTypeMap.set(import_nodes53.Code, import_nodes54.Code);
+nodeTypeMap.set(import_nodes53.Param, import_nodes54.Param);
+nodeTypeMap.set(import_nodes53.Splat, import_nodes54.Splat);
+nodeTypeMap.set(import_nodes53.Expansion, import_nodes54.Expansion);
+nodeTypeMap.set(import_nodes53.While, import_nodes54.While);
+nodeTypeMap.set(import_nodes53.Op, import_nodes54.Op);
+nodeTypeMap.set(import_nodes53.In, import_nodes54.In);
+nodeTypeMap.set(import_nodes53.Try, import_nodes54.Try);
+nodeTypeMap.set(import_nodes53.Throw, import_nodes54.Throw);
+nodeTypeMap.set(import_nodes53.Existence, import_nodes54.Existence);
+nodeTypeMap.set(import_nodes53.Parens, import_nodes54.Parens);
+nodeTypeMap.set(import_nodes53.StringWithInterpolations, import_nodes54.StringWithInterpolations);
+nodeTypeMap.set(import_nodes53.For, import_nodes54.For);
+nodeTypeMap.set(import_nodes53.Switch, import_nodes54.Switch);
+nodeTypeMap.set(import_nodes53.If, import_nodes54.If);
+function parseCS1AsCS2(source) {
+  const cs1AST = (0, import_decaffeinate_coffeescript.nodes)(source);
+  const cs2AST = convertCS1NodeToCS2(cs1AST);
+  if (!(cs2AST instanceof import_nodes54.Block)) {
+    throw new Error("Expected top-level CS file to convert to a Block");
+  }
+  return cs2AST;
+}
+function convertCS1NodeToCS2(node) {
+  if (node instanceof import_nodes53.Comment) {
+    return makeCS2Comment(node);
+  }
+  const cs1Constructor = node.constructor;
+  const cs2Constructor = nodeTypeMap.get(cs1Constructor);
+  if (!cs2Constructor) {
+    throw new Error(`Unexpected CS1 type for node ${node}`);
+  }
+  const result = Object.create(cs2Constructor.prototype);
+  for (const key of Object.keys(node)) {
+    const value = node[key];
+    if (Array.isArray(value) && value.length > 0 && value[0] instanceof import_nodes53.Base) {
+      result[key] = value.map((child) => convertCS1NodeToCS2(child));
+    } else if (key === "cases") {
+      result[key] = value.map(([switchCaseCondition, block]) => {
+        if (Array.isArray(switchCaseCondition)) {
+          return [
+            switchCaseCondition.map((condition) => convertCS1NodeToCS2(condition)),
+            convertCS1NodeToCS2(block)
+          ];
+        } else {
+          return [
+            convertCS1NodeToCS2(switchCaseCondition),
+            convertCS1NodeToCS2(block)
+          ];
+        }
+      });
+    } else if (value instanceof import_nodes53.Base) {
+      result[key] = convertCS1NodeToCS2(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function makeCS2Comment(comment) {
+  const valueNode = Object.create(import_nodes54.Value.prototype);
+  const passthroughNode = Object.create(import_nodes54.PassthroughLiteral.prototype);
+  valueNode.properties = [];
+  valueNode.base = passthroughNode;
+  passthroughNode.value = "";
+  valueNode.locationData = comment.locationData;
+  passthroughNode.locationData = comment.locationData;
+  return valueNode;
+}
+
+// src/parseCS2.ts
+var import_decaffeinate_coffeescript2 = require("decaffeinate-coffeescript2");
+function parseCS2(source) {
+  return (0, import_decaffeinate_coffeescript2.nodes)(source);
+}
+
+// src/util/fixLocations.ts
+var import_coffee_lex17 = require("coffee-lex");
+var import_nodes55 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+
+// src/util/expandToIncludeParens.ts
+var import_coffee_lex15 = require("coffee-lex");
+
+// src/util/locationDataFromSourceRange.ts
+function locationDataFromSourceRange(context, sourceRange) {
+  const startLocationInclusive = context.linesAndColumns.locationForIndex(sourceRange.start);
+  if (startLocationInclusive === null) {
+    throw new Error("Expected start location for source range.");
+  }
+  const endLocationInclusive = context.linesAndColumns.locationForIndex(sourceRange.end - 1);
+  if (endLocationInclusive === null) {
+    throw new Error("Expected end location for source range.");
+  }
+  return {
+    first_line: startLocationInclusive.line,
+    first_column: startLocationInclusive.column,
+    last_line: endLocationInclusive.line,
+    last_column: endLocationInclusive.column
+  };
+}
+
+// src/util/sourceRangeFromLocationData.ts
+function sourceRangeFromLocationData(context, locationData) {
+  const startIndexInclusive = context.linesAndColumns.indexForLocation({
+    line: locationData.first_line,
+    column: locationData.first_column
+  });
+  if (startIndexInclusive === null) {
+    throw new Error("Expected index for start of range.");
+  }
+  const endIndexInclusive = context.linesAndColumns.indexForLocation({
+    line: locationData.last_line,
+    column: locationData.last_column
+  });
+  if (endIndexInclusive === null) {
+    throw new Error("Expected index for end of range.");
+  }
+  return {
+    start: startIndexInclusive,
+    end: endIndexInclusive + 1
+  };
+}
+
+// src/util/expandToIncludeParens.ts
+function expandToIncludeParens(context, locationData) {
+  let sourceRange = sourceRangeFromLocationData(context, locationData);
+  while (true) {
+    const tokens = getSurroundingParens(context, sourceRange);
+    if (tokens === null) {
+      break;
+    }
+    sourceRange = { start: tokens.openParen.start, end: tokens.closeParen.end };
+  }
+  return locationDataFromSourceRange(context, sourceRange);
+}
+function getSurroundingParens(context, sourceRange) {
+  const tokenBefore = firstSemanticTokenBefore(context, sourceRange.start);
+  const tokenAfter = firstSemanticTokenAfter(context, sourceRange.end);
+  if (tokenBefore === null || tokenBefore.type !== import_coffee_lex15.SourceType.LPAREN) {
+    return null;
+  }
+  if (tokenAfter === null || tokenAfter.type !== import_coffee_lex15.SourceType.RPAREN) {
+    return null;
+  }
+  return { openParen: tokenBefore, closeParen: tokenAfter };
+}
+
+// src/util/fixInvalidLocationData.ts
+function fixInvalidLocationData(locationData, linesAndColumns) {
+  let { last_line, last_column } = locationData;
+  const indexForLocation = linesAndColumns.indexForLocation({
+    line: last_line,
+    column: last_column
+  });
+  if (indexForLocation !== null) {
+    return locationData;
+  } else {
+    let offset = 1;
+    for (; ; ) {
+      const index = linesAndColumns.indexForLocation({
+        line: last_line,
+        column: last_column - offset
+      });
+      offset++;
+      if (index !== null) {
+        const location = linesAndColumns.locationForIndex(index + offset);
+        if (!location) {
+          throw new Error(`Unable to determine adjustment offset for incorrect location data: ${JSON.stringify(locationData)}. No valid location found for index: ${index + offset}`);
+        }
+        last_line = location.line;
+        last_column = location.column;
+        break;
+      }
+    }
+    return {
+      ...locationData,
+      last_line,
+      last_column
+    };
+  }
+}
+
+// src/util/locationWithLastPosition.ts
+function locationWithLastPosition(loc, last) {
+  return {
+    first_line: loc.first_line,
+    first_column: loc.first_column,
+    last_line: last.last_line,
+    last_column: last.last_column
+  };
+}
+
+// src/util/mergeLocations.ts
+function mergeLocations(left, right) {
+  let first_line;
+  let first_column;
+  let last_line;
+  let last_column;
+  if (left.first_line < right.first_line) {
+    ({ first_line, first_column } = left);
+  } else if (left.first_line > right.first_line) {
+    ({ first_line, first_column } = right);
+  } else if (left.first_column < right.first_column) {
+    ({ first_line, first_column } = left);
+  } else {
+    ({ first_line, first_column } = right);
+  }
+  if (left.last_line < right.last_line) {
+    ({ last_line, last_column } = right);
+  } else if (left.last_line > right.last_line) {
+    ({ last_line, last_column } = left);
+  } else if (left.last_column < right.last_column) {
+    ({ last_line, last_column } = right);
+  } else {
+    ({ last_line, last_column } = left);
+  }
+  return { first_line, first_column, last_line, last_column };
+}
+
+// src/util/rangeOfBracketTokensForIndexNode.ts
+var import_coffee_lex16 = require("coffee-lex");
+var import_util9 = require("util");
+function rangeOfBracketTokensForIndexNode(context, indexNode) {
+  const start = context.linesAndColumns.indexForLocation({
+    line: indexNode.locationData.first_line,
+    column: indexNode.locationData.first_column
+  });
+  if (start !== null) {
+    const startTokenIndex = context.sourceTokens.indexOfTokenStartingAtSourceIndex(start);
+    if (startTokenIndex !== null) {
+      const range = context.sourceTokens.rangeOfMatchingTokensContainingTokenIndex(import_coffee_lex16.SourceType.LBRACKET, import_coffee_lex16.SourceType.RBRACKET, startTokenIndex);
+      if (range !== null) {
+        return range;
+      }
+    }
+  }
+  throw new Error(`cannot find braces surrounding index at ${indexNode.locationData.first_line + 1}:${indexNode.locationData.first_column}: ${(0, import_util9.inspect)(indexNode)}`);
+}
+
+// src/util/fixLocations.ts
+function fixLocations(context, node) {
+  const { linesAndColumns, source } = context;
+  node.eachChild((child) => {
+    if (child && child.locationData) {
+      fixLocations(context, child);
+    }
+    return void 0;
+  });
+  node.locationData = fixInvalidLocationData(node.locationData, context.linesAndColumns);
+  if (node instanceof import_nodes55.Value) {
+    const lastChild = node.properties[node.properties.length - 1] || node.base;
+    if (lastChild) {
+      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+    }
+  }
+  if (node instanceof import_nodes55.Index || node instanceof import_nodes55.Slice) {
+    const rangeOfBrackets = rangeOfBracketTokensForIndexNode(context, node);
+    const lbracket = context.sourceTokens.tokenAtIndex(rangeOfBrackets[0]);
+    if (lbracket === null) {
+      throw new Error("Expected to find left-bracket token.");
+    }
+    const lbracketLoc = linesAndColumns.locationForIndex(lbracket.start);
+    if (lbracketLoc === null) {
+      throw new Error("Expected to find a location for the left-bracket token.");
+    }
+    const rbracketIndex = rangeOfBrackets[1].previous();
+    if (rbracketIndex === null) {
+      throw new Error("Expected to find a non-null right-bracket token index.");
+    }
+    const rbracket = context.sourceTokens.tokenAtIndex(rbracketIndex);
+    if (rbracket === null) {
+      throw new Error("Expected to find right-bracket token.");
+    }
+    const rbracketLoc = linesAndColumns.locationForIndex(rbracket.start);
+    if (rbracketLoc === null) {
+      throw new Error("Expected to find a location for the right-bracket token.");
+    }
+    node.locationData = {
+      first_line: lbracketLoc.line,
+      first_column: lbracketLoc.column,
+      last_line: rbracketLoc.line,
+      last_column: rbracketLoc.column
+    };
+  }
+  if (node instanceof import_nodes55.Obj) {
+    const loc = node.locationData;
+    const start = linesAndColumns.indexForLocation({
+      line: loc.first_line,
+      column: loc.first_column
+    });
+    if (start === null) {
+      throw new Error("Expected to find a start index for object.");
+    }
+    const end = linesAndColumns.indexForLocation({
+      line: loc.last_line,
+      column: loc.last_column
+    });
+    if (end === null) {
+      throw new Error("Expected to find an end index for object.");
+    }
+    const isImplicitObject = source[start] !== "{";
+    if (isImplicitObject && source[end] !== ",") {
+      const lastChild = node.properties[node.properties.length - 1];
+      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+    }
+  }
+  if (node instanceof import_nodes55.Op) {
+    const lastChild = node.second;
+    if (lastChild) {
+      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+    }
+  }
+  if (node instanceof import_nodes55.Assign) {
+    const lastChild = node.value;
+    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+  }
+  if (node instanceof import_nodes55.In) {
+    const lastChild = node.array;
+    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+  }
+  if (node instanceof import_nodes55.Call) {
+    if (node.variable && !node.do && !node.csx) {
+      const calleeLoc = node.variable.locationData;
+      let calleeEnd = linesAndColumns.indexForLocation({
+        line: calleeLoc.last_line,
+        column: calleeLoc.last_column
+      });
+      if (calleeEnd === null) {
+        throw new Error("Expected to find index for callee end.");
+      }
+      calleeEnd++;
+      if (source[calleeEnd] === "?") {
+        calleeEnd += 1;
+      }
+      const isImplicitCall = source[calleeEnd] !== "(";
+      if (isImplicitCall) {
+        const lastChild = node.args[node.args.length - 1] || node.variable;
+        if (lastChild) {
+          node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+        }
+      }
+    }
+  }
+  if (node instanceof import_nodes55.Block) {
+    const lastChild = node.expressions[node.expressions.length - 1];
+    if (lastChild) {
+      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+    } else {
+      const sourceRange = sourceRangeFromLocationData(context, node.locationData);
+      node.locationData = locationDataFromSourceRange(context, {
+        start: sourceRange.end,
+        end: sourceRange.end
+      });
+    }
+    let blockEnd = linesAndColumns.indexForLocation({
+      line: node.locationData.last_line,
+      column: node.locationData.last_column
+    });
+    if (blockEnd === null) {
+      throw new Error("Expected to find index for block end.");
+    }
+    if (source[blockEnd + 1] === ";") {
+      blockEnd++;
+      const loc = linesAndColumns.locationForIndex(blockEnd);
+      if (loc === null) {
+        throw new Error("Expected to find location for block end.");
+      }
+      node.locationData.last_line = loc.line;
+      node.locationData.last_column = loc.column;
+    }
+    node.locationData = expandToIncludeParens(context, node.locationData);
+  }
+  if (node instanceof import_nodes55.If) {
+    const lastChild = node.elseBody || node.body;
+    node.locationData = mergeLocations(node.locationData, lastChild.locationData);
+  }
+  if (node instanceof import_nodes55.For || node instanceof import_nodes55.While) {
+    const lastChild = node.body;
+    if (lastChild) {
+      node.locationData = mergeLocations(node.locationData, lastChild.locationData);
+    }
+  }
+  if (node instanceof import_nodes55.Param) {
+    if (!node.splat) {
+      const lastChild = node.value || node.name;
+      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+    }
+  }
+  if (node instanceof import_nodes55.Code) {
+    if (node.body) {
+      node.locationData = locationWithLastPosition(node.locationData, node.body.locationData);
+    }
+  }
+  if (node instanceof import_nodes55.Class) {
+    const lastChild = node.body;
+    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+  }
+  if (node instanceof import_nodes55.Switch) {
+    const lastChild = node.otherwise || node.cases[node.cases.length - 1][1];
+    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+  }
+  if (node instanceof import_nodes55.Try) {
+    const lastChild = node.ensure || node.recovery || node.errorVariable || node.attempt;
+    if (lastChild) {
+      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+    }
+  }
+  if (node instanceof import_nodes55.Extends) {
+    const lastChild = node.parent;
+    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
+  }
+  if (node instanceof import_nodes55.Literal) {
+    const endIndex = linesAndColumns.indexForLocation({
+      line: node.locationData.last_line,
+      column: node.locationData.last_column
+    });
+    if (endIndex !== null) {
+      const tokenIndex = context.sourceTokens.indexOfTokenNearSourceIndex(endIndex);
+      const token = context.sourceTokens.tokenAtIndex(tokenIndex);
+      if (token && token.type === import_coffee_lex17.SourceType.HEREGEXP_END) {
+        const location = linesAndColumns.locationForIndex(token.end - 1);
+        if (location) {
+          node.locationData = {
+            ...node.locationData,
+            last_line: location.line,
+            last_column: location.column
+          };
+        }
+      }
+    }
+  }
+}
+
+// src/util/ParseContext.ts
+var import_nodes56 = require("decaffeinate-coffeescript2/lib/coffeescript/nodes.js");
+var import_lines_and_columns = require("lines-and-columns");
+var ParseError = class extends Error {
+  constructor(syntaxError) {
+    super(syntaxError.message);
+    this.syntaxError = syntaxError;
+  }
+};
+var ParseState = class {
+  constructor(currentClassBoundMethods) {
+    this.currentClassBoundMethods = currentClassBoundMethods;
+    this.currentClassCtor = null;
+  }
+  isInClassBody() {
+    return this.currentClassBoundMethods !== null;
+  }
+  recordBoundMethod(method) {
+    if (!this.currentClassBoundMethods) {
+      throw new Error("Cannot assign a bound method name when there is no current class.");
+    }
+    this.currentClassBoundMethods.push(method);
+  }
+  recordConstructor(ctor) {
+    this.currentClassCtor = ctor;
+  }
+  pushCurrentClass() {
+    return new ParseState([]);
+  }
+  dropCurrentClass() {
+    return new ParseState(null);
+  }
+  static initialState() {
+    return new ParseState(null);
+  }
+};
+var ParseContext = class {
+  constructor(source, linesAndColumns, sourceTokens, ast, parseState) {
+    this.source = source;
+    this.linesAndColumns = linesAndColumns;
+    this.sourceTokens = sourceTokens;
+    this.ast = ast;
+    this.parseState = parseState;
+  }
+  getRange(locatable) {
+    if (locatable instanceof import_nodes56.Base) {
+      return this.getRange(locatable.locationData);
+    } else {
+      const locationData = locatable;
+      const start = this.linesAndColumns.indexForLocation({
+        line: locationData.first_line,
+        column: locationData.first_column
+      });
+      const end = this.linesAndColumns.indexForLocation({
+        line: locationData.last_line,
+        column: locationData.last_column
+      });
+      if (start === null || end === null) {
+        return null;
+      }
+      return [start, end + 1];
+    }
+  }
+  static fromSource(source, sourceLex, parse5) {
+    try {
+      const sourceTokens = sourceLex(source);
+      return new ParseContext(source, new import_lines_and_columns.LinesAndColumns(source), sourceTokens, parse5(source), ParseState.initialState());
+    } catch (ex) {
+      if (ex instanceof SyntaxError) {
+        throw new ParseError(ex);
+      } else {
+        throw ex;
+      }
+    }
+  }
+  updateState(updater) {
+    return new ParseContext(this.source, this.linesAndColumns, this.sourceTokens, this.ast, updater(this.parseState));
+  }
+};
+
+// src/parser.ts
+var DEFAULT_OPTIONS = {
+  useCS2: false
+};
+function parse4(source, options = DEFAULT_OPTIONS) {
+  patchCoffeeScript();
+  const parse5 = options.useCS2 ? parseCS2 : parseCS1AsCS2;
+  const sourceLex = (s) => (0, import_coffee_lex18.default)(s, { useCS2: options.useCS2 });
+  const context = ParseContext.fromSource(source, sourceLex, parse5);
+  fixLocations(context, context.ast);
+  const program = mapProgram(context);
+  traverse(program, (node, parent) => {
+    node.parentNode = parent;
+  });
+  return program;
+}
+function traverse(node, callback) {
+  function traverseRec(currentNode, currentParent) {
+    const shouldDescend = callback(currentNode, currentParent);
+    if (shouldDescend !== false) {
+      for (const child of currentNode.getChildren()) {
+        traverseRec(child, currentNode);
+      }
+    }
+  }
+  traverseRec(node, null);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessOp,
+  ArrayInitialiser,
+  AssignOp,
+  AsyncFunction,
+  Await,
+  AwaitReturn,
+  BareSuperFunctionApplication,
+  BaseAssignOp,
+  BaseFunction,
+  BinaryOp,
+  BitAndOp,
+  BitNotOp,
+  BitOrOp,
+  BitXorOp,
+  Block,
+  Bool,
+  BoundAsyncFunction,
+  BoundFunction,
+  BoundGeneratorFunction,
+  Break,
+  CSXElement,
+  ChainedComparisonOp,
+  Class,
+  ClassProtoAssignOp,
+  CompoundAssignOp,
+  Conditional,
+  Constructor,
+  Continue,
+  DEFAULT_OPTIONS,
+  Debugger,
+  DefaultParam,
+  DeleteOp,
+  DivideOp,
+  DoOp,
+  DynamicMemberAccessOp,
+  EQOp,
+  Elision,
+  ExistsOp,
+  ExpOp,
+  Expansion,
+  ExportAllDeclaration,
+  ExportBindingsDeclaration,
+  ExportDefaultDeclaration,
+  ExportNamedDeclaration,
+  ExtendsOp,
+  Float,
+  FloorDivideOp,
+  For,
+  ForFrom,
+  ForIn,
+  ForOf,
+  Function,
+  FunctionApplication,
+  GTEOp,
+  GTOp,
+  GeneratorFunction,
+  Heregex,
+  Identifier,
+  ImportDeclaration,
+  InOp,
+  InstanceofOp,
+  Int,
+  JavaScript,
+  LTEOp,
+  LTOp,
+  LeftShiftOp,
+  LogicalAndOp,
+  LogicalNotOp,
+  LogicalOrOp,
+  Loop,
+  MemberAccessOp,
+  ModuleSpecifier,
+  ModuloOp,
+  MultiplyOp,
+  NEQOp,
+  NewOp,
+  Node,
+  Null,
+  Number,
+  ObjectInitialiser,
+  ObjectInitialiserMember,
+  OfOp,
+  OperatorInfo,
+  PlusOp,
+  PostDecrementOp,
+  PostIncrementOp,
+  PreDecrementOp,
+  PreIncrementOp,
+  Program,
+  ProtoMemberAccessOp,
+  Quasi,
+  Range,
+  Regex,
+  RegexFlags,
+  RemOp,
+  Rest,
+  Return,
+  SeqOp,
+  SignedRightShiftOp,
+  Slice,
+  SoakedDynamicMemberAccessOp,
+  SoakedFunctionApplication,
+  SoakedMemberAccessOp,
+  SoakedNewOp,
+  SoakedProtoMemberAccessOp,
+  SoakedSlice,
+  Spread,
+  String,
+  SubtractOp,
+  Super,
+  Switch,
+  SwitchCase,
+  TaggedTemplateLiteral,
+  This,
+  Throw,
+  Try,
+  TypeofOp,
+  UnaryExistsOp,
+  UnaryNegateOp,
+  UnaryOp,
+  UnaryPlusOp,
+  Undefined,
+  UnsignedRightShiftOp,
+  While,
+  Yield,
+  YieldFrom,
+  YieldReturn,
+  parse,
+  traverse
+});