@putout/bundle 2.1.3 → 3.0.1

package/bundle/putout.js

@@ -71154,447 +71154,457 @@ function isValidIdentifier$8(name, reserved = true) {
 
 var lib$m = {};
 
-Object.defineProperty(lib$m, "__esModule", {
-  value: true
-});
-lib$m.readCodePoint = readCodePoint$2;
-lib$m.readInt = readInt$2;
-lib$m.readStringContents = readStringContents$2;
-var _isDigit$2 = function isDigit(code) {
-  return code >= 48 && code <= 57;
-};
-const forbiddenNumericSeparatorSiblings$2 = {
-  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
-  hex: new Set([46, 88, 95, 120])
-};
-const isAllowedNumericSeparatorSibling$2 = {
-  bin: ch => ch === 48 || ch === 49,
-  oct: ch => ch >= 48 && ch <= 55,
-  dec: ch => ch >= 48 && ch <= 57,
-  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
-};
-function readStringContents$2(type, input, pos, lineStart, curLine, errors) {
-  const initialPos = pos;
-  const initialLineStart = lineStart;
-  const initialCurLine = curLine;
-  let out = "";
-  let firstInvalidLoc = null;
-  let chunkStart = pos;
-  const {
-    length
-  } = input;
-  for (;;) {
-    if (pos >= length) {
-      errors.unterminated(initialPos, initialLineStart, initialCurLine);
-      out += input.slice(chunkStart, pos);
-      break;
-    }
-    const ch = input.charCodeAt(pos);
-    if (isStringEnd$2(type, ch, input, pos)) {
-      out += input.slice(chunkStart, pos);
-      break;
-    }
-    if (ch === 92) {
-      out += input.slice(chunkStart, pos);
-      const res = readEscapedChar$2(input, pos, lineStart, curLine, type === "template", errors);
-      if (res.ch === null && !firstInvalidLoc) {
-        firstInvalidLoc = {
-          pos,
-          lineStart,
-          curLine
-        };
-      } else {
-        out += res.ch;
-      }
-      ({
-        pos,
-        lineStart,
-        curLine
-      } = res);
-      chunkStart = pos;
-    } else if (ch === 8232 || ch === 8233) {
-      ++pos;
-      ++curLine;
-      lineStart = pos;
-    } else if (ch === 10 || ch === 13) {
-      if (type === "template") {
-        out += input.slice(chunkStart, pos) + "\n";
-        ++pos;
-        if (ch === 13 && input.charCodeAt(pos) === 10) {
-          ++pos;
-        }
-        ++curLine;
-        chunkStart = lineStart = pos;
-      } else {
-        errors.unterminated(initialPos, initialLineStart, initialCurLine);
-      }
-    } else {
-      ++pos;
-    }
-  }
-  return {
-    pos,
-    str: out,
-    firstInvalidLoc,
-    lineStart,
-    curLine,
-    containsInvalid: !!firstInvalidLoc
-  };
-}
-function isStringEnd$2(type, ch, input, pos) {
-  if (type === "template") {
-    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
-  }
-  return ch === (type === "double" ? 34 : 39);
-}
-function readEscapedChar$2(input, pos, lineStart, curLine, inTemplate, errors) {
-  const throwOnInvalid = !inTemplate;
-  pos++;
-  const res = ch => ({
-    pos,
-    ch,
-    lineStart,
-    curLine
-  });
-  const ch = input.charCodeAt(pos++);
-  switch (ch) {
-    case 110:
-      return res("\n");
-    case 114:
-      return res("\r");
-    case 120:
-      {
-        let code;
-        ({
-          code,
-          pos
-        } = readHexChar$2(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
-        return res(code === null ? null : String.fromCharCode(code));
-      }
-    case 117:
-      {
-        let code;
-        ({
-          code,
-          pos
-        } = readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors));
-        return res(code === null ? null : String.fromCodePoint(code));
-      }
-    case 116:
-      return res("\t");
-    case 98:
-      return res("\b");
-    case 118:
-      return res("\u000b");
-    case 102:
-      return res("\f");
-    case 13:
-      if (input.charCodeAt(pos) === 10) {
-        ++pos;
-      }
-    case 10:
-      lineStart = pos;
-      ++curLine;
-    case 8232:
-    case 8233:
-      return res("");
-    case 56:
-    case 57:
-      if (inTemplate) {
-        return res(null);
-      } else {
-        errors.strictNumericEscape(pos - 1, lineStart, curLine);
-      }
-    default:
-      if (ch >= 48 && ch <= 55) {
-        const startPos = pos - 1;
-        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
-        let octalStr = match[0];
-        let octal = parseInt(octalStr, 8);
-        if (octal > 255) {
-          octalStr = octalStr.slice(0, -1);
-          octal = parseInt(octalStr, 8);
-        }
-        pos += octalStr.length - 1;
-        const next = input.charCodeAt(pos);
-        if (octalStr !== "0" || next === 56 || next === 57) {
-          if (inTemplate) {
-            return res(null);
-          } else {
-            errors.strictNumericEscape(startPos, lineStart, curLine);
-          }
-        }
-        return res(String.fromCharCode(octal));
-      }
-      return res(String.fromCharCode(ch));
-  }
-}
-function readHexChar$2(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
-  const initialPos = pos;
-  let n;
-  ({
-    n,
-    pos
-  } = readInt$2(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
-  if (n === null) {
-    if (throwOnInvalid) {
-      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
-    } else {
-      pos = initialPos - 1;
-    }
-  }
-  return {
-    code: n,
-    pos
-  };
-}
-function readInt$2(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
-  const start = pos;
-  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$2.hex : forbiddenNumericSeparatorSiblings$2.decBinOct;
-  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$2.hex : radix === 10 ? isAllowedNumericSeparatorSibling$2.dec : radix === 8 ? isAllowedNumericSeparatorSibling$2.oct : isAllowedNumericSeparatorSibling$2.bin;
-  let invalid = false;
-  let total = 0;
-  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-    const code = input.charCodeAt(pos);
-    let val;
-    if (code === 95 && allowNumSeparator !== "bail") {
-      const prev = input.charCodeAt(pos - 1);
-      const next = input.charCodeAt(pos + 1);
-      if (!allowNumSeparator) {
-        if (bailOnError) return {
-          n: null,
-          pos
-        };
-        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
-      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
-        if (bailOnError) return {
-          n: null,
-          pos
-        };
-        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
-      }
-      ++pos;
-      continue;
-    }
-    if (code >= 97) {
-      val = code - 97 + 10;
-    } else if (code >= 65) {
-      val = code - 65 + 10;
-    } else if (_isDigit$2(code)) {
-      val = code - 48;
-    } else {
-      val = Infinity;
-    }
-    if (val >= radix) {
-      if (val <= 9 && bailOnError) {
-        return {
-          n: null,
-          pos
-        };
-      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
-        val = 0;
-      } else if (forceLen) {
-        val = 0;
-        invalid = true;
-      } else {
-        break;
-      }
-    }
-    ++pos;
-    total = total * radix + val;
-  }
-  if (pos === start || len != null && pos - start !== len || invalid) {
-    return {
-      n: null,
-      pos
-    };
-  }
-  return {
-    n: total,
-    pos
-  };
-}
-function readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors) {
-  const ch = input.charCodeAt(pos);
-  let code;
-  if (ch === 123) {
-    ++pos;
-    ({
-      code,
-      pos
-    } = readHexChar$2(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
-    ++pos;
-    if (code !== null && code > 0x10ffff) {
-      if (throwOnInvalid) {
-        errors.invalidCodePoint(pos, lineStart, curLine);
-      } else {
-        return {
-          code: null,
-          pos
-        };
-      }
-    }
-  } else {
-    ({
-      code,
-      pos
-    } = readHexChar$2(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
-  }
-  return {
-    code,
-    pos
-  };
-}
-
-var constants$4 = {};
-
-Object.defineProperty(constants$4, "__esModule", {
-  value: true
-});
-constants$4.UPDATE_OPERATORS = constants$4.UNARY_OPERATORS = constants$4.STRING_UNARY_OPERATORS = constants$4.STATEMENT_OR_BLOCK_KEYS = constants$4.NUMBER_UNARY_OPERATORS = constants$4.NUMBER_BINARY_OPERATORS = constants$4.NOT_LOCAL_BINDING = constants$4.LOGICAL_OPERATORS = constants$4.INHERIT_KEYS = constants$4.FOR_INIT_KEYS = constants$4.FLATTENABLE_KEYS = constants$4.EQUALITY_BINARY_OPERATORS = constants$4.COMPARISON_BINARY_OPERATORS = constants$4.COMMENT_KEYS = constants$4.BOOLEAN_UNARY_OPERATORS = constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$4.BOOLEAN_BINARY_OPERATORS = constants$4.BLOCK_SCOPED_SYMBOL = constants$4.BINARY_OPERATORS = constants$4.ASSIGNMENT_OPERATORS = void 0;
-const STATEMENT_OR_BLOCK_KEYS$5 = ["consequent", "body", "alternate"];
-constants$4.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$5;
-const FLATTENABLE_KEYS$4 = ["body", "expressions"];
-constants$4.FLATTENABLE_KEYS = FLATTENABLE_KEYS$4;
-const FOR_INIT_KEYS$4 = ["left", "init"];
-constants$4.FOR_INIT_KEYS = FOR_INIT_KEYS$4;
-const COMMENT_KEYS$4 = ["leadingComments", "trailingComments", "innerComments"];
-constants$4.COMMENT_KEYS = COMMENT_KEYS$4;
-const LOGICAL_OPERATORS$5 = ["||", "&&", "??"];
-constants$4.LOGICAL_OPERATORS = LOGICAL_OPERATORS$5;
-const UPDATE_OPERATORS$4 = ["++", "--"];
-constants$4.UPDATE_OPERATORS = UPDATE_OPERATORS$4;
-const BOOLEAN_NUMBER_BINARY_OPERATORS$5 = [">", "<", ">=", "<="];
-constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$5;
-const EQUALITY_BINARY_OPERATORS$4 = ["==", "===", "!=", "!=="];
-constants$4.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$4;
-const COMPARISON_BINARY_OPERATORS$4 = [...EQUALITY_BINARY_OPERATORS$4, "in", "instanceof"];
-constants$4.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$4;
-const BOOLEAN_BINARY_OPERATORS$4 = [...COMPARISON_BINARY_OPERATORS$4, ...BOOLEAN_NUMBER_BINARY_OPERATORS$5];
-constants$4.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$4;
-const NUMBER_BINARY_OPERATORS$4 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
-constants$4.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$4;
-const BINARY_OPERATORS$4 = ["+", ...NUMBER_BINARY_OPERATORS$4, ...BOOLEAN_BINARY_OPERATORS$4, "|>"];
-constants$4.BINARY_OPERATORS = BINARY_OPERATORS$4;
-const ASSIGNMENT_OPERATORS$4 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$4.map(op => op + "="), ...LOGICAL_OPERATORS$5.map(op => op + "=")];
-constants$4.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$4;
-const BOOLEAN_UNARY_OPERATORS$4 = ["delete", "!"];
-constants$4.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$4;
-const NUMBER_UNARY_OPERATORS$4 = ["+", "-", "~"];
-constants$4.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$4;
-const STRING_UNARY_OPERATORS$4 = ["typeof"];
-constants$4.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$4;
-const UNARY_OPERATORS$4 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$4, ...NUMBER_UNARY_OPERATORS$4, ...STRING_UNARY_OPERATORS$4];
-constants$4.UNARY_OPERATORS = UNARY_OPERATORS$4;
-const INHERIT_KEYS$4 = {
-  optional: ["typeAnnotation", "typeParameters", "returnType"],
-  force: ["start", "loc", "end"]
-};
-constants$4.INHERIT_KEYS = INHERIT_KEYS$4;
-const BLOCK_SCOPED_SYMBOL$4 = Symbol.for("var used to be block scoped");
-constants$4.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$4;
-const NOT_LOCAL_BINDING$5 = Symbol.for("should not be considered a local binding");
-constants$4.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$5;
-
-var utils$5 = {};
-
-var hasRequiredUtils$4;
+var hasRequiredLib$8;
 
-function requireUtils$4 () {
-	if (hasRequiredUtils$4) return utils$5;
-	hasRequiredUtils$4 = 1;
+function requireLib$8 () {
+	if (hasRequiredLib$8) return lib$m;
+	hasRequiredLib$8 = 1;
 
-	Object.defineProperty(utils$5, "__esModule", {
+	Object.defineProperty(lib$m, "__esModule", {
 	  value: true
 	});
-	utils$5.VISITOR_KEYS = utils$5.NODE_PARENT_VALIDATIONS = utils$5.NODE_FIELDS = utils$5.FLIPPED_ALIAS_KEYS = utils$5.DEPRECATED_KEYS = utils$5.BUILDER_KEYS = utils$5.ALIAS_KEYS = void 0;
-	utils$5.arrayOf = arrayOf;
-	utils$5.arrayOfType = arrayOfType;
-	utils$5.assertEach = assertEach;
-	utils$5.assertNodeOrValueType = assertNodeOrValueType;
-	utils$5.assertNodeType = assertNodeType;
-	utils$5.assertOneOf = assertOneOf;
-	utils$5.assertOptionalChainStart = assertOptionalChainStart;
-	utils$5.assertShape = assertShape;
-	utils$5.assertValueType = assertValueType;
-	utils$5.chain = chain;
-	utils$5.default = defineType;
-	utils$5.defineAliasedType = defineAliasedType;
-	utils$5.typeIs = typeIs;
-	utils$5.validate = validate;
-	utils$5.validateArrayOfType = validateArrayOfType;
-	utils$5.validateOptional = validateOptional;
-	utils$5.validateOptionalType = validateOptionalType;
-	utils$5.validateType = validateType;
-	var _is = requireIs$4();
-	var _validate = requireValidate$4();
-	const VISITOR_KEYS = {};
-	utils$5.VISITOR_KEYS = VISITOR_KEYS;
-	const ALIAS_KEYS = {};
-	utils$5.ALIAS_KEYS = ALIAS_KEYS;
-	const FLIPPED_ALIAS_KEYS = {};
-	utils$5.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
-	const NODE_FIELDS = {};
-	utils$5.NODE_FIELDS = NODE_FIELDS;
-	const BUILDER_KEYS = {};
-	utils$5.BUILDER_KEYS = BUILDER_KEYS;
-	const DEPRECATED_KEYS = {};
-	utils$5.DEPRECATED_KEYS = DEPRECATED_KEYS;
-	const NODE_PARENT_VALIDATIONS = {};
-	utils$5.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
-	function getType(val) {
-	  if (Array.isArray(val)) {
-	    return "array";
-	  } else if (val === null) {
-	    return "null";
-	  } else {
-	    return typeof val;
+	lib$m.readCodePoint = readCodePoint;
+	lib$m.readInt = readInt;
+	lib$m.readStringContents = readStringContents;
+	var _isDigit = function isDigit(code) {
+	  return code >= 48 && code <= 57;
+	};
+	const forbiddenNumericSeparatorSiblings = {
+	  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+	  hex: new Set([46, 88, 95, 120])
+	};
+	const isAllowedNumericSeparatorSibling = {
+	  bin: ch => ch === 48 || ch === 49,
+	  oct: ch => ch >= 48 && ch <= 55,
+	  dec: ch => ch >= 48 && ch <= 57,
+	  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+	};
+	function readStringContents(type, input, pos, lineStart, curLine, errors) {
+	  const initialPos = pos;
+	  const initialLineStart = lineStart;
+	  const initialCurLine = curLine;
+	  let out = "";
+	  let firstInvalidLoc = null;
+	  let chunkStart = pos;
+	  const {
+	    length
+	  } = input;
+	  for (;;) {
+	    if (pos >= length) {
+	      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+	      out += input.slice(chunkStart, pos);
+	      break;
+	    }
+	    const ch = input.charCodeAt(pos);
+	    if (isStringEnd(type, ch, input, pos)) {
+	      out += input.slice(chunkStart, pos);
+	      break;
+	    }
+	    if (ch === 92) {
+	      out += input.slice(chunkStart, pos);
+	      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+	      if (res.ch === null && !firstInvalidLoc) {
+	        firstInvalidLoc = {
+	          pos,
+	          lineStart,
+	          curLine
+	        };
+	      } else {
+	        out += res.ch;
+	      }
+	      ({
+	        pos,
+	        lineStart,
+	        curLine
+	      } = res);
+	      chunkStart = pos;
+	    } else if (ch === 8232 || ch === 8233) {
+	      ++pos;
+	      ++curLine;
+	      lineStart = pos;
+	    } else if (ch === 10 || ch === 13) {
+	      if (type === "template") {
+	        out += input.slice(chunkStart, pos) + "\n";
+	        ++pos;
+	        if (ch === 13 && input.charCodeAt(pos) === 10) {
+	          ++pos;
+	        }
+	        ++curLine;
+	        chunkStart = lineStart = pos;
+	      } else {
+	        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+	      }
+	    } else {
+	      ++pos;
+	    }
 	  }
-	}
-	function validate(validate) {
-	  return {
-	    validate
-	  };
-	}
-	function typeIs(typeName) {
-	  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
-	}
-	function validateType(typeName) {
-	  return validate(typeIs(typeName));
-	}
-	function validateOptional(validate) {
-	  return {
-	    validate,
-	    optional: true
-	  };
-	}
-	function validateOptionalType(typeName) {
 	  return {
-	    validate: typeIs(typeName),
-	    optional: true
+	    pos,
+	    str: out,
+	    firstInvalidLoc,
+	    lineStart,
+	    curLine,
+	    containsInvalid: !!firstInvalidLoc
 	  };
 	}
-	function arrayOf(elementType) {
-	  return chain(assertValueType("array"), assertEach(elementType));
-	}
-	function arrayOfType(typeName) {
-	  return arrayOf(typeIs(typeName));
-	}
-	function validateArrayOfType(typeName) {
-	  return validate(arrayOfType(typeName));
-	}
-	function assertEach(callback) {
-	  function validator(node, key, val) {
-	    if (!Array.isArray(val)) return;
-	    for (let i = 0; i < val.length; i++) {
-	      const subkey = `${key}[${i}]`;
-	      const v = val[i];
-	      callback(node, subkey, v);
-	      (0, _validate.validateChild)(node, subkey, v);
-	    }
+	function isStringEnd(type, ch, input, pos) {
+	  if (type === "template") {
+	    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
 	  }
-	  validator.each = callback;
-	  return validator;
+	  return ch === (type === "double" ? 34 : 39);
+	}
+	function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+	  const throwOnInvalid = !inTemplate;
+	  pos++;
+	  const res = ch => ({
+	    pos,
+	    ch,
+	    lineStart,
+	    curLine
+	  });
+	  const ch = input.charCodeAt(pos++);
+	  switch (ch) {
+	    case 110:
+	      return res("\n");
+	    case 114:
+	      return res("\r");
+	    case 120:
+	      {
+	        let code;
+	        ({
+	          code,
+	          pos
+	        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+	        return res(code === null ? null : String.fromCharCode(code));
+	      }
+	    case 117:
+	      {
+	        let code;
+	        ({
+	          code,
+	          pos
+	        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+	        return res(code === null ? null : String.fromCodePoint(code));
+	      }
+	    case 116:
+	      return res("\t");
+	    case 98:
+	      return res("\b");
+	    case 118:
+	      return res("\u000b");
+	    case 102:
+	      return res("\f");
+	    case 13:
+	      if (input.charCodeAt(pos) === 10) {
+	        ++pos;
+	      }
+	    case 10:
+	      lineStart = pos;
+	      ++curLine;
+	    case 8232:
+	    case 8233:
+	      return res("");
+	    case 56:
+	    case 57:
+	      if (inTemplate) {
+	        return res(null);
+	      } else {
+	        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+	      }
+	    default:
+	      if (ch >= 48 && ch <= 55) {
+	        const startPos = pos - 1;
+	        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
+	        let octalStr = match[0];
+	        let octal = parseInt(octalStr, 8);
+	        if (octal > 255) {
+	          octalStr = octalStr.slice(0, -1);
+	          octal = parseInt(octalStr, 8);
+	        }
+	        pos += octalStr.length - 1;
+	        const next = input.charCodeAt(pos);
+	        if (octalStr !== "0" || next === 56 || next === 57) {
+	          if (inTemplate) {
+	            return res(null);
+	          } else {
+	            errors.strictNumericEscape(startPos, lineStart, curLine);
+	          }
+	        }
+	        return res(String.fromCharCode(octal));
+	      }
+	      return res(String.fromCharCode(ch));
+	  }
+	}
+	function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+	  const initialPos = pos;
+	  let n;
+	  ({
+	    n,
+	    pos
+	  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+	  if (n === null) {
+	    if (throwOnInvalid) {
+	      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+	    } else {
+	      pos = initialPos - 1;
+	    }
+	  }
+	  return {
+	    code: n,
+	    pos
+	  };
+	}
+	function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+	  const start = pos;
+	  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+	  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+	  let invalid = false;
+	  let total = 0;
+	  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	    const code = input.charCodeAt(pos);
+	    let val;
+	    if (code === 95 && allowNumSeparator !== "bail") {
+	      const prev = input.charCodeAt(pos - 1);
+	      const next = input.charCodeAt(pos + 1);
+	      if (!allowNumSeparator) {
+	        if (bailOnError) return {
+	          n: null,
+	          pos
+	        };
+	        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+	      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+	        if (bailOnError) return {
+	          n: null,
+	          pos
+	        };
+	        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+	      }
+	      ++pos;
+	      continue;
+	    }
+	    if (code >= 97) {
+	      val = code - 97 + 10;
+	    } else if (code >= 65) {
+	      val = code - 65 + 10;
+	    } else if (_isDigit(code)) {
+	      val = code - 48;
+	    } else {
+	      val = Infinity;
+	    }
+	    if (val >= radix) {
+	      if (val <= 9 && bailOnError) {
+	        return {
+	          n: null,
+	          pos
+	        };
+	      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+	        val = 0;
+	      } else if (forceLen) {
+	        val = 0;
+	        invalid = true;
+	      } else {
+	        break;
+	      }
+	    }
+	    ++pos;
+	    total = total * radix + val;
+	  }
+	  if (pos === start || len != null && pos - start !== len || invalid) {
+	    return {
+	      n: null,
+	      pos
+	    };
+	  }
+	  return {
+	    n: total,
+	    pos
+	  };
+	}
+	function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+	  const ch = input.charCodeAt(pos);
+	  let code;
+	  if (ch === 123) {
+	    ++pos;
+	    ({
+	      code,
+	      pos
+	    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+	    ++pos;
+	    if (code !== null && code > 0x10ffff) {
+	      if (throwOnInvalid) {
+	        errors.invalidCodePoint(pos, lineStart, curLine);
+	      } else {
+	        return {
+	          code: null,
+	          pos
+	        };
+	      }
+	    }
+	  } else {
+	    ({
+	      code,
+	      pos
+	    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+	  }
+	  return {
+	    code,
+	    pos
+	  };
+	}
+
+	
+	return lib$m;
+}
+
+var constants$4 = {};
+
+Object.defineProperty(constants$4, "__esModule", {
+  value: true
+});
+constants$4.UPDATE_OPERATORS = constants$4.UNARY_OPERATORS = constants$4.STRING_UNARY_OPERATORS = constants$4.STATEMENT_OR_BLOCK_KEYS = constants$4.NUMBER_UNARY_OPERATORS = constants$4.NUMBER_BINARY_OPERATORS = constants$4.NOT_LOCAL_BINDING = constants$4.LOGICAL_OPERATORS = constants$4.INHERIT_KEYS = constants$4.FOR_INIT_KEYS = constants$4.FLATTENABLE_KEYS = constants$4.EQUALITY_BINARY_OPERATORS = constants$4.COMPARISON_BINARY_OPERATORS = constants$4.COMMENT_KEYS = constants$4.BOOLEAN_UNARY_OPERATORS = constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$4.BOOLEAN_BINARY_OPERATORS = constants$4.BLOCK_SCOPED_SYMBOL = constants$4.BINARY_OPERATORS = constants$4.ASSIGNMENT_OPERATORS = void 0;
+const STATEMENT_OR_BLOCK_KEYS$5 = ["consequent", "body", "alternate"];
+constants$4.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$5;
+const FLATTENABLE_KEYS$4 = ["body", "expressions"];
+constants$4.FLATTENABLE_KEYS = FLATTENABLE_KEYS$4;
+const FOR_INIT_KEYS$4 = ["left", "init"];
+constants$4.FOR_INIT_KEYS = FOR_INIT_KEYS$4;
+const COMMENT_KEYS$4 = ["leadingComments", "trailingComments", "innerComments"];
+constants$4.COMMENT_KEYS = COMMENT_KEYS$4;
+const LOGICAL_OPERATORS$5 = ["||", "&&", "??"];
+constants$4.LOGICAL_OPERATORS = LOGICAL_OPERATORS$5;
+const UPDATE_OPERATORS$4 = ["++", "--"];
+constants$4.UPDATE_OPERATORS = UPDATE_OPERATORS$4;
+const BOOLEAN_NUMBER_BINARY_OPERATORS$5 = [">", "<", ">=", "<="];
+constants$4.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$5;
+const EQUALITY_BINARY_OPERATORS$4 = ["==", "===", "!=", "!=="];
+constants$4.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$4;
+const COMPARISON_BINARY_OPERATORS$4 = [...EQUALITY_BINARY_OPERATORS$4, "in", "instanceof"];
+constants$4.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$4;
+const BOOLEAN_BINARY_OPERATORS$4 = [...COMPARISON_BINARY_OPERATORS$4, ...BOOLEAN_NUMBER_BINARY_OPERATORS$5];
+constants$4.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$4;
+const NUMBER_BINARY_OPERATORS$4 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+constants$4.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$4;
+const BINARY_OPERATORS$4 = ["+", ...NUMBER_BINARY_OPERATORS$4, ...BOOLEAN_BINARY_OPERATORS$4, "|>"];
+constants$4.BINARY_OPERATORS = BINARY_OPERATORS$4;
+const ASSIGNMENT_OPERATORS$4 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$4.map(op => op + "="), ...LOGICAL_OPERATORS$5.map(op => op + "=")];
+constants$4.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$4;
+const BOOLEAN_UNARY_OPERATORS$4 = ["delete", "!"];
+constants$4.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$4;
+const NUMBER_UNARY_OPERATORS$4 = ["+", "-", "~"];
+constants$4.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$4;
+const STRING_UNARY_OPERATORS$4 = ["typeof"];
+constants$4.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$4;
+const UNARY_OPERATORS$4 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$4, ...NUMBER_UNARY_OPERATORS$4, ...STRING_UNARY_OPERATORS$4];
+constants$4.UNARY_OPERATORS = UNARY_OPERATORS$4;
+const INHERIT_KEYS$4 = {
+  optional: ["typeAnnotation", "typeParameters", "returnType"],
+  force: ["start", "loc", "end"]
+};
+constants$4.INHERIT_KEYS = INHERIT_KEYS$4;
+const BLOCK_SCOPED_SYMBOL$4 = Symbol.for("var used to be block scoped");
+constants$4.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$4;
+const NOT_LOCAL_BINDING$5 = Symbol.for("should not be considered a local binding");
+constants$4.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$5;
+
+var utils$5 = {};
+
+var hasRequiredUtils$4;
+
+function requireUtils$4 () {
+	if (hasRequiredUtils$4) return utils$5;
+	hasRequiredUtils$4 = 1;
+
+	Object.defineProperty(utils$5, "__esModule", {
+	  value: true
+	});
+	utils$5.VISITOR_KEYS = utils$5.NODE_PARENT_VALIDATIONS = utils$5.NODE_FIELDS = utils$5.FLIPPED_ALIAS_KEYS = utils$5.DEPRECATED_KEYS = utils$5.BUILDER_KEYS = utils$5.ALIAS_KEYS = void 0;
+	utils$5.arrayOf = arrayOf;
+	utils$5.arrayOfType = arrayOfType;
+	utils$5.assertEach = assertEach;
+	utils$5.assertNodeOrValueType = assertNodeOrValueType;
+	utils$5.assertNodeType = assertNodeType;
+	utils$5.assertOneOf = assertOneOf;
+	utils$5.assertOptionalChainStart = assertOptionalChainStart;
+	utils$5.assertShape = assertShape;
+	utils$5.assertValueType = assertValueType;
+	utils$5.chain = chain;
+	utils$5.default = defineType;
+	utils$5.defineAliasedType = defineAliasedType;
+	utils$5.typeIs = typeIs;
+	utils$5.validate = validate;
+	utils$5.validateArrayOfType = validateArrayOfType;
+	utils$5.validateOptional = validateOptional;
+	utils$5.validateOptionalType = validateOptionalType;
+	utils$5.validateType = validateType;
+	var _is = requireIs$4();
+	var _validate = requireValidate$4();
+	const VISITOR_KEYS = {};
+	utils$5.VISITOR_KEYS = VISITOR_KEYS;
+	const ALIAS_KEYS = {};
+	utils$5.ALIAS_KEYS = ALIAS_KEYS;
+	const FLIPPED_ALIAS_KEYS = {};
+	utils$5.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
+	const NODE_FIELDS = {};
+	utils$5.NODE_FIELDS = NODE_FIELDS;
+	const BUILDER_KEYS = {};
+	utils$5.BUILDER_KEYS = BUILDER_KEYS;
+	const DEPRECATED_KEYS = {};
+	utils$5.DEPRECATED_KEYS = DEPRECATED_KEYS;
+	const NODE_PARENT_VALIDATIONS = {};
+	utils$5.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
+	function getType(val) {
+	  if (Array.isArray(val)) {
+	    return "array";
+	  } else if (val === null) {
+	    return "null";
+	  } else {
+	    return typeof val;
+	  }
+	}
+	function validate(validate) {
+	  return {
+	    validate
+	  };
+	}
+	function typeIs(typeName) {
+	  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
+	}
+	function validateType(typeName) {
+	  return validate(typeIs(typeName));
+	}
+	function validateOptional(validate) {
+	  return {
+	    validate,
+	    optional: true
+	  };
+	}
+	function validateOptionalType(typeName) {
+	  return {
+	    validate: typeIs(typeName),
+	    optional: true
+	  };
+	}
+	function arrayOf(elementType) {
+	  return chain(assertValueType("array"), assertEach(elementType));
+	}
+	function arrayOfType(typeName) {
+	  return arrayOf(typeIs(typeName));
+	}
+	function validateArrayOfType(typeName) {
+	  return validate(arrayOfType(typeName));
+	}
+	function assertEach(callback) {
+	  function validator(node, key, val) {
+	    if (!Array.isArray(val)) return;
+	    for (let i = 0; i < val.length; i++) {
+	      const subkey = `${key}[${i}]`;
+	      const v = val[i];
+	      callback(node, subkey, v);
+	      (0, _validate.validateChild)(node, subkey, v);
+	    }
+	  }
+	  validator.each = callback;
+	  return validator;
 	}
 	function assertOneOf(...values) {
 	  function validate(node, key, val) {
@@ -71798,7 +71808,7 @@ function requireCore$4 () {
 	var _is = requireIs$4();
 	var _isValidIdentifier = isValidIdentifier$9;
 	var _helperValidatorIdentifier = lib$n;
-	var _helperStringParser = lib$m;
+	var _helperStringParser = requireLib$8();
 	var _constants = constants$4;
 	var _utils = requireUtils$4();
 	const defineType = (0, _utils.defineAliasedType)("Standardized");
@@ -74957,7 +74967,7 @@ function requireValidateNode$4 () {
 	});
 	validateNode$4.default = validateNode;
 	var _validate = requireValidate$4();
-	var _ = requireLib$8();
+	var _ = requireLib$7();
 	function validateNode(node) {
 	  const keys = _.BUILDER_KEYS[node.type];
 	  for (const key of keys) {
@@ -76973,7 +76983,7 @@ function requireCleanJSXElementLiteralChild$4 () {
 	});
 	cleanJSXElementLiteralChild$4.default = cleanJSXElementLiteralChild;
 	var _generated = requireGenerated$4();
-	var _ = requireLib$8();
+	var _ = requireLib$7();
 	function cleanJSXElementLiteralChild(child, args) {
 	  const lines = child.value.split(/\r\n|\n|\r/);
 	  let lastNonEmptyLine = 0;
@@ -81059,7 +81069,7 @@ function requirePrependToMemberExpression$4 () {
 	});
 	prependToMemberExpression$4.default = prependToMemberExpression;
 	var _generated = requireGenerated$4();
-	var _ = requireLib$8();
+	var _ = requireLib$7();
 	function prependToMemberExpression(member, prepend) {
 	  if ((0, _.isSuper)(member.object)) {
 	    throw new Error("Cannot prepend node to super property access (`super.foo`).");
@@ -81411,11 +81421,11 @@ function isVar$9(node) {
   }) && !node[_constants$k.BLOCK_SCOPED_SYMBOL];
 }
 
-var hasRequiredLib$8;
+var hasRequiredLib$7;
 
-function requireLib$8 () {
-	if (hasRequiredLib$8) return lib$o;
-	hasRequiredLib$8 = 1;
+function requireLib$7 () {
+	if (hasRequiredLib$7) return lib$o;
+	hasRequiredLib$7 = 1;
 	(function (exports) {
 
 		Object.defineProperty(exports, "__esModule", {
@@ -81998,7 +82008,7 @@ visitors.isExplodedVisitor = isExplodedVisitor;
 visitors.merge = merge$4;
 visitors.verify = verify;
 var virtualTypes = virtualTypes$1;
-var _t$p = requireLib$8();
+var _t$p = requireLib$7();
 const {
   DEPRECATED_KEYS,
   DEPRECATED_ALIASES: DEPRECATED_ALIASES$4,
@@ -82265,7 +82275,7 @@ Object.defineProperty(lib$l, "__esModule", {
   value: true
 });
 lib$l.default = splitExportDeclaration;
-var _t$o = requireLib$8();
+var _t$o = requireLib$7();
 const {
   cloneNode: cloneNode$b,
   exportNamedDeclaration,
@@ -82383,7 +82393,7 @@ function requireRenamer () {
 	});
 	renamer.default = void 0;
 	var _helperSplitExportDeclaration = lib$l;
-	var t = requireLib$8();
+	var t = requireLib$7();
 	var _helperEnvironmentVisitor = lib$k;
 	var _traverseNode = requireTraverseNode();
 	var _visitors = visitors;
@@ -84183,10 +84193,10 @@ function requireScope () {
 	});
 	scope.default = void 0;
 	var _renamer = requireRenamer();
-	var _index = requireLib$4();
+	var _index = requireLib$3();
 	var _binding = binding;
 	var _globals = globals;
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	var t = _t;
 	var _cache = cache;
 	var _visitors = visitors;
@@ -86791,7 +86801,7 @@ Object.defineProperty(whitespace$1, "__esModule", {
   value: true
 });
 whitespace$1.nodes = void 0;
-var _t$n = requireLib$8();
+var _t$n = requireLib$7();
 const {
   FLIPPED_ALIAS_KEYS: FLIPPED_ALIAS_KEYS$1,
   isArrayExpression: isArrayExpression$6,
@@ -86959,7 +86969,7 @@ parentheses.UnaryLike = UnaryLike;
 parentheses.IntersectionTypeAnnotation = parentheses.UnionTypeAnnotation = UnionTypeAnnotation;
 parentheses.UpdateExpression = UpdateExpression$1;
 parentheses.AwaitExpression = parentheses.YieldExpression = YieldExpression$1;
-var _t$m = requireLib$8();
+var _t$m = requireLib$7();
 const {
   isArrayTypeAnnotation: isArrayTypeAnnotation$5,
   isArrowFunctionExpression: isArrowFunctionExpression$6,
@@ -87243,7 +87253,7 @@ node.needsWhitespaceAfter = needsWhitespaceAfter;
 node.needsWhitespaceBefore = needsWhitespaceBefore;
 var whitespace = whitespace$1;
 var parens$2 = parentheses;
-var _t$l = requireLib$8();
+var _t$l = requireLib$7();
 const {
   FLIPPED_ALIAS_KEYS,
   isCallExpression: isCallExpression$8,
@@ -87372,7 +87382,7 @@ expressions$2.UpdateExpression = UpdateExpression;
 expressions$2.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
 expressions$2.YieldExpression = YieldExpression;
 expressions$2._shouldPrintDecoratorsBeforeExport = _shouldPrintDecoratorsBeforeExport;
-var _t$k = requireLib$8();
+var _t$k = requireLib$7();
 var n$1 = node;
 const {
   isCallExpression: isCallExpression$7,
@@ -87671,7 +87681,7 @@ statements$4.VariableDeclaration = VariableDeclaration$1;
 statements$4.VariableDeclarator = VariableDeclarator;
 statements$4.WhileStatement = WhileStatement$1;
 statements$4.WithStatement = WithStatement;
-var _t$j = requireLib$8();
+var _t$j = requireLib$7();
 const {
   isFor: isFor$4,
   isForStatement: isForStatement$5,
@@ -87938,7 +87948,7 @@ classes.ClassPrivateProperty = ClassPrivateProperty$1;
 classes.ClassProperty = ClassProperty$2;
 classes.StaticBlock = StaticBlock$1;
 classes._classMethodHead = _classMethodHead;
-var _t$i = requireLib$8();
+var _t$i = requireLib$7();
 const {
   isExportDefaultDeclaration: isExportDefaultDeclaration$4,
   isExportNamedDeclaration: isExportNamedDeclaration$4
@@ -88113,7 +88123,7 @@ methods._param = _param;
 methods._parameters = _parameters;
 methods._params = _params;
 methods._predicate = _predicate;
-var _t$h = requireLib$8();
+var _t$h = requireLib$7();
 const {
   isIdentifier: isIdentifier$k
 } = _t$h;
@@ -88289,7 +88299,7 @@ modules.ImportDefaultSpecifier = ImportDefaultSpecifier;
 modules.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
 modules.ImportSpecifier = ImportSpecifier;
 modules._printAttributes = _printAttributes;
-var _t$g = requireLib$8();
+var _t$g = requireLib$7();
 const {
   isClassDeclaration: isClassDeclaration$4,
   isExportDefaultSpecifier: isExportDefaultSpecifier$4,
@@ -88878,7 +88888,7 @@ types$l.SpreadElement = types$l.RestElement = RestElement$1;
 types$l.StringLiteral = StringLiteral$1;
 types$l.TopicReference = TopicReference;
 types$l.TupleExpression = TupleExpression$1;
-var _t$f = requireLib$8();
+var _t$f = requireLib$7();
 var _jsesc = jsesc_1;
 const {
   isAssignmentPattern: isAssignmentPattern$6,
@@ -89153,7 +89163,7 @@ var flow$5 = {};
 	exports.VoidTypeAnnotation = VoidTypeAnnotation;
 	exports._interfaceish = _interfaceish;
 	exports._variance = _variance;
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	var _modules = modules;
 	var _types2 = types$l;
 	const {
@@ -90790,7 +90800,7 @@ Object.defineProperty(printer, "__esModule", {
 printer.default = void 0;
 var _buffer = buffer;
 var n = node;
-var _t$e = requireLib$8();
+var _t$e = requireLib$7();
 var generatorFunctions = generators;
 const {
   isFunction: isFunction$8,
@@ -91538,7 +91548,7 @@ ancestry.getStatementParent = getStatementParent;
 ancestry.inType = inType;
 ancestry.isAncestor = isAncestor;
 ancestry.isDescendant = isDescendant;
-var _t$d = requireLib$8();
+var _t$d = requireLib$7();
 const {
   VISITOR_KEYS: VISITOR_KEYS$1
 } = _t$d;
@@ -91675,7 +91685,7 @@ Object.defineProperty(util, "__esModule", {
   value: true
 });
 util.createUnionType = createUnionType;
-var _t$c = requireLib$8();
+var _t$c = requireLib$7();
 const {
   createFlowUnionType: createFlowUnionType$4,
   createTSUnionType: createTSUnionType$4,
@@ -91702,7 +91712,7 @@ Object.defineProperty(infererReference, "__esModule", {
   value: true
 });
 infererReference.default = _default$f;
-var _t$b = requireLib$8();
+var _t$b = requireLib$7();
 var _util = util;
 const {
   BOOLEAN_NUMBER_BINARY_OPERATORS: BOOLEAN_NUMBER_BINARY_OPERATORS$4,
@@ -91882,7 +91892,7 @@ function getConditionalAnnotation(binding, path, name) {
 	exports.UnaryExpression = UnaryExpression;
 	exports.UpdateExpression = UpdateExpression;
 	exports.VariableDeclarator = VariableDeclarator;
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	var _infererReference = infererReference;
 	var _util = util;
 	const {
@@ -92067,7 +92077,7 @@ inference.getTypeAnnotation = getTypeAnnotation;
 inference.isBaseType = isBaseType;
 inference.isGenericType = isGenericType;
 var inferers = inferers$1;
-var _t$a = requireLib$8();
+var _t$a = requireLib$7();
 const {
   anyTypeAnnotation,
   isAnyTypeAnnotation: isAnyTypeAnnotation$4,
@@ -94544,20 +94554,20 @@ let State$2 = class State {
     return state;
   }
 };
-var _isDigit$1 = function isDigit(code) {
+var _isDigit$2 = function isDigit(code) {
   return code >= 48 && code <= 57;
 };
-const forbiddenNumericSeparatorSiblings$1 = {
+const forbiddenNumericSeparatorSiblings$2 = {
   decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
   hex: new Set([46, 88, 95, 120])
 };
-const isAllowedNumericSeparatorSibling$1 = {
+const isAllowedNumericSeparatorSibling$2 = {
   bin: ch => ch === 48 || ch === 49,
   oct: ch => ch >= 48 && ch <= 55,
   dec: ch => ch >= 48 && ch <= 57,
   hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
 };
-function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
+function readStringContents$2(type, input, pos, lineStart, curLine, errors) {
   const initialPos = pos;
   const initialLineStart = lineStart;
   const initialCurLine = curLine;
@@ -94574,13 +94584,13 @@ function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
       break;
     }
     const ch = input.charCodeAt(pos);
-    if (isStringEnd$1(type, ch, input, pos)) {
+    if (isStringEnd$2(type, ch, input, pos)) {
       out += input.slice(chunkStart, pos);
       break;
     }
     if (ch === 92) {
       out += input.slice(chunkStart, pos);
-      const res = readEscapedChar$1(input, pos, lineStart, curLine, type === "template", errors);
+      const res = readEscapedChar$2(input, pos, lineStart, curLine, type === "template", errors);
       if (res.ch === null && !firstInvalidLoc) {
         firstInvalidLoc = {
           pos,
@@ -94625,13 +94635,13 @@ function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
     containsInvalid: !!firstInvalidLoc
   };
 }
-function isStringEnd$1(type, ch, input, pos) {
+function isStringEnd$2(type, ch, input, pos) {
   if (type === "template") {
     return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
   }
   return ch === (type === "double" ? 34 : 39);
 }
-function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
+function readEscapedChar$2(input, pos, lineStart, curLine, inTemplate, errors) {
   const throwOnInvalid = !inTemplate;
   pos++;
   const res = ch => ({
@@ -94652,7 +94662,7 @@ function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
         ({
           code,
           pos
-        } = readHexChar$1(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        } = readHexChar$2(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
         return res(code === null ? null : String.fromCharCode(code));
       }
     case 117:
@@ -94661,7 +94671,7 @@ function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
         ({
           code,
           pos
-        } = readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        } = readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors));
         return res(code === null ? null : String.fromCodePoint(code));
       }
     case 116:
@@ -94713,13 +94723,13 @@ function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
       return res(String.fromCharCode(ch));
   }
 }
-function readHexChar$1(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+function readHexChar$2(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
   const initialPos = pos;
   let n;
   ({
     n,
     pos
-  } = readInt$1(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+  } = readInt$2(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
   if (n === null) {
     if (throwOnInvalid) {
       errors.invalidEscapeSequence(initialPos, lineStart, curLine);
@@ -94732,10 +94742,10 @@ function readHexChar$1(input, pos, lineStart, curLine, len, forceLen, throwOnInv
     pos
   };
 }
-function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+function readInt$2(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
   const start = pos;
-  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$1.hex : forbiddenNumericSeparatorSiblings$1.decBinOct;
-  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$1.hex : radix === 10 ? isAllowedNumericSeparatorSibling$1.dec : radix === 8 ? isAllowedNumericSeparatorSibling$1.oct : isAllowedNumericSeparatorSibling$1.bin;
+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$2.hex : forbiddenNumericSeparatorSiblings$2.decBinOct;
+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$2.hex : radix === 10 ? isAllowedNumericSeparatorSibling$2.dec : radix === 8 ? isAllowedNumericSeparatorSibling$2.oct : isAllowedNumericSeparatorSibling$2.bin;
   let invalid = false;
   let total = 0;
   for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
@@ -94764,7 +94774,7 @@ function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
       val = code - 97 + 10;
     } else if (code >= 65) {
       val = code - 65 + 10;
-    } else if (_isDigit$1(code)) {
+    } else if (_isDigit$2(code)) {
       val = code - 48;
     } else {
       val = Infinity;
@@ -94798,7 +94808,7 @@ function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNu
     pos
   };
 }
-function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+function readCodePoint$2(input, pos, lineStart, curLine, throwOnInvalid, errors) {
   const ch = input.charCodeAt(pos);
   let code;
   if (ch === 123) {
@@ -94806,7 +94816,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
     ({
       code,
       pos
-    } = readHexChar$1(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+    } = readHexChar$2(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
     ++pos;
     if (code !== null && code > 0x10ffff) {
       if (throwOnInvalid) {
@@ -94822,7 +94832,7 @@ function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors)
     ({
       code,
       pos
-    } = readHexChar$1(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+    } = readHexChar$2(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
   }
   return {
     code,
@@ -95619,7 +95629,7 @@ class Tokenizer extends CommentsParser {
     const {
       n,
       pos
-    } = readInt$1(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
+    } = readInt$2(this.input, this.state.pos, this.state.lineStart, this.state.curLine, radix, len, forceLen, allowNumSeparator, this.errorHandlers_readInt, false);
     this.state.pos = pos;
     return n;
   }
@@ -95745,7 +95755,7 @@ class Tokenizer extends CommentsParser {
     const {
       code,
       pos
-    } = readCodePoint$1(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
+    } = readCodePoint$2(this.input, this.state.pos, this.state.lineStart, this.state.curLine, throwOnInvalid, this.errorHandlers_readCodePoint);
     this.state.pos = pos;
     return code;
   }
@@ -95755,7 +95765,7 @@ class Tokenizer extends CommentsParser {
       pos,
       curLine,
       lineStart
-    } = readStringContents$1(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
+    } = readStringContents$2(quote === 34 ? "double" : "single", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_string);
     this.state.pos = pos + 1;
     this.state.lineStart = lineStart;
     this.state.curLine = curLine;
@@ -95776,7 +95786,7 @@ class Tokenizer extends CommentsParser {
       pos,
       curLine,
       lineStart
-    } = readStringContents$1("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
+    } = readStringContents$2("template", this.input, this.state.pos + 1, this.state.lineStart, this.state.curLine, this.errorHandlers_readStringContents_template);
     this.state.pos = pos + 1;
     this.state.lineStart = lineStart;
     this.state.curLine = curLine;
@@ -110241,407 +110251,417 @@ function isValidIdentifier$6(name, reserved = true) {
 
 var lib$b = {};
 
-Object.defineProperty(lib$b, "__esModule", {
-  value: true
-});
-lib$b.readCodePoint = readCodePoint;
-lib$b.readInt = readInt;
-lib$b.readStringContents = readStringContents;
-var _isDigit = function isDigit(code) {
-  return code >= 48 && code <= 57;
-};
-const forbiddenNumericSeparatorSiblings = {
-  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
-  hex: new Set([46, 88, 95, 120])
-};
-const isAllowedNumericSeparatorSibling = {
-  bin: ch => ch === 48 || ch === 49,
-  oct: ch => ch >= 48 && ch <= 55,
-  dec: ch => ch >= 48 && ch <= 57,
-  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
-};
-function readStringContents(type, input, pos, lineStart, curLine, errors) {
-  const initialPos = pos;
-  const initialLineStart = lineStart;
-  const initialCurLine = curLine;
-  let out = "";
-  let firstInvalidLoc = null;
-  let chunkStart = pos;
-  const {
-    length
-  } = input;
-  for (;;) {
-    if (pos >= length) {
-      errors.unterminated(initialPos, initialLineStart, initialCurLine);
-      out += input.slice(chunkStart, pos);
-      break;
-    }
-    const ch = input.charCodeAt(pos);
-    if (isStringEnd(type, ch, input, pos)) {
-      out += input.slice(chunkStart, pos);
-      break;
-    }
-    if (ch === 92) {
-      out += input.slice(chunkStart, pos);
-      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
-      if (res.ch === null && !firstInvalidLoc) {
-        firstInvalidLoc = {
-          pos,
-          lineStart,
-          curLine
-        };
-      } else {
-        out += res.ch;
-      }
-      ({
-        pos,
-        lineStart,
-        curLine
-      } = res);
-      chunkStart = pos;
-    } else if (ch === 8232 || ch === 8233) {
-      ++pos;
-      ++curLine;
-      lineStart = pos;
-    } else if (ch === 10 || ch === 13) {
-      if (type === "template") {
-        out += input.slice(chunkStart, pos) + "\n";
-        ++pos;
-        if (ch === 13 && input.charCodeAt(pos) === 10) {
-          ++pos;
-        }
-        ++curLine;
-        chunkStart = lineStart = pos;
-      } else {
-        errors.unterminated(initialPos, initialLineStart, initialCurLine);
-      }
-    } else {
-      ++pos;
-    }
-  }
-  return {
-    pos,
-    str: out,
-    firstInvalidLoc,
-    lineStart,
-    curLine,
-    containsInvalid: !!firstInvalidLoc
-  };
-}
-function isStringEnd(type, ch, input, pos) {
-  if (type === "template") {
-    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
-  }
-  return ch === (type === "double" ? 34 : 39);
-}
-function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
-  const throwOnInvalid = !inTemplate;
-  pos++;
-  const res = ch => ({
-    pos,
-    ch,
-    lineStart,
-    curLine
-  });
-  const ch = input.charCodeAt(pos++);
-  switch (ch) {
-    case 110:
-      return res("\n");
-    case 114:
-      return res("\r");
-    case 120:
-      {
-        let code;
-        ({
-          code,
-          pos
-        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
-        return res(code === null ? null : String.fromCharCode(code));
-      }
-    case 117:
-      {
-        let code;
-        ({
-          code,
-          pos
-        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
-        return res(code === null ? null : String.fromCodePoint(code));
-      }
-    case 116:
-      return res("\t");
-    case 98:
-      return res("\b");
-    case 118:
-      return res("\u000b");
-    case 102:
-      return res("\f");
-    case 13:
-      if (input.charCodeAt(pos) === 10) {
-        ++pos;
-      }
-    case 10:
-      lineStart = pos;
-      ++curLine;
-    case 8232:
-    case 8233:
-      return res("");
-    case 56:
-    case 57:
-      if (inTemplate) {
-        return res(null);
-      } else {
-        errors.strictNumericEscape(pos - 1, lineStart, curLine);
-      }
-    default:
-      if (ch >= 48 && ch <= 55) {
-        const startPos = pos - 1;
-        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
-        let octalStr = match[0];
-        let octal = parseInt(octalStr, 8);
-        if (octal > 255) {
-          octalStr = octalStr.slice(0, -1);
-          octal = parseInt(octalStr, 8);
-        }
-        pos += octalStr.length - 1;
-        const next = input.charCodeAt(pos);
-        if (octalStr !== "0" || next === 56 || next === 57) {
-          if (inTemplate) {
-            return res(null);
-          } else {
-            errors.strictNumericEscape(startPos, lineStart, curLine);
-          }
-        }
-        return res(String.fromCharCode(octal));
-      }
-      return res(String.fromCharCode(ch));
-  }
-}
-function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
-  const initialPos = pos;
-  let n;
-  ({
-    n,
-    pos
-  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
-  if (n === null) {
-    if (throwOnInvalid) {
-      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
-    } else {
-      pos = initialPos - 1;
-    }
-  }
-  return {
-    code: n,
-    pos
-  };
-}
-function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
-  const start = pos;
-  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
-  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
-  let invalid = false;
-  let total = 0;
-  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-    const code = input.charCodeAt(pos);
-    let val;
-    if (code === 95 && allowNumSeparator !== "bail") {
-      const prev = input.charCodeAt(pos - 1);
-      const next = input.charCodeAt(pos + 1);
-      if (!allowNumSeparator) {
-        if (bailOnError) return {
-          n: null,
-          pos
-        };
-        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
-      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
-        if (bailOnError) return {
-          n: null,
-          pos
-        };
-        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
-      }
-      ++pos;
-      continue;
-    }
-    if (code >= 97) {
-      val = code - 97 + 10;
-    } else if (code >= 65) {
-      val = code - 65 + 10;
-    } else if (_isDigit(code)) {
-      val = code - 48;
-    } else {
-      val = Infinity;
-    }
-    if (val >= radix) {
-      if (val <= 9 && bailOnError) {
-        return {
-          n: null,
-          pos
-        };
-      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
-        val = 0;
-      } else if (forceLen) {
-        val = 0;
-        invalid = true;
-      } else {
-        break;
-      }
-    }
-    ++pos;
-    total = total * radix + val;
-  }
-  if (pos === start || len != null && pos - start !== len || invalid) {
-    return {
-      n: null,
-      pos
-    };
-  }
-  return {
-    n: total,
-    pos
-  };
-}
-function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
-  const ch = input.charCodeAt(pos);
-  let code;
-  if (ch === 123) {
-    ++pos;
-    ({
-      code,
-      pos
-    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
-    ++pos;
-    if (code !== null && code > 0x10ffff) {
-      if (throwOnInvalid) {
-        errors.invalidCodePoint(pos, lineStart, curLine);
-      } else {
-        return {
-          code: null,
-          pos
-        };
-      }
-    }
-  } else {
-    ({
-      code,
-      pos
-    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
-  }
-  return {
-    code,
-    pos
-  };
-}
-
-var constants$3 = {};
-
-Object.defineProperty(constants$3, "__esModule", {
-  value: true
-});
-constants$3.UPDATE_OPERATORS = constants$3.UNARY_OPERATORS = constants$3.STRING_UNARY_OPERATORS = constants$3.STATEMENT_OR_BLOCK_KEYS = constants$3.NUMBER_UNARY_OPERATORS = constants$3.NUMBER_BINARY_OPERATORS = constants$3.NOT_LOCAL_BINDING = constants$3.LOGICAL_OPERATORS = constants$3.INHERIT_KEYS = constants$3.FOR_INIT_KEYS = constants$3.FLATTENABLE_KEYS = constants$3.EQUALITY_BINARY_OPERATORS = constants$3.COMPARISON_BINARY_OPERATORS = constants$3.COMMENT_KEYS = constants$3.BOOLEAN_UNARY_OPERATORS = constants$3.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$3.BOOLEAN_BINARY_OPERATORS = constants$3.BLOCK_SCOPED_SYMBOL = constants$3.BINARY_OPERATORS = constants$3.ASSIGNMENT_OPERATORS = void 0;
-const STATEMENT_OR_BLOCK_KEYS$4 = ["consequent", "body", "alternate"];
-constants$3.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$4;
-const FLATTENABLE_KEYS$3 = ["body", "expressions"];
-constants$3.FLATTENABLE_KEYS = FLATTENABLE_KEYS$3;
-const FOR_INIT_KEYS$3 = ["left", "init"];
-constants$3.FOR_INIT_KEYS = FOR_INIT_KEYS$3;
-const COMMENT_KEYS$3 = ["leadingComments", "trailingComments", "innerComments"];
-constants$3.COMMENT_KEYS = COMMENT_KEYS$3;
-const LOGICAL_OPERATORS$4 = ["||", "&&", "??"];
-constants$3.LOGICAL_OPERATORS = LOGICAL_OPERATORS$4;
-const UPDATE_OPERATORS$3 = ["++", "--"];
-constants$3.UPDATE_OPERATORS = UPDATE_OPERATORS$3;
-const BOOLEAN_NUMBER_BINARY_OPERATORS$3 = [">", "<", ">=", "<="];
-constants$3.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$3;
-const EQUALITY_BINARY_OPERATORS$3 = ["==", "===", "!=", "!=="];
-constants$3.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$3;
-const COMPARISON_BINARY_OPERATORS$3 = [...EQUALITY_BINARY_OPERATORS$3, "in", "instanceof"];
-constants$3.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$3;
-const BOOLEAN_BINARY_OPERATORS$3 = [...COMPARISON_BINARY_OPERATORS$3, ...BOOLEAN_NUMBER_BINARY_OPERATORS$3];
-constants$3.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$3;
-const NUMBER_BINARY_OPERATORS$3 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
-constants$3.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$3;
-const BINARY_OPERATORS$3 = ["+", ...NUMBER_BINARY_OPERATORS$3, ...BOOLEAN_BINARY_OPERATORS$3, "|>"];
-constants$3.BINARY_OPERATORS = BINARY_OPERATORS$3;
-const ASSIGNMENT_OPERATORS$3 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$3.map(op => op + "="), ...LOGICAL_OPERATORS$4.map(op => op + "=")];
-constants$3.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$3;
-const BOOLEAN_UNARY_OPERATORS$3 = ["delete", "!"];
-constants$3.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$3;
-const NUMBER_UNARY_OPERATORS$3 = ["+", "-", "~"];
-constants$3.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$3;
-const STRING_UNARY_OPERATORS$3 = ["typeof"];
-constants$3.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$3;
-const UNARY_OPERATORS$3 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$3, ...NUMBER_UNARY_OPERATORS$3, ...STRING_UNARY_OPERATORS$3];
-constants$3.UNARY_OPERATORS = UNARY_OPERATORS$3;
-const INHERIT_KEYS$3 = {
-  optional: ["typeAnnotation", "typeParameters", "returnType"],
-  force: ["start", "loc", "end"]
-};
-constants$3.INHERIT_KEYS = INHERIT_KEYS$3;
-const BLOCK_SCOPED_SYMBOL$3 = Symbol.for("var used to be block scoped");
-constants$3.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$3;
-const NOT_LOCAL_BINDING$4 = Symbol.for("should not be considered a local binding");
-constants$3.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$4;
-
-var utils$4 = {};
-
-var hasRequiredUtils$3;
+var hasRequiredLib$6;
 
-function requireUtils$3 () {
-	if (hasRequiredUtils$3) return utils$4;
-	hasRequiredUtils$3 = 1;
+function requireLib$6 () {
+	if (hasRequiredLib$6) return lib$b;
+	hasRequiredLib$6 = 1;
 
-	Object.defineProperty(utils$4, "__esModule", {
+	Object.defineProperty(lib$b, "__esModule", {
 	  value: true
 	});
-	utils$4.VISITOR_KEYS = utils$4.NODE_PARENT_VALIDATIONS = utils$4.NODE_FIELDS = utils$4.FLIPPED_ALIAS_KEYS = utils$4.DEPRECATED_KEYS = utils$4.BUILDER_KEYS = utils$4.ALIAS_KEYS = void 0;
-	utils$4.arrayOf = arrayOf;
-	utils$4.arrayOfType = arrayOfType;
-	utils$4.assertEach = assertEach;
-	utils$4.assertNodeOrValueType = assertNodeOrValueType;
-	utils$4.assertNodeType = assertNodeType;
-	utils$4.assertOneOf = assertOneOf;
-	utils$4.assertOptionalChainStart = assertOptionalChainStart;
-	utils$4.assertShape = assertShape;
-	utils$4.assertValueType = assertValueType;
-	utils$4.chain = chain;
-	utils$4.default = defineType;
-	utils$4.defineAliasedType = defineAliasedType;
-	utils$4.typeIs = typeIs;
-	utils$4.validate = validate;
-	utils$4.validateArrayOfType = validateArrayOfType;
-	utils$4.validateOptional = validateOptional;
-	utils$4.validateOptionalType = validateOptionalType;
-	utils$4.validateType = validateType;
-	var _is = requireIs$3();
-	var _validate = requireValidate$3();
-	const VISITOR_KEYS = {};
-	utils$4.VISITOR_KEYS = VISITOR_KEYS;
-	const ALIAS_KEYS = {};
-	utils$4.ALIAS_KEYS = ALIAS_KEYS;
-	const FLIPPED_ALIAS_KEYS = {};
-	utils$4.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
-	const NODE_FIELDS = {};
-	utils$4.NODE_FIELDS = NODE_FIELDS;
-	const BUILDER_KEYS = {};
-	utils$4.BUILDER_KEYS = BUILDER_KEYS;
-	const DEPRECATED_KEYS = {};
-	utils$4.DEPRECATED_KEYS = DEPRECATED_KEYS;
-	const NODE_PARENT_VALIDATIONS = {};
-	utils$4.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
-	function getType(val) {
-	  if (Array.isArray(val)) {
-	    return "array";
-	  } else if (val === null) {
-	    return "null";
-	  } else {
-	    return typeof val;
+	lib$b.readCodePoint = readCodePoint;
+	lib$b.readInt = readInt;
+	lib$b.readStringContents = readStringContents;
+	var _isDigit = function isDigit(code) {
+	  return code >= 48 && code <= 57;
+	};
+	const forbiddenNumericSeparatorSiblings = {
+	  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+	  hex: new Set([46, 88, 95, 120])
+	};
+	const isAllowedNumericSeparatorSibling = {
+	  bin: ch => ch === 48 || ch === 49,
+	  oct: ch => ch >= 48 && ch <= 55,
+	  dec: ch => ch >= 48 && ch <= 57,
+	  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+	};
+	function readStringContents(type, input, pos, lineStart, curLine, errors) {
+	  const initialPos = pos;
+	  const initialLineStart = lineStart;
+	  const initialCurLine = curLine;
+	  let out = "";
+	  let firstInvalidLoc = null;
+	  let chunkStart = pos;
+	  const {
+	    length
+	  } = input;
+	  for (;;) {
+	    if (pos >= length) {
+	      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+	      out += input.slice(chunkStart, pos);
+	      break;
+	    }
+	    const ch = input.charCodeAt(pos);
+	    if (isStringEnd(type, ch, input, pos)) {
+	      out += input.slice(chunkStart, pos);
+	      break;
+	    }
+	    if (ch === 92) {
+	      out += input.slice(chunkStart, pos);
+	      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+	      if (res.ch === null && !firstInvalidLoc) {
+	        firstInvalidLoc = {
+	          pos,
+	          lineStart,
+	          curLine
+	        };
+	      } else {
+	        out += res.ch;
+	      }
+	      ({
+	        pos,
+	        lineStart,
+	        curLine
+	      } = res);
+	      chunkStart = pos;
+	    } else if (ch === 8232 || ch === 8233) {
+	      ++pos;
+	      ++curLine;
+	      lineStart = pos;
+	    } else if (ch === 10 || ch === 13) {
+	      if (type === "template") {
+	        out += input.slice(chunkStart, pos) + "\n";
+	        ++pos;
+	        if (ch === 13 && input.charCodeAt(pos) === 10) {
+	          ++pos;
+	        }
+	        ++curLine;
+	        chunkStart = lineStart = pos;
+	      } else {
+	        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+	      }
+	    } else {
+	      ++pos;
+	    }
 	  }
-	}
-	function validate(validate) {
 	  return {
-	    validate
-	  };
+	    pos,
+	    str: out,
+	    firstInvalidLoc,
+	    lineStart,
+	    curLine,
+	    containsInvalid: !!firstInvalidLoc
+	  };
+	}
+	function isStringEnd(type, ch, input, pos) {
+	  if (type === "template") {
+	    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+	  }
+	  return ch === (type === "double" ? 34 : 39);
+	}
+	function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+	  const throwOnInvalid = !inTemplate;
+	  pos++;
+	  const res = ch => ({
+	    pos,
+	    ch,
+	    lineStart,
+	    curLine
+	  });
+	  const ch = input.charCodeAt(pos++);
+	  switch (ch) {
+	    case 110:
+	      return res("\n");
+	    case 114:
+	      return res("\r");
+	    case 120:
+	      {
+	        let code;
+	        ({
+	          code,
+	          pos
+	        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+	        return res(code === null ? null : String.fromCharCode(code));
+	      }
+	    case 117:
+	      {
+	        let code;
+	        ({
+	          code,
+	          pos
+	        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+	        return res(code === null ? null : String.fromCodePoint(code));
+	      }
+	    case 116:
+	      return res("\t");
+	    case 98:
+	      return res("\b");
+	    case 118:
+	      return res("\u000b");
+	    case 102:
+	      return res("\f");
+	    case 13:
+	      if (input.charCodeAt(pos) === 10) {
+	        ++pos;
+	      }
+	    case 10:
+	      lineStart = pos;
+	      ++curLine;
+	    case 8232:
+	    case 8233:
+	      return res("");
+	    case 56:
+	    case 57:
+	      if (inTemplate) {
+	        return res(null);
+	      } else {
+	        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+	      }
+	    default:
+	      if (ch >= 48 && ch <= 55) {
+	        const startPos = pos - 1;
+	        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
+	        let octalStr = match[0];
+	        let octal = parseInt(octalStr, 8);
+	        if (octal > 255) {
+	          octalStr = octalStr.slice(0, -1);
+	          octal = parseInt(octalStr, 8);
+	        }
+	        pos += octalStr.length - 1;
+	        const next = input.charCodeAt(pos);
+	        if (octalStr !== "0" || next === 56 || next === 57) {
+	          if (inTemplate) {
+	            return res(null);
+	          } else {
+	            errors.strictNumericEscape(startPos, lineStart, curLine);
+	          }
+	        }
+	        return res(String.fromCharCode(octal));
+	      }
+	      return res(String.fromCharCode(ch));
+	  }
+	}
+	function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+	  const initialPos = pos;
+	  let n;
+	  ({
+	    n,
+	    pos
+	  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+	  if (n === null) {
+	    if (throwOnInvalid) {
+	      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+	    } else {
+	      pos = initialPos - 1;
+	    }
+	  }
+	  return {
+	    code: n,
+	    pos
+	  };
+	}
+	function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+	  const start = pos;
+	  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+	  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+	  let invalid = false;
+	  let total = 0;
+	  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+	    const code = input.charCodeAt(pos);
+	    let val;
+	    if (code === 95 && allowNumSeparator !== "bail") {
+	      const prev = input.charCodeAt(pos - 1);
+	      const next = input.charCodeAt(pos + 1);
+	      if (!allowNumSeparator) {
+	        if (bailOnError) return {
+	          n: null,
+	          pos
+	        };
+	        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+	      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+	        if (bailOnError) return {
+	          n: null,
+	          pos
+	        };
+	        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+	      }
+	      ++pos;
+	      continue;
+	    }
+	    if (code >= 97) {
+	      val = code - 97 + 10;
+	    } else if (code >= 65) {
+	      val = code - 65 + 10;
+	    } else if (_isDigit(code)) {
+	      val = code - 48;
+	    } else {
+	      val = Infinity;
+	    }
+	    if (val >= radix) {
+	      if (val <= 9 && bailOnError) {
+	        return {
+	          n: null,
+	          pos
+	        };
+	      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+	        val = 0;
+	      } else if (forceLen) {
+	        val = 0;
+	        invalid = true;
+	      } else {
+	        break;
+	      }
+	    }
+	    ++pos;
+	    total = total * radix + val;
+	  }
+	  if (pos === start || len != null && pos - start !== len || invalid) {
+	    return {
+	      n: null,
+	      pos
+	    };
+	  }
+	  return {
+	    n: total,
+	    pos
+	  };
+	}
+	function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+	  const ch = input.charCodeAt(pos);
+	  let code;
+	  if (ch === 123) {
+	    ++pos;
+	    ({
+	      code,
+	      pos
+	    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+	    ++pos;
+	    if (code !== null && code > 0x10ffff) {
+	      if (throwOnInvalid) {
+	        errors.invalidCodePoint(pos, lineStart, curLine);
+	      } else {
+	        return {
+	          code: null,
+	          pos
+	        };
+	      }
+	    }
+	  } else {
+	    ({
+	      code,
+	      pos
+	    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+	  }
+	  return {
+	    code,
+	    pos
+	  };
+	}
+
+	
+	return lib$b;
+}
+
+var constants$3 = {};
+
+Object.defineProperty(constants$3, "__esModule", {
+  value: true
+});
+constants$3.UPDATE_OPERATORS = constants$3.UNARY_OPERATORS = constants$3.STRING_UNARY_OPERATORS = constants$3.STATEMENT_OR_BLOCK_KEYS = constants$3.NUMBER_UNARY_OPERATORS = constants$3.NUMBER_BINARY_OPERATORS = constants$3.NOT_LOCAL_BINDING = constants$3.LOGICAL_OPERATORS = constants$3.INHERIT_KEYS = constants$3.FOR_INIT_KEYS = constants$3.FLATTENABLE_KEYS = constants$3.EQUALITY_BINARY_OPERATORS = constants$3.COMPARISON_BINARY_OPERATORS = constants$3.COMMENT_KEYS = constants$3.BOOLEAN_UNARY_OPERATORS = constants$3.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$3.BOOLEAN_BINARY_OPERATORS = constants$3.BLOCK_SCOPED_SYMBOL = constants$3.BINARY_OPERATORS = constants$3.ASSIGNMENT_OPERATORS = void 0;
+const STATEMENT_OR_BLOCK_KEYS$4 = ["consequent", "body", "alternate"];
+constants$3.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$4;
+const FLATTENABLE_KEYS$3 = ["body", "expressions"];
+constants$3.FLATTENABLE_KEYS = FLATTENABLE_KEYS$3;
+const FOR_INIT_KEYS$3 = ["left", "init"];
+constants$3.FOR_INIT_KEYS = FOR_INIT_KEYS$3;
+const COMMENT_KEYS$3 = ["leadingComments", "trailingComments", "innerComments"];
+constants$3.COMMENT_KEYS = COMMENT_KEYS$3;
+const LOGICAL_OPERATORS$4 = ["||", "&&", "??"];
+constants$3.LOGICAL_OPERATORS = LOGICAL_OPERATORS$4;
+const UPDATE_OPERATORS$3 = ["++", "--"];
+constants$3.UPDATE_OPERATORS = UPDATE_OPERATORS$3;
+const BOOLEAN_NUMBER_BINARY_OPERATORS$3 = [">", "<", ">=", "<="];
+constants$3.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$3;
+const EQUALITY_BINARY_OPERATORS$3 = ["==", "===", "!=", "!=="];
+constants$3.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$3;
+const COMPARISON_BINARY_OPERATORS$3 = [...EQUALITY_BINARY_OPERATORS$3, "in", "instanceof"];
+constants$3.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$3;
+const BOOLEAN_BINARY_OPERATORS$3 = [...COMPARISON_BINARY_OPERATORS$3, ...BOOLEAN_NUMBER_BINARY_OPERATORS$3];
+constants$3.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$3;
+const NUMBER_BINARY_OPERATORS$3 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+constants$3.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$3;
+const BINARY_OPERATORS$3 = ["+", ...NUMBER_BINARY_OPERATORS$3, ...BOOLEAN_BINARY_OPERATORS$3, "|>"];
+constants$3.BINARY_OPERATORS = BINARY_OPERATORS$3;
+const ASSIGNMENT_OPERATORS$3 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$3.map(op => op + "="), ...LOGICAL_OPERATORS$4.map(op => op + "=")];
+constants$3.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$3;
+const BOOLEAN_UNARY_OPERATORS$3 = ["delete", "!"];
+constants$3.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$3;
+const NUMBER_UNARY_OPERATORS$3 = ["+", "-", "~"];
+constants$3.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$3;
+const STRING_UNARY_OPERATORS$3 = ["typeof"];
+constants$3.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$3;
+const UNARY_OPERATORS$3 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$3, ...NUMBER_UNARY_OPERATORS$3, ...STRING_UNARY_OPERATORS$3];
+constants$3.UNARY_OPERATORS = UNARY_OPERATORS$3;
+const INHERIT_KEYS$3 = {
+  optional: ["typeAnnotation", "typeParameters", "returnType"],
+  force: ["start", "loc", "end"]
+};
+constants$3.INHERIT_KEYS = INHERIT_KEYS$3;
+const BLOCK_SCOPED_SYMBOL$3 = Symbol.for("var used to be block scoped");
+constants$3.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$3;
+const NOT_LOCAL_BINDING$4 = Symbol.for("should not be considered a local binding");
+constants$3.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$4;
+
+var utils$4 = {};
+
+var hasRequiredUtils$3;
+
+function requireUtils$3 () {
+	if (hasRequiredUtils$3) return utils$4;
+	hasRequiredUtils$3 = 1;
+
+	Object.defineProperty(utils$4, "__esModule", {
+	  value: true
+	});
+	utils$4.VISITOR_KEYS = utils$4.NODE_PARENT_VALIDATIONS = utils$4.NODE_FIELDS = utils$4.FLIPPED_ALIAS_KEYS = utils$4.DEPRECATED_KEYS = utils$4.BUILDER_KEYS = utils$4.ALIAS_KEYS = void 0;
+	utils$4.arrayOf = arrayOf;
+	utils$4.arrayOfType = arrayOfType;
+	utils$4.assertEach = assertEach;
+	utils$4.assertNodeOrValueType = assertNodeOrValueType;
+	utils$4.assertNodeType = assertNodeType;
+	utils$4.assertOneOf = assertOneOf;
+	utils$4.assertOptionalChainStart = assertOptionalChainStart;
+	utils$4.assertShape = assertShape;
+	utils$4.assertValueType = assertValueType;
+	utils$4.chain = chain;
+	utils$4.default = defineType;
+	utils$4.defineAliasedType = defineAliasedType;
+	utils$4.typeIs = typeIs;
+	utils$4.validate = validate;
+	utils$4.validateArrayOfType = validateArrayOfType;
+	utils$4.validateOptional = validateOptional;
+	utils$4.validateOptionalType = validateOptionalType;
+	utils$4.validateType = validateType;
+	var _is = requireIs$3();
+	var _validate = requireValidate$3();
+	const VISITOR_KEYS = {};
+	utils$4.VISITOR_KEYS = VISITOR_KEYS;
+	const ALIAS_KEYS = {};
+	utils$4.ALIAS_KEYS = ALIAS_KEYS;
+	const FLIPPED_ALIAS_KEYS = {};
+	utils$4.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
+	const NODE_FIELDS = {};
+	utils$4.NODE_FIELDS = NODE_FIELDS;
+	const BUILDER_KEYS = {};
+	utils$4.BUILDER_KEYS = BUILDER_KEYS;
+	const DEPRECATED_KEYS = {};
+	utils$4.DEPRECATED_KEYS = DEPRECATED_KEYS;
+	const NODE_PARENT_VALIDATIONS = {};
+	utils$4.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
+	function getType(val) {
+	  if (Array.isArray(val)) {
+	    return "array";
+	  } else if (val === null) {
+	    return "null";
+	  } else {
+	    return typeof val;
+	  }
+	}
+	function validate(validate) {
+	  return {
+	    validate
+	  };
 	}
 	function typeIs(typeName) {
 	  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
@@ -110885,7 +110905,7 @@ function requireCore$3 () {
 	var _is = requireIs$3();
 	var _isValidIdentifier = isValidIdentifier$7;
 	var _helperValidatorIdentifier = lib$c;
-	var _helperStringParser = lib$b;
+	var _helperStringParser = requireLib$6();
 	var _constants = constants$3;
 	var _utils = requireUtils$3();
 	const defineType = (0, _utils.defineAliasedType)("Standardized");
@@ -114044,7 +114064,7 @@ function requireValidateNode$3 () {
 	});
 	validateNode$3.default = validateNode;
 	var _validate = requireValidate$3();
-	var _ = requireLib$7();
+	var _ = requireLib$5();
 	function validateNode(node) {
 	  const keys = _.BUILDER_KEYS[node.type];
 	  for (const key of keys) {
@@ -116060,7 +116080,7 @@ function requireCleanJSXElementLiteralChild$3 () {
 	});
 	cleanJSXElementLiteralChild$3.default = cleanJSXElementLiteralChild;
 	var _generated = requireGenerated$3();
-	var _ = requireLib$7();
+	var _ = requireLib$5();
 	function cleanJSXElementLiteralChild(child, args) {
 	  const lines = child.value.split(/\r\n|\n|\r/);
 	  let lastNonEmptyLine = 0;
@@ -120146,7 +120166,7 @@ function requirePrependToMemberExpression$3 () {
 	});
 	prependToMemberExpression$3.default = prependToMemberExpression;
 	var _generated = requireGenerated$3();
-	var _ = requireLib$7();
+	var _ = requireLib$5();
 	function prependToMemberExpression(member, prepend) {
 	  if ((0, _.isSuper)(member.object)) {
 	    throw new Error("Cannot prepend node to super property access (`super.foo`).");
@@ -120498,11 +120518,11 @@ function isVar$7(node) {
   }) && !node[_constants$f.BLOCK_SCOPED_SYMBOL];
 }
 
-var hasRequiredLib$7;
+var hasRequiredLib$5;
 
-function requireLib$7 () {
-	if (hasRequiredLib$7) return lib$d;
-	hasRequiredLib$7 = 1;
+function requireLib$5 () {
+	if (hasRequiredLib$5) return lib$d;
+	hasRequiredLib$5 = 1;
 	(function (exports) {
 
 		Object.defineProperty(exports, "__esModule", {
@@ -121081,7 +121101,7 @@ Object.defineProperty(lib$e, "__esModule", {
   value: true
 });
 lib$e.default = hoistVariables;
-var _t$9 = requireLib$7();
+var _t$9 = requireLib$5();
 const {
   assignmentExpression: assignmentExpression$2,
   expressionStatement: expressionStatement$3,
@@ -121140,11 +121160,11 @@ function requireReplacement () {
 	replacement.replaceWithMultiple = replaceWithMultiple;
 	replacement.replaceWithSourceString = replaceWithSourceString;
 	var _codeFrame = lib$i;
-	var _index = requireLib$4();
+	var _index = requireLib$3();
 	var _index2 = requirePath();
 	var _cache = cache;
 	var _parser = lib$f;
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	var _helperHoistVariables = lib$e;
 	const {
 	  FUNCTION_TYPES,
@@ -124875,420 +124895,410 @@ function isValidIdentifier$4(name, reserved = true) {
 
 var lib$6 = {};
 
-var hasRequiredLib$6;
+Object.defineProperty(lib$6, "__esModule", {
+  value: true
+});
+lib$6.readCodePoint = readCodePoint$1;
+lib$6.readInt = readInt$1;
+lib$6.readStringContents = readStringContents$1;
+var _isDigit$1 = function isDigit(code) {
+  return code >= 48 && code <= 57;
+};
+const forbiddenNumericSeparatorSiblings$1 = {
+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+  hex: new Set([46, 88, 95, 120])
+};
+const isAllowedNumericSeparatorSibling$1 = {
+  bin: ch => ch === 48 || ch === 49,
+  oct: ch => ch >= 48 && ch <= 55,
+  dec: ch => ch >= 48 && ch <= 57,
+  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+};
+function readStringContents$1(type, input, pos, lineStart, curLine, errors) {
+  const initialPos = pos;
+  const initialLineStart = lineStart;
+  const initialCurLine = curLine;
+  let out = "";
+  let firstInvalidLoc = null;
+  let chunkStart = pos;
+  const {
+    length
+  } = input;
+  for (;;) {
+    if (pos >= length) {
+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    const ch = input.charCodeAt(pos);
+    if (isStringEnd$1(type, ch, input, pos)) {
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    if (ch === 92) {
+      out += input.slice(chunkStart, pos);
+      const res = readEscapedChar$1(input, pos, lineStart, curLine, type === "template", errors);
+      if (res.ch === null && !firstInvalidLoc) {
+        firstInvalidLoc = {
+          pos,
+          lineStart,
+          curLine
+        };
+      } else {
+        out += res.ch;
+      }
+      ({
+        pos,
+        lineStart,
+        curLine
+      } = res);
+      chunkStart = pos;
+    } else if (ch === 8232 || ch === 8233) {
+      ++pos;
+      ++curLine;
+      lineStart = pos;
+    } else if (ch === 10 || ch === 13) {
+      if (type === "template") {
+        out += input.slice(chunkStart, pos) + "\n";
+        ++pos;
+        if (ch === 13 && input.charCodeAt(pos) === 10) {
+          ++pos;
+        }
+        ++curLine;
+        chunkStart = lineStart = pos;
+      } else {
+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      }
+    } else {
+      ++pos;
+    }
+  }
+  return {
+    pos,
+    str: out,
+    firstInvalidLoc,
+    lineStart,
+    curLine,
+    containsInvalid: !!firstInvalidLoc
+  };
+}
+function isStringEnd$1(type, ch, input, pos) {
+  if (type === "template") {
+    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+  }
+  return ch === (type === "double" ? 34 : 39);
+}
+function readEscapedChar$1(input, pos, lineStart, curLine, inTemplate, errors) {
+  const throwOnInvalid = !inTemplate;
+  pos++;
+  const res = ch => ({
+    pos,
+    ch,
+    lineStart,
+    curLine
+  });
+  const ch = input.charCodeAt(pos++);
+  switch (ch) {
+    case 110:
+      return res("\n");
+    case 114:
+      return res("\r");
+    case 120:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readHexChar$1(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCharCode(code));
+      }
+    case 117:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCodePoint(code));
+      }
+    case 116:
+      return res("\t");
+    case 98:
+      return res("\b");
+    case 118:
+      return res("\u000b");
+    case 102:
+      return res("\f");
+    case 13:
+      if (input.charCodeAt(pos) === 10) {
+        ++pos;
+      }
+    case 10:
+      lineStart = pos;
+      ++curLine;
+    case 8232:
+    case 8233:
+      return res("");
+    case 56:
+    case 57:
+      if (inTemplate) {
+        return res(null);
+      } else {
+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+      }
+    default:
+      if (ch >= 48 && ch <= 55) {
+        const startPos = pos - 1;
+        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
+        let octalStr = match[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        pos += octalStr.length - 1;
+        const next = input.charCodeAt(pos);
+        if (octalStr !== "0" || next === 56 || next === 57) {
+          if (inTemplate) {
+            return res(null);
+          } else {
+            errors.strictNumericEscape(startPos, lineStart, curLine);
+          }
+        }
+        return res(String.fromCharCode(octal));
+      }
+      return res(String.fromCharCode(ch));
+  }
+}
+function readHexChar$1(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+  const initialPos = pos;
+  let n;
+  ({
+    n,
+    pos
+  } = readInt$1(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+  if (n === null) {
+    if (throwOnInvalid) {
+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+    } else {
+      pos = initialPos - 1;
+    }
+  }
+  return {
+    code: n,
+    pos
+  };
+}
+function readInt$1(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+  const start = pos;
+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings$1.hex : forbiddenNumericSeparatorSiblings$1.decBinOct;
+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling$1.hex : radix === 10 ? isAllowedNumericSeparatorSibling$1.dec : radix === 8 ? isAllowedNumericSeparatorSibling$1.oct : isAllowedNumericSeparatorSibling$1.bin;
+  let invalid = false;
+  let total = 0;
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    const code = input.charCodeAt(pos);
+    let val;
+    if (code === 95 && allowNumSeparator !== "bail") {
+      const prev = input.charCodeAt(pos - 1);
+      const next = input.charCodeAt(pos + 1);
+      if (!allowNumSeparator) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+      }
+      ++pos;
+      continue;
+    }
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (_isDigit$1(code)) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix) {
+      if (val <= 9 && bailOnError) {
+        return {
+          n: null,
+          pos
+        };
+      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+        val = 0;
+      } else if (forceLen) {
+        val = 0;
+        invalid = true;
+      } else {
+        break;
+      }
+    }
+    ++pos;
+    total = total * radix + val;
+  }
+  if (pos === start || len != null && pos - start !== len || invalid) {
+    return {
+      n: null,
+      pos
+    };
+  }
+  return {
+    n: total,
+    pos
+  };
+}
+function readCodePoint$1(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+  const ch = input.charCodeAt(pos);
+  let code;
+  if (ch === 123) {
+    ++pos;
+    ({
+      code,
+      pos
+    } = readHexChar$1(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+    ++pos;
+    if (code !== null && code > 0x10ffff) {
+      if (throwOnInvalid) {
+        errors.invalidCodePoint(pos, lineStart, curLine);
+      } else {
+        return {
+          code: null,
+          pos
+        };
+      }
+    }
+  } else {
+    ({
+      code,
+      pos
+    } = readHexChar$1(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+  }
+  return {
+    code,
+    pos
+  };
+}
 
-function requireLib$6 () {
-	if (hasRequiredLib$6) return lib$6;
-	hasRequiredLib$6 = 1;
+var constants$2 = {};
+
+Object.defineProperty(constants$2, "__esModule", {
+  value: true
+});
+constants$2.UPDATE_OPERATORS = constants$2.UNARY_OPERATORS = constants$2.STRING_UNARY_OPERATORS = constants$2.STATEMENT_OR_BLOCK_KEYS = constants$2.NUMBER_UNARY_OPERATORS = constants$2.NUMBER_BINARY_OPERATORS = constants$2.NOT_LOCAL_BINDING = constants$2.LOGICAL_OPERATORS = constants$2.INHERIT_KEYS = constants$2.FOR_INIT_KEYS = constants$2.FLATTENABLE_KEYS = constants$2.EQUALITY_BINARY_OPERATORS = constants$2.COMPARISON_BINARY_OPERATORS = constants$2.COMMENT_KEYS = constants$2.BOOLEAN_UNARY_OPERATORS = constants$2.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$2.BOOLEAN_BINARY_OPERATORS = constants$2.BLOCK_SCOPED_SYMBOL = constants$2.BINARY_OPERATORS = constants$2.ASSIGNMENT_OPERATORS = void 0;
+const STATEMENT_OR_BLOCK_KEYS$3 = ["consequent", "body", "alternate"];
+constants$2.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$3;
+const FLATTENABLE_KEYS$2 = ["body", "expressions"];
+constants$2.FLATTENABLE_KEYS = FLATTENABLE_KEYS$2;
+const FOR_INIT_KEYS$2 = ["left", "init"];
+constants$2.FOR_INIT_KEYS = FOR_INIT_KEYS$2;
+const COMMENT_KEYS$2 = ["leadingComments", "trailingComments", "innerComments"];
+constants$2.COMMENT_KEYS = COMMENT_KEYS$2;
+const LOGICAL_OPERATORS$3 = ["||", "&&", "??"];
+constants$2.LOGICAL_OPERATORS = LOGICAL_OPERATORS$3;
+const UPDATE_OPERATORS$2 = ["++", "--"];
+constants$2.UPDATE_OPERATORS = UPDATE_OPERATORS$2;
+const BOOLEAN_NUMBER_BINARY_OPERATORS$2 = [">", "<", ">=", "<="];
+constants$2.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$2;
+const EQUALITY_BINARY_OPERATORS$2 = ["==", "===", "!=", "!=="];
+constants$2.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$2;
+const COMPARISON_BINARY_OPERATORS$2 = [...EQUALITY_BINARY_OPERATORS$2, "in", "instanceof"];
+constants$2.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$2;
+const BOOLEAN_BINARY_OPERATORS$2 = [...COMPARISON_BINARY_OPERATORS$2, ...BOOLEAN_NUMBER_BINARY_OPERATORS$2];
+constants$2.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$2;
+const NUMBER_BINARY_OPERATORS$2 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
+constants$2.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$2;
+const BINARY_OPERATORS$2 = ["+", ...NUMBER_BINARY_OPERATORS$2, ...BOOLEAN_BINARY_OPERATORS$2, "|>"];
+constants$2.BINARY_OPERATORS = BINARY_OPERATORS$2;
+const ASSIGNMENT_OPERATORS$2 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$2.map(op => op + "="), ...LOGICAL_OPERATORS$3.map(op => op + "=")];
+constants$2.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$2;
+const BOOLEAN_UNARY_OPERATORS$2 = ["delete", "!"];
+constants$2.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$2;
+const NUMBER_UNARY_OPERATORS$2 = ["+", "-", "~"];
+constants$2.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$2;
+const STRING_UNARY_OPERATORS$2 = ["typeof"];
+constants$2.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$2;
+const UNARY_OPERATORS$2 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$2, ...NUMBER_UNARY_OPERATORS$2, ...STRING_UNARY_OPERATORS$2];
+constants$2.UNARY_OPERATORS = UNARY_OPERATORS$2;
+const INHERIT_KEYS$2 = {
+  optional: ["typeAnnotation", "typeParameters", "returnType"],
+  force: ["start", "loc", "end"]
+};
+constants$2.INHERIT_KEYS = INHERIT_KEYS$2;
+const BLOCK_SCOPED_SYMBOL$2 = Symbol.for("var used to be block scoped");
+constants$2.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$2;
+const NOT_LOCAL_BINDING$3 = Symbol.for("should not be considered a local binding");
+constants$2.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$3;
+
+var utils$3 = {};
+
+var hasRequiredUtils$2;
+
+function requireUtils$2 () {
+	if (hasRequiredUtils$2) return utils$3;
+	hasRequiredUtils$2 = 1;
 
-	Object.defineProperty(lib$6, "__esModule", {
+	Object.defineProperty(utils$3, "__esModule", {
 	  value: true
 	});
-	lib$6.readCodePoint = readCodePoint;
-	lib$6.readInt = readInt;
-	lib$6.readStringContents = readStringContents;
-	var _isDigit = function isDigit(code) {
-	  return code >= 48 && code <= 57;
-	};
-	const forbiddenNumericSeparatorSiblings = {
-	  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
-	  hex: new Set([46, 88, 95, 120])
-	};
-	const isAllowedNumericSeparatorSibling = {
-	  bin: ch => ch === 48 || ch === 49,
-	  oct: ch => ch >= 48 && ch <= 55,
-	  dec: ch => ch >= 48 && ch <= 57,
-	  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
-	};
-	function readStringContents(type, input, pos, lineStart, curLine, errors) {
-	  const initialPos = pos;
-	  const initialLineStart = lineStart;
-	  const initialCurLine = curLine;
-	  let out = "";
-	  let firstInvalidLoc = null;
-	  let chunkStart = pos;
-	  const {
-	    length
-	  } = input;
-	  for (;;) {
-	    if (pos >= length) {
-	      errors.unterminated(initialPos, initialLineStart, initialCurLine);
-	      out += input.slice(chunkStart, pos);
-	      break;
-	    }
-	    const ch = input.charCodeAt(pos);
-	    if (isStringEnd(type, ch, input, pos)) {
-	      out += input.slice(chunkStart, pos);
-	      break;
-	    }
-	    if (ch === 92) {
-	      out += input.slice(chunkStart, pos);
-	      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
-	      if (res.ch === null && !firstInvalidLoc) {
-	        firstInvalidLoc = {
-	          pos,
-	          lineStart,
-	          curLine
-	        };
-	      } else {
-	        out += res.ch;
-	      }
-	      ({
-	        pos,
-	        lineStart,
-	        curLine
-	      } = res);
-	      chunkStart = pos;
-	    } else if (ch === 8232 || ch === 8233) {
-	      ++pos;
-	      ++curLine;
-	      lineStart = pos;
-	    } else if (ch === 10 || ch === 13) {
-	      if (type === "template") {
-	        out += input.slice(chunkStart, pos) + "\n";
-	        ++pos;
-	        if (ch === 13 && input.charCodeAt(pos) === 10) {
-	          ++pos;
-	        }
-	        ++curLine;
-	        chunkStart = lineStart = pos;
-	      } else {
-	        errors.unterminated(initialPos, initialLineStart, initialCurLine);
-	      }
-	    } else {
-	      ++pos;
-	    }
+	utils$3.VISITOR_KEYS = utils$3.NODE_PARENT_VALIDATIONS = utils$3.NODE_FIELDS = utils$3.FLIPPED_ALIAS_KEYS = utils$3.DEPRECATED_KEYS = utils$3.BUILDER_KEYS = utils$3.ALIAS_KEYS = void 0;
+	utils$3.arrayOf = arrayOf;
+	utils$3.arrayOfType = arrayOfType;
+	utils$3.assertEach = assertEach;
+	utils$3.assertNodeOrValueType = assertNodeOrValueType;
+	utils$3.assertNodeType = assertNodeType;
+	utils$3.assertOneOf = assertOneOf;
+	utils$3.assertOptionalChainStart = assertOptionalChainStart;
+	utils$3.assertShape = assertShape;
+	utils$3.assertValueType = assertValueType;
+	utils$3.chain = chain;
+	utils$3.default = defineType;
+	utils$3.defineAliasedType = defineAliasedType;
+	utils$3.typeIs = typeIs;
+	utils$3.validate = validate;
+	utils$3.validateArrayOfType = validateArrayOfType;
+	utils$3.validateOptional = validateOptional;
+	utils$3.validateOptionalType = validateOptionalType;
+	utils$3.validateType = validateType;
+	var _is = requireIs$2();
+	var _validate = requireValidate$2();
+	const VISITOR_KEYS = {};
+	utils$3.VISITOR_KEYS = VISITOR_KEYS;
+	const ALIAS_KEYS = {};
+	utils$3.ALIAS_KEYS = ALIAS_KEYS;
+	const FLIPPED_ALIAS_KEYS = {};
+	utils$3.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
+	const NODE_FIELDS = {};
+	utils$3.NODE_FIELDS = NODE_FIELDS;
+	const BUILDER_KEYS = {};
+	utils$3.BUILDER_KEYS = BUILDER_KEYS;
+	const DEPRECATED_KEYS = {};
+	utils$3.DEPRECATED_KEYS = DEPRECATED_KEYS;
+	const NODE_PARENT_VALIDATIONS = {};
+	utils$3.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
+	function getType(val) {
+	  if (Array.isArray(val)) {
+	    return "array";
+	  } else if (val === null) {
+	    return "null";
+	  } else {
+	    return typeof val;
 	  }
+	}
+	function validate(validate) {
 	  return {
-	    pos,
-	    str: out,
-	    firstInvalidLoc,
-	    lineStart,
-	    curLine,
-	    containsInvalid: !!firstInvalidLoc
+	    validate
 	  };
 	}
-	function isStringEnd(type, ch, input, pos) {
-	  if (type === "template") {
-	    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
-	  }
-	  return ch === (type === "double" ? 34 : 39);
-	}
-	function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
-	  const throwOnInvalid = !inTemplate;
-	  pos++;
-	  const res = ch => ({
-	    pos,
-	    ch,
-	    lineStart,
-	    curLine
-	  });
-	  const ch = input.charCodeAt(pos++);
-	  switch (ch) {
-	    case 110:
-	      return res("\n");
-	    case 114:
-	      return res("\r");
-	    case 120:
-	      {
-	        let code;
-	        ({
-	          code,
-	          pos
-	        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
-	        return res(code === null ? null : String.fromCharCode(code));
-	      }
-	    case 117:
-	      {
-	        let code;
-	        ({
-	          code,
-	          pos
-	        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
-	        return res(code === null ? null : String.fromCodePoint(code));
-	      }
-	    case 116:
-	      return res("\t");
-	    case 98:
-	      return res("\b");
-	    case 118:
-	      return res("\u000b");
-	    case 102:
-	      return res("\f");
-	    case 13:
-	      if (input.charCodeAt(pos) === 10) {
-	        ++pos;
-	      }
-	    case 10:
-	      lineStart = pos;
-	      ++curLine;
-	    case 8232:
-	    case 8233:
-	      return res("");
-	    case 56:
-	    case 57:
-	      if (inTemplate) {
-	        return res(null);
-	      } else {
-	        errors.strictNumericEscape(pos - 1, lineStart, curLine);
-	      }
-	    default:
-	      if (ch >= 48 && ch <= 55) {
-	        const startPos = pos - 1;
-	        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
-	        let octalStr = match[0];
-	        let octal = parseInt(octalStr, 8);
-	        if (octal > 255) {
-	          octalStr = octalStr.slice(0, -1);
-	          octal = parseInt(octalStr, 8);
-	        }
-	        pos += octalStr.length - 1;
-	        const next = input.charCodeAt(pos);
-	        if (octalStr !== "0" || next === 56 || next === 57) {
-	          if (inTemplate) {
-	            return res(null);
-	          } else {
-	            errors.strictNumericEscape(startPos, lineStart, curLine);
-	          }
-	        }
-	        return res(String.fromCharCode(octal));
-	      }
-	      return res(String.fromCharCode(ch));
-	  }
-	}
-	function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
-	  const initialPos = pos;
-	  let n;
-	  ({
-	    n,
-	    pos
-	  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
-	  if (n === null) {
-	    if (throwOnInvalid) {
-	      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
-	    } else {
-	      pos = initialPos - 1;
-	    }
-	  }
-	  return {
-	    code: n,
-	    pos
-	  };
-	}
-	function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
-	  const start = pos;
-	  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
-	  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
-	  let invalid = false;
-	  let total = 0;
-	  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	    const code = input.charCodeAt(pos);
-	    let val;
-	    if (code === 95 && allowNumSeparator !== "bail") {
-	      const prev = input.charCodeAt(pos - 1);
-	      const next = input.charCodeAt(pos + 1);
-	      if (!allowNumSeparator) {
-	        if (bailOnError) return {
-	          n: null,
-	          pos
-	        };
-	        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
-	      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
-	        if (bailOnError) return {
-	          n: null,
-	          pos
-	        };
-	        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
-	      }
-	      ++pos;
-	      continue;
-	    }
-	    if (code >= 97) {
-	      val = code - 97 + 10;
-	    } else if (code >= 65) {
-	      val = code - 65 + 10;
-	    } else if (_isDigit(code)) {
-	      val = code - 48;
-	    } else {
-	      val = Infinity;
-	    }
-	    if (val >= radix) {
-	      if (val <= 9 && bailOnError) {
-	        return {
-	          n: null,
-	          pos
-	        };
-	      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
-	        val = 0;
-	      } else if (forceLen) {
-	        val = 0;
-	        invalid = true;
-	      } else {
-	        break;
-	      }
-	    }
-	    ++pos;
-	    total = total * radix + val;
-	  }
-	  if (pos === start || len != null && pos - start !== len || invalid) {
-	    return {
-	      n: null,
-	      pos
-	    };
-	  }
-	  return {
-	    n: total,
-	    pos
-	  };
-	}
-	function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
-	  const ch = input.charCodeAt(pos);
-	  let code;
-	  if (ch === 123) {
-	    ++pos;
-	    ({
-	      code,
-	      pos
-	    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
-	    ++pos;
-	    if (code !== null && code > 0x10ffff) {
-	      if (throwOnInvalid) {
-	        errors.invalidCodePoint(pos, lineStart, curLine);
-	      } else {
-	        return {
-	          code: null,
-	          pos
-	        };
-	      }
-	    }
-	  } else {
-	    ({
-	      code,
-	      pos
-	    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
-	  }
-	  return {
-	    code,
-	    pos
-	  };
-	}
-
-	
-	return lib$6;
-}
-
-var constants$2 = {};
-
-Object.defineProperty(constants$2, "__esModule", {
-  value: true
-});
-constants$2.UPDATE_OPERATORS = constants$2.UNARY_OPERATORS = constants$2.STRING_UNARY_OPERATORS = constants$2.STATEMENT_OR_BLOCK_KEYS = constants$2.NUMBER_UNARY_OPERATORS = constants$2.NUMBER_BINARY_OPERATORS = constants$2.NOT_LOCAL_BINDING = constants$2.LOGICAL_OPERATORS = constants$2.INHERIT_KEYS = constants$2.FOR_INIT_KEYS = constants$2.FLATTENABLE_KEYS = constants$2.EQUALITY_BINARY_OPERATORS = constants$2.COMPARISON_BINARY_OPERATORS = constants$2.COMMENT_KEYS = constants$2.BOOLEAN_UNARY_OPERATORS = constants$2.BOOLEAN_NUMBER_BINARY_OPERATORS = constants$2.BOOLEAN_BINARY_OPERATORS = constants$2.BLOCK_SCOPED_SYMBOL = constants$2.BINARY_OPERATORS = constants$2.ASSIGNMENT_OPERATORS = void 0;
-const STATEMENT_OR_BLOCK_KEYS$3 = ["consequent", "body", "alternate"];
-constants$2.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS$3;
-const FLATTENABLE_KEYS$2 = ["body", "expressions"];
-constants$2.FLATTENABLE_KEYS = FLATTENABLE_KEYS$2;
-const FOR_INIT_KEYS$2 = ["left", "init"];
-constants$2.FOR_INIT_KEYS = FOR_INIT_KEYS$2;
-const COMMENT_KEYS$2 = ["leadingComments", "trailingComments", "innerComments"];
-constants$2.COMMENT_KEYS = COMMENT_KEYS$2;
-const LOGICAL_OPERATORS$3 = ["||", "&&", "??"];
-constants$2.LOGICAL_OPERATORS = LOGICAL_OPERATORS$3;
-const UPDATE_OPERATORS$2 = ["++", "--"];
-constants$2.UPDATE_OPERATORS = UPDATE_OPERATORS$2;
-const BOOLEAN_NUMBER_BINARY_OPERATORS$2 = [">", "<", ">=", "<="];
-constants$2.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS$2;
-const EQUALITY_BINARY_OPERATORS$2 = ["==", "===", "!=", "!=="];
-constants$2.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS$2;
-const COMPARISON_BINARY_OPERATORS$2 = [...EQUALITY_BINARY_OPERATORS$2, "in", "instanceof"];
-constants$2.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS$2;
-const BOOLEAN_BINARY_OPERATORS$2 = [...COMPARISON_BINARY_OPERATORS$2, ...BOOLEAN_NUMBER_BINARY_OPERATORS$2];
-constants$2.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS$2;
-const NUMBER_BINARY_OPERATORS$2 = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
-constants$2.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS$2;
-const BINARY_OPERATORS$2 = ["+", ...NUMBER_BINARY_OPERATORS$2, ...BOOLEAN_BINARY_OPERATORS$2, "|>"];
-constants$2.BINARY_OPERATORS = BINARY_OPERATORS$2;
-const ASSIGNMENT_OPERATORS$2 = ["=", "+=", ...NUMBER_BINARY_OPERATORS$2.map(op => op + "="), ...LOGICAL_OPERATORS$3.map(op => op + "=")];
-constants$2.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS$2;
-const BOOLEAN_UNARY_OPERATORS$2 = ["delete", "!"];
-constants$2.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS$2;
-const NUMBER_UNARY_OPERATORS$2 = ["+", "-", "~"];
-constants$2.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS$2;
-const STRING_UNARY_OPERATORS$2 = ["typeof"];
-constants$2.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS$2;
-const UNARY_OPERATORS$2 = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS$2, ...NUMBER_UNARY_OPERATORS$2, ...STRING_UNARY_OPERATORS$2];
-constants$2.UNARY_OPERATORS = UNARY_OPERATORS$2;
-const INHERIT_KEYS$2 = {
-  optional: ["typeAnnotation", "typeParameters", "returnType"],
-  force: ["start", "loc", "end"]
-};
-constants$2.INHERIT_KEYS = INHERIT_KEYS$2;
-const BLOCK_SCOPED_SYMBOL$2 = Symbol.for("var used to be block scoped");
-constants$2.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL$2;
-const NOT_LOCAL_BINDING$3 = Symbol.for("should not be considered a local binding");
-constants$2.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING$3;
-
-var utils$3 = {};
-
-var hasRequiredUtils$2;
-
-function requireUtils$2 () {
-	if (hasRequiredUtils$2) return utils$3;
-	hasRequiredUtils$2 = 1;
-
-	Object.defineProperty(utils$3, "__esModule", {
-	  value: true
-	});
-	utils$3.VISITOR_KEYS = utils$3.NODE_PARENT_VALIDATIONS = utils$3.NODE_FIELDS = utils$3.FLIPPED_ALIAS_KEYS = utils$3.DEPRECATED_KEYS = utils$3.BUILDER_KEYS = utils$3.ALIAS_KEYS = void 0;
-	utils$3.arrayOf = arrayOf;
-	utils$3.arrayOfType = arrayOfType;
-	utils$3.assertEach = assertEach;
-	utils$3.assertNodeOrValueType = assertNodeOrValueType;
-	utils$3.assertNodeType = assertNodeType;
-	utils$3.assertOneOf = assertOneOf;
-	utils$3.assertOptionalChainStart = assertOptionalChainStart;
-	utils$3.assertShape = assertShape;
-	utils$3.assertValueType = assertValueType;
-	utils$3.chain = chain;
-	utils$3.default = defineType;
-	utils$3.defineAliasedType = defineAliasedType;
-	utils$3.typeIs = typeIs;
-	utils$3.validate = validate;
-	utils$3.validateArrayOfType = validateArrayOfType;
-	utils$3.validateOptional = validateOptional;
-	utils$3.validateOptionalType = validateOptionalType;
-	utils$3.validateType = validateType;
-	var _is = requireIs$2();
-	var _validate = requireValidate$2();
-	const VISITOR_KEYS = {};
-	utils$3.VISITOR_KEYS = VISITOR_KEYS;
-	const ALIAS_KEYS = {};
-	utils$3.ALIAS_KEYS = ALIAS_KEYS;
-	const FLIPPED_ALIAS_KEYS = {};
-	utils$3.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
-	const NODE_FIELDS = {};
-	utils$3.NODE_FIELDS = NODE_FIELDS;
-	const BUILDER_KEYS = {};
-	utils$3.BUILDER_KEYS = BUILDER_KEYS;
-	const DEPRECATED_KEYS = {};
-	utils$3.DEPRECATED_KEYS = DEPRECATED_KEYS;
-	const NODE_PARENT_VALIDATIONS = {};
-	utils$3.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
-	function getType(val) {
-	  if (Array.isArray(val)) {
-	    return "array";
-	  } else if (val === null) {
-	    return "null";
-	  } else {
-	    return typeof val;
-	  }
-	}
-	function validate(validate) {
-	  return {
-	    validate
-	  };
-	}
-	function typeIs(typeName) {
-	  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
+	function typeIs(typeName) {
+	  return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
 	}
 	function validateType(typeName) {
 	  return validate(typeIs(typeName));
@@ -125529,7 +125539,7 @@ function requireCore$2 () {
 	var _is = requireIs$2();
 	var _isValidIdentifier = isValidIdentifier$5;
 	var _helperValidatorIdentifier = lib$7;
-	var _helperStringParser = requireLib$6();
+	var _helperStringParser = lib$6;
 	var _constants = constants$2;
 	var _utils = requireUtils$2();
 	const defineType = (0, _utils.defineAliasedType)("Standardized");
@@ -128688,7 +128698,7 @@ function requireValidateNode$2 () {
 	});
 	validateNode$2.default = validateNode;
 	var _validate = requireValidate$2();
-	var _ = requireLib$5();
+	var _ = requireLib$4();
 	function validateNode(node) {
 	  const keys = _.BUILDER_KEYS[node.type];
 	  for (const key of keys) {
@@ -130704,7 +130714,7 @@ function requireCleanJSXElementLiteralChild$2 () {
 	});
 	cleanJSXElementLiteralChild$2.default = cleanJSXElementLiteralChild;
 	var _generated = requireGenerated$2();
-	var _ = requireLib$5();
+	var _ = requireLib$4();
 	function cleanJSXElementLiteralChild(child, args) {
 	  const lines = child.value.split(/\r\n|\n|\r/);
 	  let lastNonEmptyLine = 0;
@@ -134790,7 +134800,7 @@ function requirePrependToMemberExpression$2 () {
 	});
 	prependToMemberExpression$2.default = prependToMemberExpression;
 	var _generated = requireGenerated$2();
-	var _ = requireLib$5();
+	var _ = requireLib$4();
 	function prependToMemberExpression(member, prepend) {
 	  if ((0, _.isSuper)(member.object)) {
 	    throw new Error("Cannot prepend node to super property access (`super.foo`).");
@@ -135142,11 +135152,11 @@ function isVar$5(node) {
   }) && !node[_constants$a.BLOCK_SCOPED_SYMBOL];
 }
 
-var hasRequiredLib$5;
+var hasRequiredLib$4;
 
-function requireLib$5 () {
-	if (hasRequiredLib$5) return lib$8;
-	hasRequiredLib$5 = 1;
+function requireLib$4 () {
+	if (hasRequiredLib$4) return lib$8;
+	hasRequiredLib$4 = 1;
 	(function (exports) {
 
 		Object.defineProperty(exports, "__esModule", {
@@ -135725,7 +135735,7 @@ Object.defineProperty(formatters$1, "__esModule", {
   value: true
 });
 formatters$1.statements = formatters$1.statement = formatters$1.smart = formatters$1.program = formatters$1.expression = void 0;
-var _t$8 = requireLib$5();
+var _t$8 = requireLib$4();
 const {
   assertExpressionStatement: assertExpressionStatement$2
 } = _t$8;
@@ -135866,7 +135876,7 @@ Object.defineProperty(parse$5, "__esModule", {
   value: true
 });
 parse$5.default = parseAndBuildMetadata;
-var _t$7 = requireLib$5();
+var _t$7 = requireLib$4();
 var _parser = lib$f;
 var _codeFrame = lib$i;
 const {
@@ -136025,7 +136035,7 @@ Object.defineProperty(populate, "__esModule", {
   value: true
 });
 populate.default = populatePlaceholders;
-var _t$6 = requireLib$5();
+var _t$6 = requireLib$4();
 const {
   blockStatement: blockStatement$2,
   cloneNode: cloneNode$6,
@@ -136322,7 +136332,7 @@ Object.defineProperty(lib$a, "__esModule", {
 });
 lib$a.default = _default$6;
 var _template = lib$9;
-var _t$5 = requireLib$5();
+var _t$5 = requireLib$4();
 const {
   NOT_LOCAL_BINDING: NOT_LOCAL_BINDING$2,
   cloneNode: cloneNode$5,
@@ -136491,7 +136501,7 @@ conversion.arrowFunctionToExpression = arrowFunctionToExpression;
 conversion.ensureBlock = ensureBlock$2;
 conversion.toComputedKey = toComputedKey$2;
 conversion.unwrapFunctionEnvironment = unwrapFunctionEnvironment;
-var _t$4 = requireLib$8();
+var _t$4 = requireLib$7();
 var _helperEnvironmentVisitor = lib$k;
 var _helperFunctionName = lib$a;
 var _visitors = visitors;
@@ -136975,7 +136985,7 @@ introspection.matchesPattern = matchesPattern$5;
 introspection.referencesImport = referencesImport;
 introspection.resolve = resolve$1;
 introspection.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
-var _t$3 = requireLib$8();
+var _t$3 = requireLib$7();
 const {
   STATEMENT_OR_BLOCK_KEYS: STATEMENT_OR_BLOCK_KEYS$2,
   VISITOR_KEYS,
@@ -137679,7 +137689,7 @@ Object.defineProperty(hoister, "__esModule", {
   value: true
 });
 hoister.default = void 0;
-var _t$2 = requireLib$8();
+var _t$2 = requireLib$7();
 var _t2 = _t$2;
 const {
   react: react$1
@@ -137865,7 +137875,7 @@ function requireModification () {
 	var _cache = cache;
 	var _hoister = hoister;
 	var _index = requirePath();
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	const {
 	  arrowFunctionExpression,
 	  assertExpression,
@@ -138101,7 +138111,7 @@ function requireFamily () {
 	family.getPrevSibling = getPrevSibling;
 	family.getSibling = getSibling;
 	var _index = requirePath();
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	const {
 	  getBindingIdentifiers: _getBindingIdentifiers,
 	  getOuterBindingIdentifiers: _getOuterBindingIdentifiers,
@@ -138428,7 +138438,7 @@ Object.defineProperty(comments$1, "__esModule", {
 comments$1.addComment = addComment$4;
 comments$1.addComments = addComments$4;
 comments$1.shareCommentsWithSiblings = shareCommentsWithSiblings;
-var _t$1 = requireLib$8();
+var _t$1 = requireLib$7();
 const {
   addComment: _addComment,
   addComments: _addComments$2
@@ -138494,7 +138504,7 @@ virtualTypesValidator.isSpreadProperty = isSpreadProperty$2;
 virtualTypesValidator.isStatement = isStatement$7;
 virtualTypesValidator.isUser = isUser;
 virtualTypesValidator.isVar = isVar$4;
-var _t = requireLib$8();
+var _t = requireLib$7();
 const {
   isBinding: isBinding$5,
   isBlockScoped: nodeIsBlockScoped,
@@ -138647,9 +138657,9 @@ function requirePath () {
 	path.default = path.SHOULD_STOP = path.SHOULD_SKIP = path.REMOVED = void 0;
 	var virtualTypes = virtualTypes$1;
 	var _debug = browserExports;
-	var _index = requireLib$4();
+	var _index = requireLib$3();
 	var _scope = requireScope();
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	var t = _t;
 	var cache$1 = cache;
 	var _generator = lib$j;
@@ -138846,7 +138856,7 @@ function requireContext () {
 	});
 	context$1.default = void 0;
 	var _path = requirePath();
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	const {
 	  VISITOR_KEYS
 	} = _t;
@@ -138968,7 +138978,7 @@ function requireTraverseNode () {
 	});
 	traverseNode.traverseNode = traverseNode$1;
 	var _context = requireContext();
-	var _t = requireLib$8();
+	var _t = requireLib$7();
 	const {
 	  VISITOR_KEYS
 	} = _t;
@@ -139011,11 +139021,11 @@ class Hub {
 }
 hub.default = Hub;
 
-var hasRequiredLib$4;
+var hasRequiredLib$3;
 
-function requireLib$4 () {
-	if (hasRequiredLib$4) return lib$p;
-	hasRequiredLib$4 = 1;
+function requireLib$3 () {
+	if (hasRequiredLib$3) return lib$p;
+	hasRequiredLib$3 = 1;
 	(function (exports) {
 
 		Object.defineProperty(exports, "__esModule", {
@@ -139042,7 +139052,7 @@ function requireLib$4 () {
 		exports.visitors = exports.default = void 0;
 		var visitors$1 = visitors;
 		exports.visitors = visitors$1;
-		var _t = requireLib$8();
+		var _t = requireLib$7();
 		var cache$1 = cache;
 		var _traverseNode = requireTraverseNode();
 		var _path = requirePath();
@@ -142313,306 +142323,296 @@ function isValidIdentifier$2(name, reserved = true) {
 
 var lib$3 = {};
 
-var hasRequiredLib$3;
-
-function requireLib$3 () {
-	if (hasRequiredLib$3) return lib$3;
-	hasRequiredLib$3 = 1;
-
-	Object.defineProperty(lib$3, "__esModule", {
-	  value: true
-	});
-	lib$3.readCodePoint = readCodePoint;
-	lib$3.readInt = readInt;
-	lib$3.readStringContents = readStringContents;
-	var _isDigit = function isDigit(code) {
-	  return code >= 48 && code <= 57;
-	};
-	const forbiddenNumericSeparatorSiblings = {
-	  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
-	  hex: new Set([46, 88, 95, 120])
-	};
-	const isAllowedNumericSeparatorSibling = {
-	  bin: ch => ch === 48 || ch === 49,
-	  oct: ch => ch >= 48 && ch <= 55,
-	  dec: ch => ch >= 48 && ch <= 57,
-	  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
-	};
-	function readStringContents(type, input, pos, lineStart, curLine, errors) {
-	  const initialPos = pos;
-	  const initialLineStart = lineStart;
-	  const initialCurLine = curLine;
-	  let out = "";
-	  let firstInvalidLoc = null;
-	  let chunkStart = pos;
-	  const {
-	    length
-	  } = input;
-	  for (;;) {
-	    if (pos >= length) {
-	      errors.unterminated(initialPos, initialLineStart, initialCurLine);
-	      out += input.slice(chunkStart, pos);
-	      break;
-	    }
-	    const ch = input.charCodeAt(pos);
-	    if (isStringEnd(type, ch, input, pos)) {
-	      out += input.slice(chunkStart, pos);
-	      break;
-	    }
-	    if (ch === 92) {
-	      out += input.slice(chunkStart, pos);
-	      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
-	      if (res.ch === null && !firstInvalidLoc) {
-	        firstInvalidLoc = {
-	          pos,
-	          lineStart,
-	          curLine
-	        };
-	      } else {
-	        out += res.ch;
-	      }
-	      ({
-	        pos,
-	        lineStart,
-	        curLine
-	      } = res);
-	      chunkStart = pos;
-	    } else if (ch === 8232 || ch === 8233) {
-	      ++pos;
-	      ++curLine;
-	      lineStart = pos;
-	    } else if (ch === 10 || ch === 13) {
-	      if (type === "template") {
-	        out += input.slice(chunkStart, pos) + "\n";
-	        ++pos;
-	        if (ch === 13 && input.charCodeAt(pos) === 10) {
-	          ++pos;
-	        }
-	        ++curLine;
-	        chunkStart = lineStart = pos;
-	      } else {
-	        errors.unterminated(initialPos, initialLineStart, initialCurLine);
-	      }
-	    } else {
-	      ++pos;
-	    }
-	  }
-	  return {
-	    pos,
-	    str: out,
-	    firstInvalidLoc,
-	    lineStart,
-	    curLine,
-	    containsInvalid: !!firstInvalidLoc
-	  };
-	}
-	function isStringEnd(type, ch, input, pos) {
-	  if (type === "template") {
-	    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
-	  }
-	  return ch === (type === "double" ? 34 : 39);
-	}
-	function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
-	  const throwOnInvalid = !inTemplate;
-	  pos++;
-	  const res = ch => ({
-	    pos,
-	    ch,
-	    lineStart,
-	    curLine
-	  });
-	  const ch = input.charCodeAt(pos++);
-	  switch (ch) {
-	    case 110:
-	      return res("\n");
-	    case 114:
-	      return res("\r");
-	    case 120:
-	      {
-	        let code;
-	        ({
-	          code,
-	          pos
-	        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
-	        return res(code === null ? null : String.fromCharCode(code));
-	      }
-	    case 117:
-	      {
-	        let code;
-	        ({
-	          code,
-	          pos
-	        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
-	        return res(code === null ? null : String.fromCodePoint(code));
-	      }
-	    case 116:
-	      return res("\t");
-	    case 98:
-	      return res("\b");
-	    case 118:
-	      return res("\u000b");
-	    case 102:
-	      return res("\f");
-	    case 13:
-	      if (input.charCodeAt(pos) === 10) {
-	        ++pos;
-	      }
-	    case 10:
-	      lineStart = pos;
-	      ++curLine;
-	    case 8232:
-	    case 8233:
-	      return res("");
-	    case 56:
-	    case 57:
-	      if (inTemplate) {
-	        return res(null);
-	      } else {
-	        errors.strictNumericEscape(pos - 1, lineStart, curLine);
-	      }
-	    default:
-	      if (ch >= 48 && ch <= 55) {
-	        const startPos = pos - 1;
-	        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
-	        let octalStr = match[0];
-	        let octal = parseInt(octalStr, 8);
-	        if (octal > 255) {
-	          octalStr = octalStr.slice(0, -1);
-	          octal = parseInt(octalStr, 8);
-	        }
-	        pos += octalStr.length - 1;
-	        const next = input.charCodeAt(pos);
-	        if (octalStr !== "0" || next === 56 || next === 57) {
-	          if (inTemplate) {
-	            return res(null);
-	          } else {
-	            errors.strictNumericEscape(startPos, lineStart, curLine);
-	          }
-	        }
-	        return res(String.fromCharCode(octal));
-	      }
-	      return res(String.fromCharCode(ch));
-	  }
-	}
-	function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
-	  const initialPos = pos;
-	  let n;
-	  ({
-	    n,
-	    pos
-	  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
-	  if (n === null) {
-	    if (throwOnInvalid) {
-	      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
-	    } else {
-	      pos = initialPos - 1;
-	    }
-	  }
-	  return {
-	    code: n,
-	    pos
-	  };
-	}
-	function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
-	  const start = pos;
-	  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
-	  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
-	  let invalid = false;
-	  let total = 0;
-	  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
-	    const code = input.charCodeAt(pos);
-	    let val;
-	    if (code === 95 && allowNumSeparator !== "bail") {
-	      const prev = input.charCodeAt(pos - 1);
-	      const next = input.charCodeAt(pos + 1);
-	      if (!allowNumSeparator) {
-	        if (bailOnError) return {
-	          n: null,
-	          pos
-	        };
-	        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
-	      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
-	        if (bailOnError) return {
-	          n: null,
-	          pos
-	        };
-	        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
-	      }
-	      ++pos;
-	      continue;
-	    }
-	    if (code >= 97) {
-	      val = code - 97 + 10;
-	    } else if (code >= 65) {
-	      val = code - 65 + 10;
-	    } else if (_isDigit(code)) {
-	      val = code - 48;
-	    } else {
-	      val = Infinity;
-	    }
-	    if (val >= radix) {
-	      if (val <= 9 && bailOnError) {
-	        return {
-	          n: null,
-	          pos
-	        };
-	      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
-	        val = 0;
-	      } else if (forceLen) {
-	        val = 0;
-	        invalid = true;
-	      } else {
-	        break;
-	      }
-	    }
-	    ++pos;
-	    total = total * radix + val;
-	  }
-	  if (pos === start || len != null && pos - start !== len || invalid) {
-	    return {
-	      n: null,
-	      pos
-	    };
-	  }
-	  return {
-	    n: total,
-	    pos
-	  };
-	}
-	function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
-	  const ch = input.charCodeAt(pos);
-	  let code;
-	  if (ch === 123) {
-	    ++pos;
-	    ({
-	      code,
-	      pos
-	    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
-	    ++pos;
-	    if (code !== null && code > 0x10ffff) {
-	      if (throwOnInvalid) {
-	        errors.invalidCodePoint(pos, lineStart, curLine);
-	      } else {
-	        return {
-	          code: null,
-	          pos
-	        };
-	      }
-	    }
-	  } else {
-	    ({
-	      code,
-	      pos
-	    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
-	  }
-	  return {
-	    code,
-	    pos
-	  };
-	}
-
-	
-	return lib$3;
+Object.defineProperty(lib$3, "__esModule", {
+  value: true
+});
+lib$3.readCodePoint = readCodePoint;
+lib$3.readInt = readInt;
+lib$3.readStringContents = readStringContents;
+var _isDigit = function isDigit(code) {
+  return code >= 48 && code <= 57;
+};
+const forbiddenNumericSeparatorSiblings = {
+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+  hex: new Set([46, 88, 95, 120])
+};
+const isAllowedNumericSeparatorSibling = {
+  bin: ch => ch === 48 || ch === 49,
+  oct: ch => ch >= 48 && ch <= 55,
+  dec: ch => ch >= 48 && ch <= 57,
+  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+};
+function readStringContents(type, input, pos, lineStart, curLine, errors) {
+  const initialPos = pos;
+  const initialLineStart = lineStart;
+  const initialCurLine = curLine;
+  let out = "";
+  let firstInvalidLoc = null;
+  let chunkStart = pos;
+  const {
+    length
+  } = input;
+  for (;;) {
+    if (pos >= length) {
+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    const ch = input.charCodeAt(pos);
+    if (isStringEnd(type, ch, input, pos)) {
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    if (ch === 92) {
+      out += input.slice(chunkStart, pos);
+      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+      if (res.ch === null && !firstInvalidLoc) {
+        firstInvalidLoc = {
+          pos,
+          lineStart,
+          curLine
+        };
+      } else {
+        out += res.ch;
+      }
+      ({
+        pos,
+        lineStart,
+        curLine
+      } = res);
+      chunkStart = pos;
+    } else if (ch === 8232 || ch === 8233) {
+      ++pos;
+      ++curLine;
+      lineStart = pos;
+    } else if (ch === 10 || ch === 13) {
+      if (type === "template") {
+        out += input.slice(chunkStart, pos) + "\n";
+        ++pos;
+        if (ch === 13 && input.charCodeAt(pos) === 10) {
+          ++pos;
+        }
+        ++curLine;
+        chunkStart = lineStart = pos;
+      } else {
+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      }
+    } else {
+      ++pos;
+    }
+  }
+  return {
+    pos,
+    str: out,
+    firstInvalidLoc,
+    lineStart,
+    curLine,
+    containsInvalid: !!firstInvalidLoc
+  };
+}
+function isStringEnd(type, ch, input, pos) {
+  if (type === "template") {
+    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+  }
+  return ch === (type === "double" ? 34 : 39);
+}
+function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+  const throwOnInvalid = !inTemplate;
+  pos++;
+  const res = ch => ({
+    pos,
+    ch,
+    lineStart,
+    curLine
+  });
+  const ch = input.charCodeAt(pos++);
+  switch (ch) {
+    case 110:
+      return res("\n");
+    case 114:
+      return res("\r");
+    case 120:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCharCode(code));
+      }
+    case 117:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCodePoint(code));
+      }
+    case 116:
+      return res("\t");
+    case 98:
+      return res("\b");
+    case 118:
+      return res("\u000b");
+    case 102:
+      return res("\f");
+    case 13:
+      if (input.charCodeAt(pos) === 10) {
+        ++pos;
+      }
+    case 10:
+      lineStart = pos;
+      ++curLine;
+    case 8232:
+    case 8233:
+      return res("");
+    case 56:
+    case 57:
+      if (inTemplate) {
+        return res(null);
+      } else {
+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+      }
+    default:
+      if (ch >= 48 && ch <= 55) {
+        const startPos = pos - 1;
+        const match = input.slice(startPos, pos + 2).match(/^[0-7]+/);
+        let octalStr = match[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        pos += octalStr.length - 1;
+        const next = input.charCodeAt(pos);
+        if (octalStr !== "0" || next === 56 || next === 57) {
+          if (inTemplate) {
+            return res(null);
+          } else {
+            errors.strictNumericEscape(startPos, lineStart, curLine);
+          }
+        }
+        return res(String.fromCharCode(octal));
+      }
+      return res(String.fromCharCode(ch));
+  }
+}
+function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+  const initialPos = pos;
+  let n;
+  ({
+    n,
+    pos
+  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+  if (n === null) {
+    if (throwOnInvalid) {
+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+    } else {
+      pos = initialPos - 1;
+    }
+  }
+  return {
+    code: n,
+    pos
+  };
+}
+function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+  const start = pos;
+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+  let invalid = false;
+  let total = 0;
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    const code = input.charCodeAt(pos);
+    let val;
+    if (code === 95 && allowNumSeparator !== "bail") {
+      const prev = input.charCodeAt(pos - 1);
+      const next = input.charCodeAt(pos + 1);
+      if (!allowNumSeparator) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+      }
+      ++pos;
+      continue;
+    }
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (_isDigit(code)) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix) {
+      if (val <= 9 && bailOnError) {
+        return {
+          n: null,
+          pos
+        };
+      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+        val = 0;
+      } else if (forceLen) {
+        val = 0;
+        invalid = true;
+      } else {
+        break;
+      }
+    }
+    ++pos;
+    total = total * radix + val;
+  }
+  if (pos === start || len != null && pos - start !== len || invalid) {
+    return {
+      n: null,
+      pos
+    };
+  }
+  return {
+    n: total,
+    pos
+  };
+}
+function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+  const ch = input.charCodeAt(pos);
+  let code;
+  if (ch === 123) {
+    ++pos;
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+    ++pos;
+    if (code !== null && code > 0x10ffff) {
+      if (throwOnInvalid) {
+        errors.invalidCodePoint(pos, lineStart, curLine);
+      } else {
+        return {
+          code: null,
+          pos
+        };
+      }
+    }
+  } else {
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+  }
+  return {
+    code,
+    pos
+  };
 }
 
 var constants$1 = {};
@@ -142967,7 +142967,7 @@ function requireCore$1 () {
 	var _is = requireIs$1();
 	var _isValidIdentifier = isValidIdentifier$3;
 	var _helperValidatorIdentifier = lib$4;
-	var _helperStringParser = requireLib$3();
+	var _helperStringParser = lib$3;
 	var _constants = constants$1;
 	var _utils = requireUtils$1();
 	const defineType = (0, _utils.defineAliasedType)("Standardized");
@@ -158811,7 +158811,7 @@ function initSemantics(semantics = {}) {
 const {round} = Math;
 const fullstore = fullstore$1;
 const isObject$3 = (a) => a && typeof a === 'object';
-const babelTraverse$2 = requireLib$4().default;
+const babelTraverse$2 = requireLib$3().default;
 const expressions = expressions$1;
 const statements = statements$1;
 const literals = literals$1;
@@ -173614,7 +173614,7 @@ var getAst = (node) => {
     return ast;
 };
 
-const traverse$b = requireLib$4().default;
+const traverse$b = requireLib$3().default;
 const {
     isObjectExpression,
     isExportDeclaration,