wice_grid 7.1.0 → 7.1.1

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

@@ -1,3458 +0,0 @@
-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
-});