wice_grid 7.1.0 → 7.1.1

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

@@ -1,3557 +0,0 @@
-// src/parser.ts
-import lex from "coffee-lex";
-
-// src/ext/coffee-script.ts
-import {
-  Base as CS1Base,
-  Op as CS1Op
-} from "decaffeinate-coffeescript/lib/coffee-script/nodes.js";
-import { Base, Op } from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-function patchCoffeeScript() {
-  CS1Op.prototype.invert = invert;
-  CS1Base.prototype.invert = invert;
-  Op.prototype.invert = invert;
-  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
-import {
-  PassthroughLiteral,
-  Value
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-function isCommentOnlyNode(base) {
-  return base instanceof Value && base.base instanceof PassthroughLiteral && base.base.value === "";
-}
-
-// src/mappers/mapBlock.ts
-import { SourceType as SourceType14 } from "coffee-lex";
-import {
-  Assign as Assign4,
-  Obj as Obj4,
-  Value as Value10
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-import { inspect as inspect8 } from "util";
-
-// src/util/getLocation.ts
-import { SourceType } from "coffee-lex";
-import { inspect } from "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: ${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 !== SourceType.NEWLINE && token.type !== 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 !== SourceType.NEWLINE && token.type !== 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: ${inspect(node)}`);
-  }
-  return token;
-}
-
-// src/mappers/mapAny.ts
-import {
-  Arr as Arr2,
-  Assign as Assign3,
-  Block as Block3,
-  Call as Call4,
-  Class as Class2,
-  Code,
-  ComputedPropertyName as ComputedPropertyName2,
-  Elision as Elision2,
-  Existence,
-  Expansion as Expansion2,
-  Extends,
-  For as For3,
-  If,
-  In,
-  Literal as Literal8,
-  ModuleDeclaration as ModuleDeclaration2,
-  Obj as Obj3,
-  Op as Op7,
-  Param,
-  Parens as Parens2,
-  Range as Range2,
-  Return as Return2,
-  Splat as Splat4,
-  StringWithInterpolations as StringWithInterpolations4,
-  Super as Super2,
-  Switch as Switch2,
-  TaggedTemplateCall,
-  Throw as Throw2,
-  Try as Try2,
-  Value as Value9,
-  While as While2
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-
-// src/util/UnsupportedNodeError.ts
-import { inspect as inspect2 } from "util";
-var UnsupportedNodeError = class extends Error {
-  constructor(node, message = null) {
-    const prefix = message ? `${message}
-
-` : "";
-    super(`${prefix}node type '${node.constructor.name}' is not supported: ${inspect2(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
-import { SourceType as SourceType5 } from "coffee-lex";
-import {
-  Literal as Literal3,
-  Splat as Splat2,
-  StringWithInterpolations as StringWithInterpolations2,
-  SuperCall,
-  Value as Value5
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-import { inspect as inspect3 } from "util";
-
-// src/util/isHeregexTemplateNode.ts
-import { SourceType as SourceType2 } from "coffee-lex";
-import {
-  Call,
-  Literal,
-  Value as Value2
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-function isHeregexTemplateNode(node, context) {
-  if (!(node instanceof Call) || !node.variable || !(node.variable instanceof Value2) || !node.variable.base || !(node.variable.base instanceof 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 === SourceType2.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
-import {
-  SourceType as SourceType4
-} from "coffee-lex";
-import {
-  Literal as Literal2,
-  Op as Op2,
-  Value as Value3
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-
-// src/util/isPlusTokenBetweenRanges.ts
-import { SourceType as SourceType3 } from "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 === SourceType3.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
-import { parse } from "@codemod/parser";
-function parseString(string) {
-  const expressionStatement = 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 === SourceType4.INTERPOLATION_START || token.type === SourceType4.CSX_OPEN_TAG_START) {
-      depth++;
-      if (depth === 1) {
-        quasis.push(findQuasi(lastToken, token, context, elements));
-        lastToken = token;
-      }
-    } else if (token.type === SourceType4.INTERPOLATION_END || token.type === SourceType4.CSX_SELF_CLOSING_TAG_END || token.type === SourceType4.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 Op2 && 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 Literal2) {
-      literal = element;
-    } else if (element instanceof Value3 && element.properties.length === 0 && element.base instanceof Literal2) {
-      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 [
-    SourceType4.DSTRING_START,
-    SourceType4.SSTRING_START,
-    SourceType4.TDSTRING_START,
-    SourceType4.TSSTRING_START,
-    SourceType4.HEREGEXP_START,
-    SourceType4.CSX_OPEN_TAG_END
-  ].indexOf(token.type) >= 0;
-}
-function isTemplateLiteralEnd(token) {
-  return [
-    SourceType4.DSTRING_END,
-    SourceType4.SSTRING_END,
-    SourceType4.TDSTRING_END,
-    SourceType4.TSSTRING_END,
-    SourceType4.HEREGEXP_END,
-    SourceType4.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
-import {
-  Arr,
-  Assign,
-  IdentifierLiteral,
-  Obj,
-  Splat,
-  StringLiteral,
-  StringWithInterpolations,
-  Value as Value4
-} from "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 Value4) || !(properties.base instanceof 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 Value4)) {
-      throw new Error("Expected value for CSX property.");
-    }
-    if (value.base instanceof Obj) {
-      for (const propertyAssignment of value.base.objects) {
-        if (propertyAssignment instanceof Splat) {
-          resultProperties.push(mapAny(context, propertyAssignment));
-        } else if (propertyAssignment instanceof Assign) {
-          if (!(propertyAssignment.value instanceof Value4)) {
-            throw new Error("Unexpected property assignment value.");
-          }
-          if (!(propertyAssignment.value.base instanceof StringLiteral)) {
-            resultProperties.push(mapAny(context, propertyAssignment.value));
-          }
-        } else {
-          throw new Error("Unexpected property assignment object field in CSX.");
-        }
-      }
-    } else if (value.base instanceof IdentifierLiteral) {
-    } else {
-      throw new Error("Unexpected property assignment in CSX.");
-    }
-  }
-  return resultProperties;
-}
-function mapCSXChildren(context, children) {
-  if (!children) {
-    return [];
-  }
-  if (!(children instanceof Value4)) {
-    throw new Error("Expected a value for the CSX children arg.");
-  }
-  if (children.base instanceof StringLiteral) {
-    return [];
-  } else if (!(children.base instanceof 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 Value5) || !(firstArg.base instanceof StringWithInterpolations2)) {
-      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 Value5) || !(secondArg.base instanceof Literal3)) {
-        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 SuperCall) {
-    if (node.args.length === 1 && node.args[0] instanceof Splat2 && 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 !== SourceType5.SUPER) {
-      throw new Error(`unable to find SUPER token in 'super' function call: ${inspect3(node)}`);
-    }
-    const superLocation = context.linesAndColumns.locationForIndex(superToken.start);
-    if (!superLocation) {
-      throw new Error(`unable to locate SUPER token for 'super' function call: ${inspect3(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
-import { SourceType as SourceType6 } from "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 === SourceType6.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
-import { SourceType as SourceType7 } from "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 === SourceType7.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
-import {
-  BooleanLiteral,
-  IdentifierLiteral as IdentifierLiteral2,
-  NullLiteral,
-  NumberLiteral,
-  PassthroughLiteral as PassthroughLiteral2,
-  PropertyName,
-  RegexLiteral,
-  StatementLiteral,
-  StringLiteral as StringLiteral2,
-  ThisLiteral,
-  UndefinedLiteral
-} from "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
-import { parse as parse2 } from "@codemod/parser";
-function parseNumber(string) {
-  const expressionStatement = parse2(`(${string})`).program.body[0];
-  const literal = expressionStatement.expression;
-  return literal.value;
-}
-
-// src/util/parseRegExp.ts
-import { parse as parse3 } from "@codemod/parser";
-function parseRegExp(string) {
-  const expressionStatement = parse3(`(${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 ThisLiteral) {
-    return new This(line, column, start, end, raw);
-  } else if (node instanceof NullLiteral) {
-    return new Null(line, column, start, end, raw);
-  } else if (node instanceof UndefinedLiteral) {
-    return new Undefined(line, column, start, end, raw);
-  } else if (node instanceof BooleanLiteral) {
-    return new Bool(line, column, start, end, raw, JSON.parse(node.value));
-  } else if (node instanceof IdentifierLiteral2 || node instanceof PropertyName) {
-    const value = node.value.valueOf();
-    return new Identifier(line, column, start, end, raw, value);
-  } else if (node instanceof PassthroughLiteral2) {
-    return new JavaScript(line, column, start, end, raw, node.value);
-  } else if (node instanceof 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 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 StringLiteral2) {
-    return makeString(context, node);
-  } else if (node instanceof 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
-import {
-  ExportAllDeclaration as CoffeeExportAllDeclaration,
-  ExportDefaultDeclaration as CoffeeExportDefaultDeclaration,
-  ExportNamedDeclaration as CoffeeExportNamedDeclaration,
-  ExportSpecifierList,
-  IdentifierLiteral as IdentifierLiteral3,
-  ImportDeclaration as CoffeeImportDeclaration,
-  ImportNamespaceSpecifier,
-  ImportSpecifierList,
-  Literal as Literal5
-} from "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 CoffeeImportDeclaration) {
-    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 ImportNamespaceSpecifier) {
-        namespaceImport = mapStarSpecifier(context, clause.namedImports);
-      } else if (clause.namedImports instanceof 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 CoffeeExportNamedDeclaration) {
-    if (node.clause instanceof 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 CoffeeExportDefaultDeclaration) {
-    const expression = mapAny(context, notNull(node.clause));
-    return new ExportDefaultDeclaration(line, column, start, end, raw, expression);
-  } else if (node instanceof CoffeeExportAllDeclaration) {
-    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 IdentifierLiteral3) {
-    return mapLiteral(context, literal);
-  } else if (literal.constructor === Literal5) {
-    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
-import {
-  Assign as Assign2,
-  ComputedPropertyName,
-  Splat as Splat3,
-  Value as Value7
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-
-// src/mappers/mapValue.ts
-import { SourceType as SourceType8 } from "coffee-lex";
-import {
-  Access,
-  Index,
-  Literal as Literal6,
-  Slice as CoffeeSlice
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-import { inspect as inspect4 } from "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 Access) {
-    const name = property.name;
-    if (!(name instanceof Literal6)) {
-      throw new Error(`unexpected non-Literal property access name: ${inspect4(name)}`);
-    }
-    let startTokenIndex = tokenIndexAtLocation(context, property.locationData);
-    let startToken = startTokenIndex && context.sourceTokens.tokenAtIndex(startTokenIndex);
-    if (startToken && property.soak) {
-      if (startToken.type !== SourceType8.EXISTENCE) {
-        throw new Error(`expected EXISTENCE token ('?') but got ${SourceType8[startToken.type]}: ${inspect4(startToken)}`);
-      }
-      startTokenIndex = startTokenIndex && startTokenIndex.next();
-      startToken = startTokenIndex && context.sourceTokens.tokenAtIndex(startTokenIndex);
-    }
-    if (!startToken) {
-      throw new Error(`cannot find token at start of property: ${inspect4(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: ${inspect4(property)}`);
-    }
-    const isPrototypeAccess = startToken.type === SourceType8.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: ${inspect4(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 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: ${inspect4(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 CoffeeSlice) {
-    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: ${inspect4(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 Value7) {
-      const value = mapValue(context, property);
-      const isComputed = property.base instanceof ComputedPropertyName;
-      members.push(new ObjectInitialiserMember(line2, column2, start2, end2, raw2, value, null, isComputed));
-    } else if (property instanceof Assign2 && property.context === "object") {
-      const key = mapAny(context, property.variable);
-      const expression = mapAny(context, property.value);
-      const isComputed = property.variable instanceof Value7 && property.variable.base instanceof ComputedPropertyName;
-      members.push(new ObjectInitialiserMember(line2, column2, start2, end2, raw2, key, expression, isComputed));
-    } else if (property instanceof Assign2) {
-      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 Splat3) {
-      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
-import { SourceType as SourceType10 } from "coffee-lex";
-import {
-  Literal as Literal7,
-  Value as Value8
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-import { inspect as inspect6 } from "util";
-
-// src/util/getOperatorInfoInRange.ts
-import { SourceType as SourceType9 } from "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 !== SourceType9.LPAREN && token.type !== SourceType9.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
-import { Op as Op4 } from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-
-// src/util/isComparisonOperator.ts
-import { Op as Op3 } from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-function isComparisonOperator(node) {
-  if (!(node instanceof Op3)) {
-    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 Op4 && isComparisonOperator(node)) {
-    return isComparisonOperator(node.first) || (node.second ? isComparisonOperator(node.second) : false);
-  } else {
-    return false;
-  }
-}
-
-// src/util/unwindChainedComparison.ts
-import { Op as Op5 } from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-import { inspect as inspect5 } from "util";
-function unwindChainedComparison(node) {
-  let operands = [];
-  for (let link = node; ; ) {
-    if (link instanceof Op5 && isComparisonOperator(link)) {
-      const { first, second } = link;
-      if (!second) {
-        throw new Error(`unexpected unary operator inside chained comparison: ${inspect5(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: ${inspect6(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 Value8 && node.first.base instanceof Literal7 && 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: ${inspect6(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: ${inspect6(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 === SourceType10.OPERATOR || token.type === SourceType10.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
-import {
-  Block as Block2
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-function mapParens(context, node) {
-  if (!(node.body instanceof Block2)) {
-    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
-import { inspect as inspect7 } from "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: ${inspect7(node)}`);
-  }
-  return new Range(line, column, start, end, raw, mapAny(context, node.from), mapAny(context, node.to), !node.exclusive);
-}
-
-// src/mappers/mapReturn.ts
-import {
-  AwaitReturn as CoffeeAwaitReturn,
-  YieldReturn as CoffeeYieldReturn
-} from "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 CoffeeYieldReturn) {
-    return new YieldReturn(line, column, start, end, raw, argument);
-  } else if (node instanceof CoffeeAwaitReturn) {
-    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
-import { SourceType as SourceType11 } from "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 !== SourceType11.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
-import { SourceType as SourceType12 } from "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 === SourceType12.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
-import { SourceType as SourceType13 } from "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 === SourceType13.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 Value9) {
-    return mapValue(context, node);
-  }
-  if (node instanceof ComputedPropertyName2) {
-    return mapComputedPropertyName(context, node);
-  }
-  if (node instanceof Literal8) {
-    return mapLiteral(context, node);
-  }
-  if (node instanceof Op7) {
-    return mapOp(context, node);
-  }
-  if (node instanceof TaggedTemplateCall) {
-    return mapTaggedTemplateCall(context, node);
-  }
-  if (node instanceof Call4) {
-    return mapCall(context, node);
-  }
-  if (node instanceof Super2) {
-    return mapSuper(context, node);
-  }
-  if (node instanceof Arr2) {
-    return mapArr(context, node);
-  }
-  if (node instanceof Assign3) {
-    return mapAssign(context, node);
-  }
-  if (node instanceof Param) {
-    return mapParam(context, node);
-  }
-  if (node instanceof Return2) {
-    return mapReturn(context, node);
-  }
-  if (node instanceof If) {
-    return mapIf(context, node);
-  }
-  if (node instanceof Obj3) {
-    return mapObj(context, node);
-  }
-  if (node instanceof Parens2 || node instanceof StringWithInterpolations4) {
-    return mapParens(context, node);
-  }
-  if (node instanceof For3) {
-    return mapFor(context, node);
-  }
-  if (node instanceof Throw2) {
-    return mapThrow(context, node);
-  }
-  if (node instanceof Block3) {
-    return mapBlock(context, node);
-  }
-  if (node instanceof Code) {
-    return mapCode(context, node);
-  }
-  if (node instanceof While2 && !(node instanceof For3)) {
-    return mapWhile(context, node);
-  }
-  if (node instanceof Try2) {
-    return mapTry(context, node);
-  }
-  if (node instanceof Existence) {
-    return mapExistence(context, node);
-  }
-  if (node instanceof Class2) {
-    return mapClass(context, node);
-  }
-  if (node instanceof Splat4) {
-    return mapSplat(context, node);
-  }
-  if (node instanceof Expansion2) {
-    return mapExpansion(context, node);
-  }
-  if (node instanceof Elision2) {
-    return mapElision(context, node);
-  }
-  if (node instanceof Switch2) {
-    return mapSwitch(context, node);
-  }
-  if (node instanceof In) {
-    return mapIn(context, node);
-  }
-  if (node instanceof Range2) {
-    return mapRange(context, node);
-  }
-  if (node instanceof Extends) {
-    return mapExtends(context, node);
-  }
-  if (node instanceof ModuleDeclaration2) {
-    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 Value10 && 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 !== SourceType14.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 Value10 && node.isObject(true)) {
-    const obj = node.base;
-    if (!(obj instanceof Obj4)) {
-      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 Assign4) {
-        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: ${inspect8(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
-import { nodes } from "decaffeinate-coffeescript";
-import {
-  Access as CS1Access,
-  Arr as CS1Arr,
-  Assign as CS1Assign,
-  Base as CS1Base2,
-  Block as CS1Block,
-  BooleanLiteral as CS1BooleanLiteral,
-  Call as CS1Call,
-  Class as CS1Class,
-  Code as CS1Code,
-  Comment as CS1Comment,
-  Existence as CS1Existence,
-  Expansion as CS1Expansion,
-  ExportAllDeclaration as CS1ExportAllDeclaration,
-  ExportDeclaration as CS1ExportDeclaration,
-  ExportDefaultDeclaration as CS1ExportDefaultDeclaration,
-  ExportNamedDeclaration as CS1ExportNamedDeclaration,
-  ExportSpecifier as CS1ExportSpecifier,
-  ExportSpecifierList as CS1ExportSpecifierList,
-  Extends as CS1Extends,
-  For as CS1For,
-  IdentifierLiteral as CS1IdentifierLiteral,
-  If as CS1If,
-  ImportClause as CS1ImportClause,
-  ImportDeclaration as CS1ImportDeclaration,
-  ImportDefaultSpecifier as CS1ImportDefaultSpecifier,
-  ImportNamespaceSpecifier as CS1ImportNamespaceSpecifier,
-  ImportSpecifier as CS1ImportSpecifier,
-  ImportSpecifierList as CS1ImportSpecifierList,
-  In as CS1In,
-  Index as CS1Index,
-  InfinityLiteral as CS1InfinityLiteral,
-  Literal as CS1Literal,
-  ModuleDeclaration as CS1ModuleDeclaration,
-  ModuleSpecifier as CS1ModuleSpecifier,
-  ModuleSpecifierList as CS1ModuleSpecifierList,
-  NaNLiteral as CS1NaNLiteral,
-  NullLiteral as CS1NullLiteral,
-  NumberLiteral as CS1NumberLiteral,
-  Obj as CS1Obj,
-  Op as CS1Op2,
-  Param as CS1Param,
-  Parens as CS1Parens,
-  PassthroughLiteral as CS1PassthroughLiteral,
-  PropertyName as CS1PropertyName,
-  Range as CS1Range,
-  RegexLiteral as CS1RegexLiteral,
-  RegexWithInterpolations as CS1RegexWithInterpolations,
-  Return as CS1Return,
-  Slice as CS1Slice,
-  Splat as CS1Splat,
-  StatementLiteral as CS1StatementLiteral,
-  StringLiteral as CS1StringLiteral,
-  StringWithInterpolations as CS1StringWithInterpolations,
-  SuperCall as CS1SuperCall,
-  Switch as CS1Switch,
-  TaggedTemplateCall as CS1TaggedTemplateCall,
-  ThisLiteral as CS1ThisLiteral,
-  Throw as CS1Throw,
-  Try as CS1Try,
-  UndefinedLiteral as CS1UndefinedLiteral,
-  Value as CS1Value,
-  While as CS1While,
-  YieldReturn as CS1YieldReturn
-} from "decaffeinate-coffeescript/lib/coffee-script/nodes.js";
-import {
-  Access as Access2,
-  Arr as Arr3,
-  Assign as Assign5,
-  Base as Base11,
-  Block as Block4,
-  BooleanLiteral as BooleanLiteral2,
-  Call as Call5,
-  Class as Class3,
-  Code as Code2,
-  Existence as Existence2,
-  Expansion as Expansion3,
-  ExportAllDeclaration as ExportAllDeclaration2,
-  ExportDeclaration,
-  ExportDefaultDeclaration as ExportDefaultDeclaration2,
-  ExportNamedDeclaration as ExportNamedDeclaration2,
-  ExportSpecifier,
-  ExportSpecifierList as ExportSpecifierList2,
-  Extends as Extends2,
-  For as For4,
-  IdentifierLiteral as IdentifierLiteral4,
-  If as If2,
-  ImportClause,
-  ImportDeclaration as ImportDeclaration2,
-  ImportDefaultSpecifier,
-  ImportNamespaceSpecifier as ImportNamespaceSpecifier2,
-  ImportSpecifier,
-  ImportSpecifierList as ImportSpecifierList2,
-  In as In2,
-  Index as Index2,
-  InfinityLiteral,
-  Literal as Literal9,
-  ModuleDeclaration as ModuleDeclaration3,
-  ModuleSpecifier as ModuleSpecifier2,
-  ModuleSpecifierList,
-  NaNLiteral,
-  NullLiteral as NullLiteral2,
-  NumberLiteral as NumberLiteral2,
-  Obj as Obj5,
-  Op as Op8,
-  Param as Param2,
-  Parens as Parens3,
-  PassthroughLiteral as PassthroughLiteral3,
-  PropertyName as PropertyName2,
-  Range as Range3,
-  RegexLiteral as RegexLiteral2,
-  RegexWithInterpolations,
-  Return as Return3,
-  Slice as Slice2,
-  Splat as Splat5,
-  StatementLiteral as StatementLiteral2,
-  StringLiteral as StringLiteral4,
-  StringWithInterpolations as StringWithInterpolations5,
-  SuperCall as SuperCall2,
-  Switch as Switch3,
-  TaggedTemplateCall as TaggedTemplateCall2,
-  ThisLiteral as ThisLiteral2,
-  Throw as Throw3,
-  Try as Try3,
-  UndefinedLiteral as UndefinedLiteral2,
-  Value as Value11,
-  While as While3,
-  YieldReturn as YieldReturn2
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-var nodeTypeMap = /* @__PURE__ */ new Map();
-nodeTypeMap.set(CS1Base2, Base11);
-nodeTypeMap.set(CS1Block, Block4);
-nodeTypeMap.set(CS1Literal, Literal9);
-nodeTypeMap.set(CS1NumberLiteral, NumberLiteral2);
-nodeTypeMap.set(CS1InfinityLiteral, InfinityLiteral);
-nodeTypeMap.set(CS1NaNLiteral, NaNLiteral);
-nodeTypeMap.set(CS1StringLiteral, StringLiteral4);
-nodeTypeMap.set(CS1RegexLiteral, RegexLiteral2);
-nodeTypeMap.set(CS1PassthroughLiteral, PassthroughLiteral3);
-nodeTypeMap.set(CS1IdentifierLiteral, IdentifierLiteral4);
-nodeTypeMap.set(CS1PropertyName, PropertyName2);
-nodeTypeMap.set(CS1StatementLiteral, StatementLiteral2);
-nodeTypeMap.set(CS1ThisLiteral, ThisLiteral2);
-nodeTypeMap.set(CS1UndefinedLiteral, UndefinedLiteral2);
-nodeTypeMap.set(CS1NullLiteral, NullLiteral2);
-nodeTypeMap.set(CS1BooleanLiteral, BooleanLiteral2);
-nodeTypeMap.set(CS1Return, Return3);
-nodeTypeMap.set(CS1YieldReturn, YieldReturn2);
-nodeTypeMap.set(CS1Value, Value11);
-nodeTypeMap.set(CS1Call, Call5);
-nodeTypeMap.set(CS1SuperCall, SuperCall2);
-nodeTypeMap.set(CS1RegexWithInterpolations, RegexWithInterpolations);
-nodeTypeMap.set(CS1TaggedTemplateCall, TaggedTemplateCall2);
-nodeTypeMap.set(CS1Extends, Extends2);
-nodeTypeMap.set(CS1Access, Access2);
-nodeTypeMap.set(CS1Index, Index2);
-nodeTypeMap.set(CS1Range, Range3);
-nodeTypeMap.set(CS1Slice, Slice2);
-nodeTypeMap.set(CS1Obj, Obj5);
-nodeTypeMap.set(CS1Arr, Arr3);
-nodeTypeMap.set(CS1Class, Class3);
-nodeTypeMap.set(CS1ModuleDeclaration, ModuleDeclaration3);
-nodeTypeMap.set(CS1ImportDeclaration, ImportDeclaration2);
-nodeTypeMap.set(CS1ImportClause, ImportClause);
-nodeTypeMap.set(CS1ExportDeclaration, ExportDeclaration);
-nodeTypeMap.set(CS1ExportNamedDeclaration, ExportNamedDeclaration2);
-nodeTypeMap.set(CS1ExportDefaultDeclaration, ExportDefaultDeclaration2);
-nodeTypeMap.set(CS1ExportAllDeclaration, ExportAllDeclaration2);
-nodeTypeMap.set(CS1ModuleSpecifierList, ModuleSpecifierList);
-nodeTypeMap.set(CS1ImportSpecifierList, ImportSpecifierList2);
-nodeTypeMap.set(CS1ExportSpecifierList, ExportSpecifierList2);
-nodeTypeMap.set(CS1ModuleSpecifier, ModuleSpecifier2);
-nodeTypeMap.set(CS1ImportSpecifier, ImportSpecifier);
-nodeTypeMap.set(CS1ImportDefaultSpecifier, ImportDefaultSpecifier);
-nodeTypeMap.set(CS1ImportNamespaceSpecifier, ImportNamespaceSpecifier2);
-nodeTypeMap.set(CS1ExportSpecifier, ExportSpecifier);
-nodeTypeMap.set(CS1Assign, Assign5);
-nodeTypeMap.set(CS1Code, Code2);
-nodeTypeMap.set(CS1Param, Param2);
-nodeTypeMap.set(CS1Splat, Splat5);
-nodeTypeMap.set(CS1Expansion, Expansion3);
-nodeTypeMap.set(CS1While, While3);
-nodeTypeMap.set(CS1Op2, Op8);
-nodeTypeMap.set(CS1In, In2);
-nodeTypeMap.set(CS1Try, Try3);
-nodeTypeMap.set(CS1Throw, Throw3);
-nodeTypeMap.set(CS1Existence, Existence2);
-nodeTypeMap.set(CS1Parens, Parens3);
-nodeTypeMap.set(CS1StringWithInterpolations, StringWithInterpolations5);
-nodeTypeMap.set(CS1For, For4);
-nodeTypeMap.set(CS1Switch, Switch3);
-nodeTypeMap.set(CS1If, If2);
-function parseCS1AsCS2(source) {
-  const cs1AST = nodes(source);
-  const cs2AST = convertCS1NodeToCS2(cs1AST);
-  if (!(cs2AST instanceof Block4)) {
-    throw new Error("Expected top-level CS file to convert to a Block");
-  }
-  return cs2AST;
-}
-function convertCS1NodeToCS2(node) {
-  if (node instanceof CS1Comment) {
-    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 CS1Base2) {
-      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 CS1Base2) {
-      result[key] = convertCS1NodeToCS2(value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function makeCS2Comment(comment) {
-  const valueNode = Object.create(Value11.prototype);
-  const passthroughNode = Object.create(PassthroughLiteral3.prototype);
-  valueNode.properties = [];
-  valueNode.base = passthroughNode;
-  passthroughNode.value = "";
-  valueNode.locationData = comment.locationData;
-  passthroughNode.locationData = comment.locationData;
-  return valueNode;
-}
-
-// src/parseCS2.ts
-import { nodes as nodes2 } from "decaffeinate-coffeescript2";
-function parseCS2(source) {
-  return nodes2(source);
-}
-
-// src/util/fixLocations.ts
-import { SourceType as SourceType17 } from "coffee-lex";
-import {
-  Assign as Assign6,
-  Block as Block5,
-  Call as Call6,
-  Class as Class4,
-  Code as Code3,
-  Extends as Extends3,
-  For as For5,
-  If as If3,
-  In as In3,
-  Index as Index3,
-  Literal as Literal10,
-  Obj as Obj6,
-  Op as Op9,
-  Param as Param3,
-  Slice as Slice3,
-  Switch as Switch4,
-  Try as Try4,
-  Value as Value12,
-  While as While4
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-
-// src/util/expandToIncludeParens.ts
-import { SourceType as SourceType15 } from "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 !== SourceType15.LPAREN) {
-    return null;
-  }
-  if (tokenAfter === null || tokenAfter.type !== SourceType15.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
-import { SourceType as SourceType16 } from "coffee-lex";
-import { inspect as inspect9 } from "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(SourceType16.LBRACKET, SourceType16.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}: ${inspect9(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 Value12) {
-    const lastChild = node.properties[node.properties.length - 1] || node.base;
-    if (lastChild) {
-      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-    }
-  }
-  if (node instanceof Index3 || node instanceof Slice3) {
-    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 Obj6) {
-    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 Op9) {
-    const lastChild = node.second;
-    if (lastChild) {
-      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-    }
-  }
-  if (node instanceof Assign6) {
-    const lastChild = node.value;
-    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-  }
-  if (node instanceof In3) {
-    const lastChild = node.array;
-    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-  }
-  if (node instanceof Call6) {
-    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 Block5) {
-    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 If3) {
-    const lastChild = node.elseBody || node.body;
-    node.locationData = mergeLocations(node.locationData, lastChild.locationData);
-  }
-  if (node instanceof For5 || node instanceof While4) {
-    const lastChild = node.body;
-    if (lastChild) {
-      node.locationData = mergeLocations(node.locationData, lastChild.locationData);
-    }
-  }
-  if (node instanceof Param3) {
-    if (!node.splat) {
-      const lastChild = node.value || node.name;
-      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-    }
-  }
-  if (node instanceof Code3) {
-    if (node.body) {
-      node.locationData = locationWithLastPosition(node.locationData, node.body.locationData);
-    }
-  }
-  if (node instanceof Class4) {
-    const lastChild = node.body;
-    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-  }
-  if (node instanceof Switch4) {
-    const lastChild = node.otherwise || node.cases[node.cases.length - 1][1];
-    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-  }
-  if (node instanceof Try4) {
-    const lastChild = node.ensure || node.recovery || node.errorVariable || node.attempt;
-    if (lastChild) {
-      node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-    }
-  }
-  if (node instanceof Extends3) {
-    const lastChild = node.parent;
-    node.locationData = locationWithLastPosition(node.locationData, lastChild.locationData);
-  }
-  if (node instanceof Literal10) {
-    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 === SourceType17.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
-import {
-  Base as Base13
-} from "decaffeinate-coffeescript2/lib/coffeescript/nodes.js";
-import { LinesAndColumns } from "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 Base13) {
-      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 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) => lex(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);
-}
-export {
-  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,
-  parse4 as parse,
-  traverse
-};