wice_grid 6.1.3 → 7.1.0

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

@@ -0,0 +1,3557 @@
+// 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
+};