solutions

2022-12-03 17:11:42 -05:00 · 2022-12-03 17:11:42 -05:00 · ab688f8b38
commit ab688f8b38
3978 changed files with 1460662 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1 @@
+session.cookie
--- a/_utils/index.ts
+++ b/_utils/index.ts
@ -0,0 +1,65 @@
+import { readFile } from "fs";
+
+/**
+ *
+ * @param filename {string} - name of the filename to read
+ * @returns - a Promise containing a list of newline-separated strings
+ */
+export function readlines(
+  filename: string,
+  filter?: (value: string) => unknown
+): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    readFile(filename, "utf8", function (err, data) {
+      if (err) {
+        reject(err);
+      }
+
+      const lines = data.split("\n");
+
+      if (filter) {
+        resolve(lines.filter(filter));
+      } else {
+        resolve(lines);
+      }
+    });
+  });
+}
+
+export function group<T>(
+  lines: T[],
+  cutoffPredicate: (
+    previousValue: T[][],
+    currentValue: T,
+    currentIndex: number,
+    array: T[]
+  ) => boolean,
+  includeCutoffValue: boolean = true
+): T[][] {
+  return lines.reduce(
+    (previousValue, currentValue, currentIndex, array) => {
+      const isCutoffPoint = cutoffPredicate(
+        previousValue,
+        currentValue,
+        currentIndex,
+        array
+      );
+
+      return isCutoffPoint
+        ? [...previousValue, includeCutoffValue ? [currentValue] : []]
+        : [
+            ...previousValue.slice(0, -1),
+            [...previousValue[previousValue.length - 1], currentValue],
+          ];
+    },
+    [[]] as T[][]
+  );
+}
+
+export function sum(a: number, b: number): number {
+  return a + b;
+}
+
+export function emptyLines(line?: string): boolean {
+  return !!line;
+}
--- a/day_01/input.txt
+++ b/day_01/input.txt
--- a/day_01/sample.txt
+++ b/day_01/sample.txt
@ -0,0 +1,15 @@
+1000
+2000
+3000
+
+4000
+
+5000
+6000
+
+7000
+8000
+9000
+
+10000
+
--- a/day_01/solution.test.ts
+++ b/day_01/solution.test.ts
@ -0,0 +1,27 @@
+import { readlines } from "../_utils";
+
+const solution = require("./solution");
+
+describe("day 1: calorie counting, pt 1", () => {
+  test("sample input", async () => {
+    const sample = await readlines("./day_01/sample.txt");
+    expect(solution.part1_solver(sample)).toBe(24000);
+  });
+
+  test("submission input", async () => {
+    const input = await readlines("./day_01/input.txt");
+    expect(solution.part1_solver(input)).toBe(70613);
+  });
+});
+
+describe("day 1: calorie counting, pt 2", () => {
+  test("sample input", async () => {
+    const sample = await readlines("./day_01/sample.txt");
+    expect(solution.part2_solver(sample)).toBe(45000);
+  });
+
+  test("submission input", async () => {
+    const input = await readlines("./day_01/input.txt");
+    expect(solution.part2_solver(input)).toBe(205805);
+  });
+});
--- a/day_01/solution.ts
+++ b/day_01/solution.ts
@ -0,0 +1,97 @@
+/*
+--- Day 1: Calorie Counting ---
+
+Santa's reindeer typically eat regular reindeer food, but they need a lot of magical energy to deliver presents on Christmas. For that, their favorite snack is a special type of star fruit that only grows deep in the jungle. The Elves have brought you on their annual expedition to the grove where the fruit grows.
+
+To supply enough magical energy, the expedition needs to retrieve a minimum of fifty stars by December 25th. Although the Elves assure you that the grove has plenty of fruit, you decide to grab any fruit you see along the way, just in case.
+
+Collect stars by solving puzzles. Two puzzles will be made available on each day in the Advent calendar; the second puzzle is unlocked when you complete the first. Each puzzle grants one star. Good luck!
+
+The jungle must be too overgrown and difficult to navigate in vehicles or access from the air; the Elves' expedition traditionally goes on foot. As your boats approach land, the Elves begin taking inventory of their supplies. One important consideration is food - in particular, the number of Calories each Elf is carrying (your puzzle input).
+
+The Elves take turns writing down the number of Calories contained by the various meals, snacks, rations, etc. that they've brought with them, one item per line. Each Elf separates their own inventory from the previous Elf's inventory (if any) by a blank line.
+
+For example, suppose the Elves finish writing their items' Calories and end up with the following list:
+
+```
+1000
+2000
+3000
+
+4000
+
+5000
+6000
+
+7000
+8000
+9000
+
+10000
+```
+
+This list represents the Calories of the food carried by five Elves:
+
+    The first Elf is carrying food with 1000, 2000, and 3000 Calories, a total of 6000 Calories.
+    The second Elf is carrying one food item with 4000 Calories.
+    The third Elf is carrying food with 5000 and 6000 Calories, a total of 11000 Calories.
+    The fourth Elf is carrying food with 7000, 8000, and 9000 Calories, a total of 24000 Calories.
+    The fifth Elf is carrying one food item with 10000 Calories.
+
+In case the Elves get hungry and need extra snacks, they need to know which Elf to ask: they'd like to know how many Calories are being carried by the Elf carrying the most Calories. In the example above, this is 24000 (carried by the fourth Elf).
+
+Find the Elf carrying the most Calories. How many total Calories is that Elf carrying?
+*/
+
+import { group, sum } from "../_utils";
+
+const groupSnacksByElf = (lines: string[]) =>
+  group(lines, (_, line) => line === "", false);
+
+const parseCaloriesToInts = (snacks: string[]) =>
+  snacks.map((calorie) => parseInt(calorie));
+
+const sumCalories = (snacks: number[]): number => snacks.reduce(sum, 0);
+
+const findMax = (a: number, b: number): number => (a > b ? a : b);
+
+export function part1_solver(lines: string[]): number {
+  return groupSnacksByElf(lines)
+    .map(parseCaloriesToInts)
+    .map(sumCalories)
+    .reduce(findMax);
+}
+
+/*
+--- Part Two ---
+
+By the time you calculate the answer to the Elves' question, they've already realized that the Elf carrying the most Calories of food might eventually run out of snacks.
+
+To avoid this unacceptable situation, the Elves would instead like to know the total Calories carried by the top three Elves carrying the most Calories. That way, even if one of those Elves runs out of snacks, they still have two backups.
+
+In the example above, the top three Elves are the fourth Elf (with 24000 Calories), then the third Elf (with 11000 Calories), then the fifth Elf (with 10000 Calories). The sum of the Calories carried by these three elves is 45000.
+
+Find the top three Elves carrying the most Calories. How many Calories are those Elves carrying in total?
+*/
+
+const findTopThreeElves = (leaders: number[], calorieSum: number) => {
+  const [first, second, third] = leaders;
+
+  if (calorieSum > first) {
+    return [calorieSum, first, second];
+  } else if (calorieSum > second) {
+    return [first, calorieSum, second];
+  } else if (calorieSum > third) {
+    return [first, second, calorieSum];
+  } else {
+    return leaders;
+  }
+};
+
+export function part2_solver(lines: string[]): number {
+  return groupSnacksByElf(lines)
+    .map(parseCaloriesToInts)
+    .map(sumCalories)
+    .reduce(findTopThreeElves, [0, 0, 0] as number[])
+    .reduce(sum, 0);
+}
--- a/day_02/input.txt
+++ b/day_02/input.txt
--- a/day_02/sample.txt
+++ b/day_02/sample.txt
@ -0,0 +1,3 @@
+A Y
+B X
+C Z
--- a/day_02/solution.test.ts
+++ b/day_02/solution.test.ts
@ -0,0 +1,27 @@
+import { readlines } from "../_utils";
+
+const solution = require("./solution");
+
+describe("day 2: rock paper scissors, pt 1", () => {
+  test("sample input", async () => {
+    const sample = await readlines("./day_02/sample.txt");
+    expect(solution.part1_solver(sample)).toBe(15);
+  });
+
+  test("submission input", async () => {
+    const input = await readlines("./day_02/input.txt");
+    expect(solution.part1_solver(input)).toBe(13675);
+  });
+});
+
+describe("day 2: rock paper scissors, pt 2", () => {
+  test("sample input", async () => {
+    const sample = await readlines("./day_02/sample.txt");
+    expect(solution.part2_solver(sample)).toBe(12);
+  });
+
+  test("submission input", async () => {
+    const input = await readlines("./day_02/input.txt");
+    expect(solution.part2_solver(input)).toBe(14184);
+  });
+});
--- a/day_02/solution.ts
+++ b/day_02/solution.ts
@ -0,0 +1,127 @@
+/*
+--- Day 2: Rock Paper Scissors ---
+
+The Elves begin to set up camp on the beach. To decide whose tent gets to be closest to the snack storage, a giant Rock Paper Scissors tournament is already in progress.
+
+Rock Paper Scissors is a game between two players. Each game contains many rounds; in each round, the players each simultaneously choose one of Rock, Paper, or Scissors using a hand shape. Then, a winner for that round is selected: Rock defeats Scissors, Scissors defeats Paper, and Paper defeats Rock. If both players choose the same shape, the round instead ends in a draw.
+
+Appreciative of your help yesterday, one Elf gives you an encrypted strategy guide (your puzzle input) that they say will be sure to help you win. "The first column is what your opponent is going to play: A for Rock, B for Paper, and C for Scissors. The second column--" Suddenly, the Elf is called away to help with someone's tent.
+
+The second column, you reason, must be what you should play in response: X for Rock, Y for Paper, and Z for Scissors. Winning every time would be suspicious, so the responses must have been carefully chosen.
+
+The winner of the whole tournament is the player with the highest score. Your total score is the sum of your scores for each round. The score for a single round is the score for the shape you selected (1 for Rock, 2 for Paper, and 3 for Scissors) plus the score for the outcome of the round (0 if you lost, 3 if the round was a draw, and 6 if you won).
+
+Since you can't be sure if the Elf is trying to help you or trick you, you should calculate the score you would get if you were to follow the strategy guide.
+
+For example, suppose you were given the following strategy guide:
+
+A Y
+B X
+C Z
+
+This strategy guide predicts and recommends the following:
+
+    In the first round, your opponent will choose Rock (A), and you should choose Paper (Y). This ends in a win for you with a score of 8 (2 because you chose Paper + 6 because you won).
+    In the second round, your opponent will choose Paper (B), and you should choose Rock (X). This ends in a loss for you with a score of 1 (1 + 0).
+    The third round is a draw with both players choosing Scissors, giving you a score of 3 + 3 = 6.
+
+In this example, if you were to follow the strategy guide, you would get a total score of 15 (8 + 1 + 6).
+
+What would your total score be if everything goes exactly according to your strategy guide?
+*/
+
+import { emptyLines } from "../_utils";
+
+export function part1_solver(lines: string[]): number {
+  const score_map = {
+    X: 1,
+    Y: 2,
+    Z: 3,
+  };
+
+  const result_map = {
+    AX: "draw",
+    AY: "win",
+    AZ: "loss",
+    BX: "loss",
+    BY: "draw",
+    BZ: "win",
+    CX: "win",
+    CY: "loss",
+    CZ: "draw",
+  };
+
+  const result_score_map = {
+    loss: 0,
+    draw: 3,
+    win: 6,
+  };
+
+  const scoreRound = (opponent: string, player: string) => {
+    let score: number = score_map[player];
+    score += result_score_map[result_map[opponent + player]];
+    return score;
+  };
+
+  return lines.filter(emptyLines).reduce((totalScore, match) => {
+    const [opponent, player] = match.split(" ");
+    const roundScore = scoreRound(opponent, player);
+
+    return (totalScore += roundScore);
+  }, 0);
+}
+
+/* 
+--- Part Two ---
+
+The Elf finishes helping with the tent and sneaks back over to you. "Anyway, the second column says how the round needs to end: X means you need to lose, Y means you need to end the round in a draw, and Z means you need to win. Good luck!"
+
+The total score is still calculated in the same way, but now you need to figure out what shape to choose so the round ends as indicated. The example above now goes like this:
+
+    In the first round, your opponent will choose Rock (A), and you need the round to end in a draw (Y), so you also choose Rock. This gives you a score of 1 + 3 = 4.
+    In the second round, your opponent will choose Paper (B), and you choose Rock so you lose (X) with a score of 1 + 0 = 1.
+    In the third round, you will defeat your opponent's Scissors with Rock for a score of 1 + 6 = 7.
+
+Now that you're correctly decrypting the ultra top secret strategy guide, you would get a total score of 12.
+
+Following the Elf's instructions for the second column, what would your total score be if everything goes exactly according to your strategy guide?
+*/
+
+export function part2_solver(lines: string[]): number {
+  const score_map = {
+    rock: 1,
+    paper: 2,
+    scissor: 3,
+  };
+
+  const result_map = {
+    AX: "scissor",
+    AY: "rock",
+    AZ: "paper",
+    BX: "rock",
+    BY: "paper",
+    BZ: "scissor",
+    CX: "paper",
+    CY: "scissor",
+    CZ: "rock",
+  };
+
+  const result_score_map = {
+    X: 0,
+    Y: 3,
+    Z: 6,
+  };
+
+  const scoreRound = (opponent: string, outcome: string) => {
+    let score: number = result_score_map[outcome];
+    score += score_map[result_map[opponent + outcome]];
+    return score;
+  };
+
+  return lines.filter(emptyLines).reduce((totalScore, match) => {
+    const [opponent, outcome] = match.split(" ");
+    const roundScore = scoreRound(opponent, outcome);
+
+    return (totalScore += roundScore);
+  }, 0);
+}
--- a/day_03/input.txt
+++ b/day_03/input.txt
@ -0,0 +1,300 @@
+jVTBgVbgJQVrTLRRsLvRzWcZvnDs
+dhtmhfdfNlNNldfqmPCflqGbNZDHsDWcRzvczWsczZNzHz
+tmwwwCCfbJSMbwMb
+hsrZZhHlhrHmPPbMbDFDQdnQgLfMFDdDQQ
+GpBtwtqrcCcjgnLgqfgDDgRn
+cJwVwpCpGJctJtBcCrSCGrVJhlsbvSvTvbmHmmsWmHslmsHm
+gCtWJvmfmGGwVVMhJw
+nzRSpZbSVFFRDFSDzcplddqplqMhQMclMp
+zFLszzRTDnZnbTZTRZsVNgCjrvfvgtvNmtfvLW
+glRQRpQQtQtGtQws
+TnmbLqvBFRFFLPBFnPbvRBhshTtHWhwzdwtHdsdzWhws
+qmCLPNmCFnLBnmPPqVbFLRrJjVggDgJjlZVVDjDlDD
+vRRgpWvPQFdTFDDNQs
+bqtCmltmlbwqLVLZqwtmLBBTMcGBddTTBgFNGcZGMD
+bbtmJmjlVlwblwwbwzbbvrrznvzShgRhRvhfWrWn
+ZMhThfNcpbbMNNjsHpmpsRqsPmRs
+wQjDgggQDPqqDlsD
+SCwSzvLVCSVtQVgLnrccfdGdTdZfcZMtjJhG
+wNnNmNHnNPPwwPGCrLSZZvdVVZvBtMMvdm
+WQzlhzjzbBtMMlBrMl
+szbgWhJjTTcsWTqgzsqcsGHfwNcwfwnHHrCGCPPGwr
+CNsbpFCMSrmDhQHNNGmH
+fQPPPcqvljQzjVDDgRBhGGqDgqqD
+ZctlcVzcfltQtnrndbQMCM
+NQjQjQvZvZjcvrrrNjgTQgBQwTJsJswJlbGstqqtmGhmwhqw
+PWpHRzRnPHHSCnPFwlqhbtqGZClJqGqG
+ZzVpMpWPHnVzzpWzDRzSZrcdDQdrQNrcQgQfjcNfjf
+BSZMtdtZBzMFvhCbBJDbhDDC
+qcqVVmccrmVcjrlHqTrjDJRPQhWvPWWfPvblffDf
+cHTrbGwpmGwVjdFMnzpLznMztd
+DGDGGbNgTgJQQLMRMMTNVzvPsPbdsfPVsdVVZfPf
+lcCmmlpwwnwSjCHtFpCpHzCrZsVrBZZzdvDfVrsfZd
+lSHwnjpFmppHqppttttcFmnhMLGNRLhTMDqJLQNLLQNLhJ
+WqWfDWBjBjLbfcbbqGbWqQsrFFztsppMFCzgCJzJCrFpCM
+VRlhdHZTZVRRmZwlmFrJwFpMMDDrrrtJwg
+PPVddvvDZmRmHvndTHmLcbcjSjLQBGWGGQWSqP
+HHvgvwHMPMwHwmcRfJNFchFGNNCm
+BsTDsjzBCCBJGffN
+jznSnSdqzqnQTbdDljQjQSMHWWvvgWvtZlrWpPfWwtPr
+DJCJJCNjCDRfDfDRhDnNhfjFPgbGbddBTjFdTFTPbgGSdF
+cmMcMVqBZVcwsGFgGqgWdFqb
+vcZVzwmHVcrtrwMMvvmBHwNNCDpQRfhLhrNJNfJDDDRC
+VWSSScsncpDRdnsWsVncVzTwMMMHtMTrLTLMMVHM
+fjJvQqBCQNhfQlZZnqmFHLFMTFTzwzLzrHMB
+CqfjjQZJPjjvpRppDPgbnSnP
+tLnjNwjRWttdCwRLsfGzfzPbzbWbQQPT
+cvvBvlBrFrlTffsbfTqZ
+vmrFpsrvFMMMNwhtDwhN
+wzgRNqwtgzMWtqGwCssBBSBZnSRsrQQS
+bbjLTmpjpHcpVncVdmffPCDrjZDSDsZffDQC
+pbVFncvvbpbbHJJHVdvqMGMJNwWlNlJMwqzlNM
+TdszlzFsRQqFdRzqwwQGlFsGmmSBBdmdVVmgSZdSPZBBBmSD
+HMCCMbJHJJLHSmSvZLBcSDBP
+NWbhPjfrbbNfWCPjhNnGsNzsqpQszTQGRwGQzR
+ppQpTNCPBTlNBVmNQTNrrrrtqsrWbGrVFWqhZb
+DMvDHnjRvMDLghhhgbqZWbqFSS
+vWvMRRJDLMnHLJjDwWnnndcllNTzBmClQBpBBzQQzCBzCJ
+VsNZfPMnrCnlCnWtbvBbvwtTbZwT
+JhJQdQhmRHDRdLmHJhljhphgGwtttmcvbwwTWtvtbGBttc
+jqLpjSLDHlhnffCMzsqCPP
+JzJdLRmmzJwrLLwLJwLTWwBrMrpHlFnScVVqccrBHSlc
+tvQDQhjhvbqFqFSpjHSV
+QbgZtsgfbNNQbgbsbQRfmWRJwJGWWTPRwqzR
+MwvDgpwszSpSJPsssMccTQfTDfTQRTljfRfT
+PmGbWhbVtZWPTqRrcTrrjTrt
+NbZbWHBmVGmLbZVBVNLPsMBzwSSzMJMCsCzvnvSp
+cTpgTnpzbZlJHTZm
+jRrLVtqtvtrjqsHZhvpmBfJHmhhp
+FqDsFLCwCVRDqwgNQcQMwnncnMpg
+sCCtssdZdZJmMbNJDmtmJzLSrcGfHGLTHDHnGLrHTSSn
+gQwRRWqwqgpggFWPjPpFnSTSnHNfLLQrccrLGHLL
+qqlpqhjFwPgPwvvRgFlPdslZCzMZtVdtVdVMtJlN
+BWVmPtRVRRWDNtZBVQzCfdscmfjcfdfzzSfz
+MhgJLbGggHbqpGgpgJbrFJdjwsCChCzllzCdjDSszCCD
+grpDLFrbgpJnqJrHGFHGqMHBBPRWQTPWZBQVTQWnPNVvBt
+gJfggdmHDgfJJWzCcbqvcqcmTG
+hLZlRBZNlBlrpprzrWqvtHvvGtbvHT
+sNLRjHZLNVnZZVLppnhNsMFJSjFPPQMjwgMPPfDMfS
+mDDzHfrPBvJRJhpBRg
+SsTSTwJwcbCtwssGFVWppgZRbLpLRNhpLhbLvg
+ttVCGjTGrfJJMfjD
+ffhcsTjnfqHLqvZSHvHB
+CsgmPVmstsQVpRbHBvFbHBDMvZLZGB
+ppgpmmRVpVPwPrrrTNlcrwrlWs
+NDtssPNBjQtCtCcT
+ZZqncfqhZqhJZFTJTllCGVljSl
+ndrWbfZwWhngwbqbZnMZcwWhDmmLDmzvHPvzNLdmzsvBBHHP
+FQtptwMppSFQRRQfSfvTrTJJJTrvLjMMJbgJ
+CcDqWBWzbldcchDGCWBCBhdGrvhnrsrjjsJvLvghrjjnnjsJ
+GDBldPDGqPGWVBBcwHFmSmbpSpNRwHFV
+CwHwCFwtCmdCDflHDpwFnnvzhhNJhJNzmhzhhNMM
+sTbZssPqScTrqSWSShdMvgMRRzdRRQ
+brBrsWPTrdrWsPcBcTcGqDLDDHjFfDClwLLBfFlFlw
+lNptNFWpbVMjlBgQgvdNBRQLrd
+TsDCDfSCQqqQQqDq
+TwTmwPPPzZSCccScJwpWZHljtbWMFFQVHpnj
+fhFmwbrgnCcSnwtS
+vZVVZvQZVPZsMnNSccMHPN
+ddzvQJvQzBzWRTJzdRVSWGqbRbgmfbFFbmbgmpmlff
+wdslVdQtdlBVHDrHBcBc
+TJWvpncCcJzCWcRfWvJRRpfZHBDZZHmDZPBjZHjZrSfb
+TRJFvvWpTRRWCpCgGtgtGQdlcNtsGlwg
+rCHvRLJtCjpbRCLpptHMVCQgGlMndVlQGNcCMc
+zZfzSmsfSsMzMccQMVcN
+ssSmPmSmhwVhZBZsTBRJrtRjtbDvjvrTHLtJ
+wswRCNHHhsrWFsGfGWFBGb
+lLtngDPLgLJPttgWzQWlbCfBlmBFCW
+DcDnVpcnnJPngjjcdpRhwNZSCZNdNdvr
+NWNzWpfMRHfwsRNznPdjtdjJtPVPHVdJ
+CSLTZBrGbSmClvBVdGzFVVcFdjjjnV
+SrZhZbTvmmbbLvwQzMhsfhqqWwQR
+vvZqwFBZvzZzrqltPsQstrGGpMcbbR
+bhJdjJJmTRQMTMMPPM
+mCmgLbdVVVLhVnJmLgJhBWZFDlqFvwZDlZBnBvWB
+sMrcmQcHHsLLrSHZhvdCddvtJJFl
+jzjjWplWpPRPDzPzfRGjqvdJqqqCtqdqDvdDqtwC
+pPNWVpGGVVffPlnSMnMsTmgsQVLr
+zGMMRbpGmqqqNRmmzbNfbzPRPlvThCTrHPnrHSVPlTHR
+LSjjwgsjtTjhPhHhvC
+dJZtJwFgtBLDZZbmNMGzMMqS
+ZrnstppPWccnsFWpnZnRdjRtjbCtSSRjjjLLbG
+JgBQPJvPgHHJvmmzwGGLdjHGSjShGHqdHL
+wTJvPzmTJvzJQBfwNmTmlPsrVfnVFpcMVZprDpFrsrVc
+ssGCtltsSdJJtQjPdvHvfbfvqLHqZtBfVb
+pzRwwDwDTgzbqVTVvHqVWB
+grzHnRpmFpDMnmzFhplJCjlsPdGJSjsFCdFs
+CTGBBGCBlSTTSsnTMrQbNrBMtpVzNddWHWzVpHVtdHmwhphm
+JqPZgMRFFvFZvDZMDFcFFfDchdtdPWpzpWhtHWwwhVzWpddW
+ZfLZMcgqRDjgjcLccDRDLsbbrSBBlQGQBCTrCBnT
+VjVGVqSqFLFVSqCjFJSsbfPprHbCCRRPccRWPW
+wwnQmtwlvNmpZRsPsWWNbZ
+DBhhhznhddldnvjMqJMTqDMGPSjF
+TTJbsJPPBDsBVbJJGJBGWLfmWzgmDmzmLqmmLddQ
+jHwVZZjwFZlzLzWZLMdLqM
+HHHhjHplrHSpcCSvjlsNPbNRbRnVTrRsNNNJ
+NzMMLZtwRmbwFnVDhnqD
+SlsJsSdSJdNJnFphVHFjph
+vlrsTlGPTgvvSBScGcBvfzmmLLCtMWNZRBQMzftf
+tRFLmZZRLrtRvtvvrvvGgvtLNfwzMzNwgdznMpwwpnMpqHdz
+hcsBsWTcQJhjbHMncNwzMqnzwl
+VWSWWTJhWBVDTJsTVWQWTVVbZtCPSvrrGSLCRFRGtRZLPmmq
+hbdFhdShGsFSGBlQhNhQMLLLlLJCvLLDtVJDLlwtwD
+WcqWsmcWrmqcmtDHJjVHrJCjjt
+WPWcnggssmzqzzzgfzZnWRqqdGpSNFdMSFdBMSFZhSFBZZhh
+GNFNtRQMGjDjwfgDZjmz
+bqDsPWWbsqVsdvvBJvBfmgfLLzSwzLcmzmfB
+WPWrrVrrVJhVWJDVsqnPdRQllRQRNhQGMlFQFMplGl
+mChChmSQGSGJrjPHCpPFtwgsFZjtFVZfgVwtdV
+MBMqvDWMlTbzlRWzllDzblZfsrgdZffgrtwrswZfdZTd
+DlcMvBbBMnqMDqcRqDBMWvLmCGrGLSJhnLHCCHHnPmSQ
+tscfGqftGfDnnppJGDGCZLbzMVMwPPhsblzbjzzMMz
+TWPTWWmHTmFRSBSvgBPwwwlVzhMdwblhbVjRLL
+TTQNNWWgHWQHPBWTNPWNcqJtGCnfqfpQZJCZpQZn
+CqzCGDQJCzzftfRqRzzMdvFpFpccdZFvFMtMbd
+rNHwmHVmswsHVsPTLnbFSTbZZpFcpvSZZgpg
+vPLhLLwHLhVVNVvQhBqDCBfhDzCffG
+WsBbBbsWNhsPsCNssRWLPLpmLDDQHlJlnlzFnDDnzF
+gcGfqggMqfjjGwrdDZzQFmpJQzZlFDMF
+qdwqvjdTrwfvvBCPtpVvtR
+RQdbbRHtHRvqZtwVcmwVwV
+WnLNnqFDlDWzzNLLrjClwCZCGZcglGCccZ
+LnTFfWBpffrfrhBqdsSBqhBJHb
+sqsgJpDMrNQgGsFMsPCfjCPChPWjqSWSjh
+RBnRnZVcwZllLwbwwLbZVLclhpjRttSdtjPhjWShWdphjCPd
+HwHwVVwVnBVBmmGppNFzrrsgJJ
+WpmDFlQlzmmgMMLMLQVTvTTSwNbmTVwTtHHw
+jrhPDnDnnZfjPTNtHSVTcjccwt
+CJqPfGnhGZCBfnPJCrBCqdLqMlQqDLlLRgLQFFRW
+vZVvDZsvhDZhZvzgVcgVqPqmwWMqcw
+bdTbdBBFQcdCdcGmcP
+bmjQpHfbpzDJRjNhJZ
+twRrwjFptprQjjjtQRdWCmNJTlNSCmZQcNlmlSST
+VVDzMWDnDHMzLZDNNJSqqCJZZD
+HHhhsfVHGbnwgjfrgdpgWj
+GmszZGMrLmnmsfGVRcVlwtwccc
+SSCgbNqSTgCCJMHCJtlVcwVbVljlclVfwf
+HTCgHSgHQThMqWQQSgDnvBdsFDvrzdZsLdmLZZ
+PRlMlBPPctVBlstzVLhsdwCqCdCNDjSDdWmMqdNw
+fZrQQHFffgGFprSJSgvZrfnqjmWdnndCNGWmWDwNNDCG
+rTvvpJZZrfpFSbQQvrrsssLRVPPtlRtRPThzTR
+FqgHFFMRTRjRFRpRRjFtNdCtJCMnNNdrdMLdrQ
+VhWSmwGwWVbGbvlwwlLZJLZSdJZtNCtnTSCJ
+BmWwWWzhvVfwWhmhwlmvwlRqHpscHRTpTDRFfTsjDPjD
+MJMgGqMFLPGgWVjpcmjZTpmZjZpJ
+hdSzzlCtzNdtWSdndttflBmjpBRmvvpjnjcvBjmvHj
+zdhCrfztrDSzfWzdChrhlhgPPPGDgqFFLGGFVVqqPVQw
+ZQZNQRZzFdCCgfLcCGDfScjDcG
+vsmwVHTmTfGcSHjcDS
+tMsmMVlSWWzdWNnQNJ
+GPRcQnwwQWwFFnrnnldSqzMfSCdfdldrJf
+LpTsjmZTsBZjpmzhLLMdSJJSMhCC
+ZsZBssBsDpDmmVBjCmDZHgnVNWvPQPNPGvNQncQPcRWn
+pznzpzlGFrvGHGrnnMvDmBMfgfTmsBsTTghDsg
+LJtWVCWLCNPcSbdcShWBgBThgTfjzwfhhz
+VZZCdLCVNNCVbCLzFnRqGqlHprQZHRqr
+dFTsQPdMFsMnWFPdSnwBltftttvlflNN
+VLZhZLqghCgzqgrLrcgVgbCvtDDtwpqNpDtlBRflDwNqDpNw
+cLmVhVcgbZrVhrhCLhczhQdJHTmPJJTjvTJsPFWFTW
+SSwNPNHldNJSngHqBssQvBfccB
+mMppmDprWpFGRGWmWrDrtGzQfcvvQZBBzzczqRQgRqRT
+WtFtFvhvpLphNJJVSCbSNP
+chpGMMzcwSSGnQFRQQFWcFWn
+sgddTfjLqsWrRtLvQnJr
+CsmlZgssbRdMhzCHDGpGGG
+vHBrTzpMPTHMtbBRRJGtDsNB
+QJWWVwnCZmQlWQWlLWCCmmLwRgtDdDbgngqtRdRGbDNDGtGq
+LwmWQLJcWmwPrpvpjjrcjT
+fcsWnWzhWcWgcbfbvtbHTRvpvHttmLtR
+lNSjwjrDFjlFhlZlQTpLHvSHptvTSRtLmJ
+NwjwrQDwFCZBCfWzqhqqzc
+fgNJNRcvvWRfWRrZFldlwlFwfFllflDH
+spQshQhpqhJsLpnQVLqBqlFwddHSdBFFjSFmwlFmwl
+hppLsqPVLnpnzJPtqtPPJTCgNcrcNbrrGNcgRNrzcZbG
+PWFdgDGCFPGhMtQqHBrpJqqW
+nlllLNmnVNNLllVbVRLRsQMqqpccQQJcJtqcJcnBrc
+NmvZLsNrbZNjNZVNGvdFFfwdDhPFdDzC
+LpZpwgLsLSzDdjVGpS
+bWBlHqqBhNJWNbJQFzGtCtDtGGjNGDgtGC
+RBRbJggbWRRmhWqTcnnfnmZMTTsTcP
+JJgzvfzpdzzJjJhgdfhvqfdScNsLwwGsrRbwRLbcbVrVRp
+WDFBTTDtHTntltnCnnntCDwGlGGbSwNVSssrbwGVsVLs
+nCHMDtCWWTCCHmmPDnZQgvfQgZNJJdvdMZQg
+lFDgvlsGvvZGDsFZWgGvWrPqnmwwtqmMVSWrSqMM
+hRpJhLQHhdTTVPmVSrqwtHmV
+ctJJJfjLpjglZDGCGljF
+CnnVMbhVRbQQZjBP
+rlfsLFLtmLSJscttFfsdjZwZNNwBPWRjRNZBZBfQ
+tFrmDFlDtmcltFvqVzDqQzGvCVCG
+JzzJzVrmzJpCCmTFmjZS
+HtDDtggWssqWfDgwDWvsfDBBchZjSnGGpCFjSFZjpGjFShZg
+sbvbvfbbDblWtrNVNRzRlJPCzM
+nlFnFWsWhrctWVdJPDPTnTNJPJQJ
+fHqvHSqRqSHjBmqvmqqHCtJSTZGdMQJDPQDPPMdNTMZN
+jzqmbtRRztmbLHcFpgWVsFphpcLV
+PHZFZFVZZfHgpwjFtmgjtq
+rpTrTNzzNdrTJwgMwqCBJzJz
+vsTWbvccRcdRbrRnRRbRrcvVpGlGHZPspSVhSPPQGGZVHV
+HWnDDjfPFccDPhfchnMMVWGzzpvGszCCGWWV
+JNBtBTQJNwJQjTpRVRMvpLsQzsRR
+JltNSrBjmrHfdPHnDlHg
+ldCJHlZFspjzHMnp
+zvcLQBQcQvhBwmcDppqbNpjMLnLDDn
+BvcmQhWWRzPJJzWWWg
+ggSTPZBwTPTPSTRwZPBnwPMLdVvBqzsqLzqqtVzqtzBszN
+QRmhQhffCQhJcDfmpChQWJmJNNtzvqtLdvNsGtLqNGzvWqvG
+HQFCDhDFCCQJQmZTZwTSSwrZnRFS
+QbFlsMbgPWPlJWzsJsJZntvnvZtctHBfZvBZlD
+VTqpTqmSrhVLqrpjNppgntfBgfjddHffZBdtcB
+VCwpqqqNVgNVgMJJwbsWWGMGFR
+GCwRjQlsCQrPrGMQPsRvpdvgnjgmVVmSStptgJ
+DzNcZNHZZhzzHhDzDTLWhDzSdJSSpnnVSTSvJJmgvSdmmn
+pfLNDppNWHqDWfWbzcHPRslCGbwRCPwQrGQPCF
+hVLnDgCmbhltrmDlhbhVmcgFBWdSBSZZBFPwBLBPfWdPWZ
+TNTjJNpjqGMTRRsTTCZddfWwFHFWHSSJSFPS
+CGQqvQRTNzTpQsDtmcrgDQllhnQl
+SWrtcHWjcWrPcwWrBwSPffnJNsqfMNCNqNfJFfSq
+QLQvhBpbbvdvTdvpTdGDbDQqqqslsNMJlMMCqMfQnlfC
+gThhpmDLbzBmGLptrmRZcwHWHZjVrW
+gQvzQRvSSbvvJvQgfRrfbSpGqBPGwqwVjPBBwwjpRmjB
+TcNHHVVtNsDHcMcdMBjqpBnGnwlGTwlPBl
+MHsMDHFMdDtZddZdFdFrhhgbFFVvffrzzffrrS
+QSFmrDSSQrqlfmDDHPRTdrrTPRbsTPTsNN
+wBcclhhgwgMhWLLtVMgVvzRTNNjvbszzTdjNdsRbjp
+nJgVMtBhwLBctmQHQlnCGqmQZZ
+sggtjzzggfGmPbCMvRCMvTmT
+RDqqhdQdDlcDpqVlLbSbZFSTTPllbCMv
+hqpQWRhhdncDQcBsrwzjnfgtgGfgHs
+MTrzlgMNQNggrrrPlzQDPCsFRfscTfFVhVftRsFFsScS
+nWWHZHhZWJjjwjLjwbLbwHGSFppVfFVcGcFLfFSVttpf
+jWhZZBhqBbwvZvBjZNNQrQQQzPMlzzglPB
+jLVhJZQjwFCLRjQhPRZFLDzrGDHpDGsGqztGHststC
+SBNlNmWnfvdLmlnvfNSbzrDTTzprdqrDpGqqpHrG
+bNmSBnBmcfMmcmnlfcnNSnLhZPVVJhwjZRJPwjZMPjMZ
+VpzBDgGTGVNNpSGzppMdTQwcvFdFMQdcdFwc
+ZDsqfRftWtllmlWbLLtjFFMwMrjCcwfvMFvwcC
+PHbDLHZtZJSJPpVgnV
+bRvTdswLLSTvwswSbDhsDTvFmmGRVmJGZJnRcGGfFVJcqn
+MWllQMllWHrjWPNplrllQMPZJmnnVmqJcNmVFFnJNFqVGC
+PgpQrQjjzQWHzpBdvtwhwdSShBZTsT
+MhTwjMTsTRFStjmSMqqppBrHpDrzHtPqbD
+dllNcZWgldLvcsvvvvgvWddlHffqBHBBfPzbbqBpPHrpHNbq
+VddvgWWdCZhnhsCSSCGT
+LPjqHnDNqqHNllqLpqPCZCGRCssGdGrGFrPrgr
+WVBztWTQSQMBQrGgRwwwCGgtwg
+QJMTgvbTTWSzWWvSbVJTzJllJlHHhLpNqpHqjNjNHpjq
+PCHCbPPPHPlTThBhjGTTNhMNTh
+FrmfLqdqgfmfttqtWqfrqdhshchDBshDllDBcGDhGDWs
+mqgdpvFmmdLdqqQCPHZZblvwZQZl
+bQGqmngwwgSNrBWJWdHZmjfZWB
+FlpRLCptFLMlLPRLlCCcCCMpjJZJHShWdWvBHHdcZdBWZvSv
+FRPCDTTtFptVTnQnrGbwbS
+LsdmnDMTLbzsbNtqcb
+lJjCnHSvQRRwQQjRRHQbgWbqctNJPbcWrcPPgc
+RhGSQGwBvvGShnGlHClwjmfpmfdmVmfFDBLDDZpmMf
+ppDnPmwvNDjTjjcssT
+qqfRHzdCPHWfhHHtTjjbbLLGZr
+MhzqWdJCzqJWSJnpnpvvPSPP
+NGWdQgDDHGJgQLznzzsJFFzvzB
+twRCpZVjVWqVSqVwwjtZfrrfntfvznBssBncfLrc
+jRRwCqwCZhlhZRpSZpjSqWwqmDMQdMmHPQQMHGdlHdTldNGd
--- a/day_03/sample.txt
+++ b/day_03/sample.txt
@ -0,0 +1,6 @@
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw
--- a/day_03/solution.test.ts
+++ b/day_03/solution.test.ts
@ -0,0 +1,27 @@
+import { readlines } from "../_utils";
+
+const solution = require("./solution");
+
+describe("day 3: rucksack reorganization, pt 1", () => {
+  test("sample input", async () => {
+    const sample = await readlines("./day_03/sample.txt");
+    expect(solution.part1_solver(sample)).toBe(157);
+  });
+
+  test("submission input", async () => {
+    const input = await readlines("./day_03/input.txt");
+    expect(solution.part1_solver(input)).toBe(8109);
+  });
+});
+
+describe("day 3: rucksack reorganization, pt 2", () => {
+  test("sample input", async () => {
+    const sample = await readlines("./day_03/sample.txt");
+    expect(solution.part2_solver(sample)).toBe(70);
+  });
+
+  test("submission input", async () => {
+    const input = await readlines("./day_03/input.txt");
+    expect(solution.part2_solver(input)).toBe(2738);
+  });
+});
--- a/day_03/solution.ts
+++ b/day_03/solution.ts
@ -0,0 +1,138 @@
+/*
+--- Day 3: Rucksack Reorganization ---
+
+One Elf has the important job of loading all of the rucksacks with supplies for the jungle journey. Unfortunately, that Elf didn't quite follow the packing instructions, and so a few items now need to be rearranged.
+
+Each rucksack has two large compartments. All items of a given type are meant to go into exactly one of the two compartments. The Elf that did the packing failed to follow this rule for exactly one item type per rucksack.
+
+The Elves have made a list of all of the items currently in each rucksack (your puzzle input), but they need your help finding the errors. Every item type is identified by a single lowercase or uppercase letter (that is, a and A refer to different types of items).
+
+The list of items for each rucksack is given as characters all on a single line. A given rucksack always has the same number of items in each of its two compartments, so the first half of the characters represent items in the first compartment, while the second half of the characters represent items in the second compartment.
+
+For example, suppose you have the following list of contents from six rucksacks:
+
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw
+
+    The first rucksack contains the items vJrwpWtwJgWrhcsFMMfFFhFp, which means its first compartment contains the items vJrwpWtwJgWr, while the second compartment contains the items hcsFMMfFFhFp. The only item type that appears in both compartments is lowercase p.
+    The second rucksack's compartments contain jqHRNqRjqzjGDLGL and rsFMfFZSrLrFZsSL. The only item type that appears in both compartments is uppercase L.
+    The third rucksack's compartments contain PmmdzqPrV and vPwwTWBwg; the only common item type is uppercase P.
+    The fourth rucksack's compartments only share item type v.
+    The fifth rucksack's compartments only share item type t.
+    The sixth rucksack's compartments only share item type s.
+
+To help prioritize item rearrangement, every item type can be converted to a priority:
+
+    Lowercase item types a through z have priorities 1 through 26.
+    Uppercase item types A through Z have priorities 27 through 52.
+
+In the above example, the priority of the item type that appears in both compartments of each rucksack is 16 (p), 38 (L), 42 (P), 22 (v), 20 (t), and 19 (s); the sum of these is 157.
+
+Find the item type that appears in both compartments of each rucksack. What is the sum of the priorities of those item types?
+*/
+
+import { emptyLines, group, sum } from "../_utils";
+
+/**
+ *
+ * amongst an arbitrary sequence of words, find the character(s) that
+ * are common to all of them, if any
+ *
+ * @param w
+ * @returns
+ */
+const findCommonAll = (...w: string[]): string => {
+  if (w.length < 2) {
+    return "";
+  } else if (w.length === 2) {
+    let m1: Record<string, number> = {};
+    w[0].split("").forEach((char) => {
+      m1[char] = 1;
+    });
+
+    let common = new Set<string>();
+    w[1].split("").forEach((char) => {
+      if (m1[char]) {
+        common.add(char);
+      }
+    });
+
+    return [...common.keys()].join();
+  } else {
+    return findCommonAll(findCommonAll(w[0], w[1]), ...w.slice(2));
+  }
+};
+
+const calculatePriority = (char: string): number => {
+  const code = char.charCodeAt(0);
+  if (code >= "A".charCodeAt(0) && code <= "Z".charCodeAt(0)) {
+    return code - 38;
+  }
+  if (code >= "a".charCodeAt(0) && code <= "z".charCodeAt(0)) {
+    return code - 96;
+  }
+
+  throw new Error(`char ${char} is outside acceptable range`);
+};
+
+const getCompartments = (line: string): string[] =>
+  group(line.split(""), (_, __, index) => index === line.length / 2).map(
+    (compartment) => compartment.join("")
+  );
+
+const toDuplicateItemPriority = (line: string) => {
+  const [compartment1, compartment2] = getCompartments(line);
+  const commonItem = findCommonAll(compartment1, compartment2);
+  return calculatePriority(commonItem);
+};
+
+export function part1_solver(lines: string[]): number {
+  return lines.filter(emptyLines).map(toDuplicateItemPriority).reduce(sum, 0);
+}
+
+/*
+--- Part Two ---
+
+As you finish identifying the misplaced items, the Elves come to you with another issue.
+
+For safety, the Elves are divided into groups of three. Every Elf carries a badge that identifies their group. For efficiency, within each group of three Elves, the badge is the only item type carried by all three Elves. That is, if a group's badge is item type B, then all three Elves will have item type B somewhere in their rucksack, and at most two of the Elves will be carrying any other item type.
+
+The problem is that someone forgot to put this year's updated authenticity sticker on the badges. All of the badges need to be pulled out of the rucksacks so the new authenticity stickers can be attached.
+
+Additionally, nobody wrote down which item type corresponds to each group's badges. The only way to tell which item type is the right one is by finding the one item type that is common between all three Elves in each group.
+
+Every set of three lines in your list corresponds to a single group, but each group can have a different badge item type. So, in the above example, the first group's rucksacks are the first three lines:
+
+vJrwpWtwJgWrhcsFMMfFFhFp
+jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL
+PmmdzqPrVvPwwTWBwg
+
+And the second group's rucksacks are the next three lines:
+
+wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn
+ttgJtRGJQctTZtZT
+CrZsJsPPZsGzwwsLwLmpwMDw
+
+In the first group, the only item type that appears in all three rucksacks is lowercase r; this must be their badges. In the second group, their badge item type must be Z.
+
+Priorities for these items must still be found to organize the sticker attachment efforts: here, they are 18 (r) for the first group and 52 (Z) for the second group. The sum of these is 70.
+
+Find the item type that corresponds to the badges of each three-Elf group. What is the sum of the priorities of those item types?
+*/
+
+const groupElvesIntoThrees = (lines: string[]): string[][] =>
+  group(
+    lines.filter(emptyLines),
+    (_, __, index) => index > 0 && index % 3 === 0
+  );
+
+const toCommonBadgePriority = (elfGroup: string[]) =>
+  calculatePriority(findCommonAll(...elfGroup));
+
+export function part2_solver(lines: string[]): number {
+  return groupElvesIntoThrees(lines).map(toCommonBadgePriority).reduce(sum, 0);
+}
--- a/get_input.sh
+++ b/get_input.sh
@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+day=$1
+dir=$(printf "day_%02d" "$day")
+
+mkdir -p "$dir"
+
+curl -H "Cookie: $(cat ./session.cookie)" https://adventofcode.com/2022/day/"$day"/input -o "$dir"/input.txt
--- a/jest.config.ts
+++ b/jest.config.ts
@ -0,0 +1,9 @@
+import type { Config } from "@jest/types";
+// Sync object
+const config: Config.InitialOptions = {
+  verbose: true,
+  transform: {
+    "^.+\\.tsx?$": "ts-jest",
+  },
+};
+export default config;
--- a/node_modules/.bin/acorn
+++ b/node_modules/.bin/acorn
@ -0,0 +1 @@
+../acorn/bin/acorn
--- a/node_modules/.bin/browserslist
+++ b/node_modules/.bin/browserslist
@ -0,0 +1 @@
+../browserslist/cli.js
--- a/node_modules/.bin/browserslist-lint
+++ b/node_modules/.bin/browserslist-lint
@ -0,0 +1 @@
+../update-browserslist-db/cli.js
--- a/node_modules/.bin/esparse
+++ b/node_modules/.bin/esparse
@ -0,0 +1 @@
+../esprima/bin/esparse.js
--- a/node_modules/.bin/esvalidate
+++ b/node_modules/.bin/esvalidate
@ -0,0 +1 @@
+../esprima/bin/esvalidate.js
--- a/node_modules/.bin/import-local-fixture
+++ b/node_modules/.bin/import-local-fixture
@ -0,0 +1 @@
+../import-local/fixtures/cli.js
--- a/node_modules/.bin/jest
+++ b/node_modules/.bin/jest
@ -0,0 +1 @@
+../jest/bin/jest.js
--- a/node_modules/.bin/js-yaml
+++ b/node_modules/.bin/js-yaml
@ -0,0 +1 @@
+../js-yaml/bin/js-yaml.js
--- a/node_modules/.bin/jsesc
+++ b/node_modules/.bin/jsesc
@ -0,0 +1 @@
+../jsesc/bin/jsesc
--- a/node_modules/.bin/json5
+++ b/node_modules/.bin/json5
@ -0,0 +1 @@
+../json5/lib/cli.js
--- a/node_modules/.bin/node-which
+++ b/node_modules/.bin/node-which
@ -0,0 +1 @@
+../which/bin/node-which
--- a/node_modules/.bin/parser
+++ b/node_modules/.bin/parser
@ -0,0 +1 @@
+../@babel/parser/bin/babel-parser.js
--- a/node_modules/.bin/resolve
+++ b/node_modules/.bin/resolve
@ -0,0 +1 @@
+../resolve/bin/resolve
--- a/node_modules/.bin/semver
+++ b/node_modules/.bin/semver
@ -0,0 +1 @@
+../semver/bin/semver.js
--- a/node_modules/.bin/ts-jest
+++ b/node_modules/.bin/ts-jest
@ -0,0 +1 @@
+../ts-jest/cli.js
--- a/node_modules/.bin/ts-node
+++ b/node_modules/.bin/ts-node
@ -0,0 +1 @@
+../ts-node/dist/bin.js
--- a/node_modules/.bin/ts-node-cwd
+++ b/node_modules/.bin/ts-node-cwd
@ -0,0 +1 @@
+../ts-node/dist/bin-cwd.js
--- a/node_modules/.bin/ts-node-esm
+++ b/node_modules/.bin/ts-node-esm
@ -0,0 +1 @@
+../ts-node/dist/bin-esm.js
--- a/node_modules/.bin/ts-node-script
+++ b/node_modules/.bin/ts-node-script
@ -0,0 +1 @@
+../ts-node/dist/bin-script.js
--- a/node_modules/.bin/ts-node-transpile-only
+++ b/node_modules/.bin/ts-node-transpile-only
@ -0,0 +1 @@
+../ts-node/dist/bin-transpile.js
--- a/node_modules/.bin/ts-script
+++ b/node_modules/.bin/ts-script
@ -0,0 +1 @@
+../ts-node/dist/bin-script-deprecated.js
--- a/node_modules/.bin/tsc
+++ b/node_modules/.bin/tsc
@ -0,0 +1 @@
+../typescript/bin/tsc
--- a/node_modules/.bin/tsserver
+++ b/node_modules/.bin/tsserver
@ -0,0 +1 @@
+../typescript/bin/tsserver
--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
--- a/node_modules/@ampproject/remapping/LICENSE
+++ b/node_modules/@ampproject/remapping/LICENSE
@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2019 Google LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/node_modules/@ampproject/remapping/README.md
+++ b/node_modules/@ampproject/remapping/README.md
@ -0,0 +1,218 @@
+# @ampproject/remapping
+
+> Remap sequential sourcemaps through transformations to point at the original source code
+
+Remapping allows you to take the sourcemaps generated through transforming your code and "remap"
+them to the original source locations. Think "my minified code, transformed with babel and bundled
+with webpack", all pointing to the correct location in your original source code.
+
+With remapping, none of your source code transformations need to be aware of the input's sourcemap,
+they only need to generate an output sourcemap. This greatly simplifies building custom
+transformations (think a find-and-replace).
+
+## Installation
+
+```sh
+npm install @ampproject/remapping
+```
+
+## Usage
+
+```typescript
+function remapping(
+  map: SourceMap | SourceMap[],
+  loader: (file: string, ctx: LoaderContext) => (SourceMap | null | undefined),
+  options?: { excludeContent: boolean, decodedMappings: boolean }
+): SourceMap;
+
+// LoaderContext gives the loader the importing sourcemap, tree depth, the ability to override the
+// "source" location (where child sources are resolved relative to, or the location of original
+// source), and the ability to override the "content" of an original source for inclusion in the
+// output sourcemap.
+type LoaderContext = {
+ readonly importer: string;
+ readonly depth: number;
+ source: string;
+ content: string | null | undefined;
+}
+```
+
+`remapping` takes the final output sourcemap, and a `loader` function. For every source file pointer
+in the sourcemap, the `loader` will be called with the resolved path. If the path itself represents
+a transformed file (it has a sourcmap associated with it), then the `loader` should return that
+sourcemap. If not, the path will be treated as an original, untransformed source code.
+
+```js
+// Babel transformed "helloworld.js" into "transformed.js"
+const transformedMap = JSON.stringify({
+  file: 'transformed.js',
+  // 1st column of 2nd line of output file translates into the 1st source
+  // file, line 3, column 2
+  mappings: ';CAEE',
+  sources: ['helloworld.js'],
+  version: 3,
+});
+
+// Uglify minified "transformed.js" into "transformed.min.js"
+const minifiedTransformedMap = JSON.stringify({
+  file: 'transformed.min.js',
+  // 0th column of 1st line of output file translates into the 1st source
+  // file, line 2, column 1.
+  mappings: 'AACC',
+  names: [],
+  sources: ['transformed.js'],
+  version: 3,
+});
+
+const remapped = remapping(
+  minifiedTransformedMap,
+  (file, ctx) => {
+
+    // The "transformed.js" file is an transformed file.
+    if (file === 'transformed.js') {
+      // The root importer is empty.
+      console.assert(ctx.importer === '');
+      // The depth in the sourcemap tree we're currently loading.
+      // The root `minifiedTransformedMap` is depth 0, and its source children are depth 1, etc.
+      console.assert(ctx.depth === 1);
+
+      return transformedMap;
+    }
+
+    // Loader will be called to load transformedMap's source file pointers as well.
+    console.assert(file === 'helloworld.js');
+    // `transformed.js`'s sourcemap points into `helloworld.js`.
+    console.assert(ctx.importer === 'transformed.js');
+    // This is a source child of `transformed`, which is a source child of `minifiedTransformedMap`.
+    console.assert(ctx.depth === 2);
+    return null;
+  }
+);
+
+console.log(remapped);
+// {
+//   file: 'transpiled.min.js',
+//   mappings: 'AAEE',
+//   sources: ['helloworld.js'],
+//   version: 3,
+// };
+```
+
+In this example, `loader` will be called twice:
+
+1. `"transformed.js"`, the first source file pointer in the `minifiedTransformedMap`. We return the
+   associated sourcemap for it (its a transformed file, after all) so that sourcemap locations can
+   be traced through it into the source files it represents.
+2. `"helloworld.js"`, our original, unmodified source code. This file does not have a sourcemap, so
+   we return `null`.
+
+The `remapped` sourcemap now points from `transformed.min.js` into locations in `helloworld.js`. If
+you were to read the `mappings`, it says "0th column of the first line output line points to the 1st
+column of the 2nd line of the file `helloworld.js`".
+
+### Multiple transformations of a file
+
+As a convenience, if you have multiple single-source transformations of a file, you may pass an
+array of sourcemap files in the order of most-recent transformation sourcemap first. Note that this
+changes the `importer` and `depth` of each call to our loader. So our above example could have been
+written as:
+
+```js
+const remapped = remapping(
+  [minifiedTransformedMap, transformedMap],
+  () => null
+);
+
+console.log(remapped);
+// {
+//   file: 'transpiled.min.js',
+//   mappings: 'AAEE',
+//   sources: ['helloworld.js'],
+//   version: 3,
+// };
+```
+
+### Advanced control of the loading graph
+
+#### `source`
+
+The `source` property can overridden to any value to change the location of the current load. Eg,
+for an original source file, it allows us to change the location to the original source regardless
+of what the sourcemap source entry says. And for transformed files, it allows us to change the
+relative resolving location for child sources of the loaded sourcemap.
+
+```js
+const remapped = remapping(
+  minifiedTransformedMap,
+  (file, ctx) => {
+
+    if (file === 'transformed.js') {
+      // We pretend the transformed.js file actually exists in the 'src/' directory. When the nested
+      // source files are loaded, they will now be relative to `src/`.
+      ctx.source = 'src/transformed.js';
+      return transformedMap;
+    }
+
+    console.assert(file === 'src/helloworld.js');
+    // We could futher change the source of this original file, eg, to be inside a nested directory
+    // itself. This will be reflected in the remapped sourcemap.
+    ctx.source = 'src/nested/transformed.js';
+    return null;
+  }
+);
+
+console.log(remapped);
+// {
+//   …,
+//   sources: ['src/nested/helloworld.js'],
+// };
+```
+
+
+#### `content`
+
+The `content` property can be overridden when we encounter an original source file. Eg, this allows
+you to manually provide the source content of the original file regardless of whether the
+`sourcesContent` field is present in the parent sourcemap. It can also be set to `null` to remove
+the source content.
+
+```js
+const remapped = remapping(
+  minifiedTransformedMap,
+  (file, ctx) => {
+
+    if (file === 'transformed.js') {
+      // transformedMap does not include a `sourcesContent` field, so usually the remapped sourcemap
+      // would not include any `sourcesContent` values.
+      return transformedMap;
+    }
+
+    console.assert(file === 'helloworld.js');
+    // We can read the file to provide the source content.
+    ctx.content = fs.readFileSync(file, 'utf8');
+    return null;
+  }
+);
+
+console.log(remapped);
+// {
+//   …,
+//   sourcesContent: [
+//     'console.log("Hello world!")',
+//   ],
+// };
+```
+
+### Options
+
+#### excludeContent
+
+By default, `excludeContent` is `false`. Passing `{ excludeContent: true }` will exclude the
+`sourcesContent` field from the returned sourcemap. This is mainly useful when you want to reduce
+the size out the sourcemap.
+
+#### decodedMappings
+
+By default, `decodedMappings` is `false`. Passing `{ decodedMappings: true }` will leave the
+`mappings` field in a [decoded state](https://github.com/rich-harris/sourcemap-codec) instead of
+encoding into a VLQ string.
--- a/node_modules/@ampproject/remapping/package.json
+++ b/node_modules/@ampproject/remapping/package.json
@ -0,0 +1,63 @@
+{
+  "name": "@ampproject/remapping",
+  "version": "2.2.0",
+  "description": "Remap sequential sourcemaps through transformations to point at the original source code",
+  "keywords": [
+    "source",
+    "map",
+    "remap"
+  ],
+  "main": "dist/remapping.umd.js",
+  "module": "dist/remapping.mjs",
+  "typings": "dist/types/remapping.d.ts",
+  "files": [
+    "dist"
+  ],
+  "author": "Justin Ridgewell <jridgewell@google.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ampproject/remapping.git"
+  },
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "scripts": {
+    "build": "run-s -n build:*",
+    "build:rollup": "rollup -c rollup.config.js",
+    "build:ts": "tsc --project tsconfig.build.json",
+    "lint": "run-s -n lint:*",
+    "lint:prettier": "npm run test:lint:prettier -- --write",
+    "lint:ts": "npm run test:lint:ts -- --fix",
+    "prebuild": "rm -rf dist",
+    "prepublishOnly": "npm run preversion",
+    "preversion": "run-s test build",
+    "test": "run-s -n test:lint test:only",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand",
+    "test:lint": "run-s -n test:lint:*",
+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
+    "test:only": "jest --coverage",
+    "test:watch": "jest --coverage --watch"
+  },
+  "devDependencies": {
+    "@rollup/plugin-typescript": "8.3.2",
+    "@types/jest": "27.4.1",
+    "@typescript-eslint/eslint-plugin": "5.20.0",
+    "@typescript-eslint/parser": "5.20.0",
+    "eslint": "8.14.0",
+    "eslint-config-prettier": "8.5.0",
+    "jest": "27.5.1",
+    "jest-config": "27.5.1",
+    "npm-run-all": "4.1.5",
+    "prettier": "2.6.2",
+    "rollup": "2.70.2",
+    "ts-jest": "27.1.4",
+    "tslib": "2.4.0",
+    "typescript": "4.6.3"
+  },
+  "dependencies": {
+    "@jridgewell/gen-mapping": "^0.1.0",
+    "@jridgewell/trace-mapping": "^0.3.9"
+  }
+}
--- a/node_modules/@babel/code-frame/LICENSE
+++ b/node_modules/@babel/code-frame/LICENSE
@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/@babel/code-frame/README.md
+++ b/node_modules/@babel/code-frame/README.md
@ -0,0 +1,19 @@
+# @babel/code-frame
+
+> Generate errors that contain a code frame that point to source locations.
+
+See our website [@babel/code-frame](https://babeljs.io/docs/en/babel-code-frame) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/code-frame
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/code-frame --dev
+```
--- a/node_modules/@babel/code-frame/lib/index.js
+++ b/node_modules/@babel/code-frame/lib/index.js
@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = _default;
+
+var _highlight = require("@babel/highlight");
+
+let deprecationWarningShown = false;
+
+function getDefs(chalk) {
+  return {
+    gutter: chalk.grey,
+    marker: chalk.red.bold,
+    message: chalk.red.bold
+  };
+}
+
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+
+function getMarkerLines(loc, source, opts) {
+  const startLoc = Object.assign({
+    column: 0,
+    line: -1
+  }, loc.start);
+  const endLoc = Object.assign({}, startLoc, loc.end);
+  const {
+    linesAbove = 2,
+    linesBelow = 3
+  } = opts || {};
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+
+  if (startLine === -1) {
+    start = 0;
+  }
+
+  if (endLine === -1) {
+    end = source.length;
+  }
+
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+
+  return {
+    start,
+    end,
+    markerLines
+  };
+}
+
+function codeFrameColumns(rawLines, loc, opts = {}) {
+  const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+  const chalk = (0, _highlight.getChalk)(opts);
+  const defs = getDefs(chalk);
+
+  const maybeHighlight = (chalkFn, string) => {
+    return highlighted ? chalkFn(string) : string;
+  };
+
+  const lines = rawLines.split(NEWLINE);
+  const {
+    start,
+    end,
+    markerLines
+  } = getMarkerLines(loc, lines, opts);
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end).length;
+  const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+  let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} |`;
+    const hasMarker = markerLines[number];
+    const lastMarkerLine = !markerLines[number + 1];
+
+    if (hasMarker) {
+      let markerLine = "";
+
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
+
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + maybeHighlight(defs.message, opts.message);
+        }
+      }
+
+      return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    } else {
+      return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+    }
+  }).join("\n");
+
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+  }
+
+  if (highlighted) {
+    return chalk.reset(frame);
+  } else {
+    return frame;
+  }
+}
+
+function _default(rawLines, lineNumber, colNumber, opts = {}) {
+  if (!deprecationWarningShown) {
+    deprecationWarningShown = true;
+    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+
+    if (process.emitWarning) {
+      process.emitWarning(message, "DeprecationWarning");
+    } else {
+      const deprecationError = new Error(message);
+      deprecationError.name = "DeprecationWarning";
+      console.warn(new Error(message));
+    }
+  }
+
+  colNumber = Math.max(colNumber, 0);
+  const location = {
+    start: {
+      column: colNumber,
+      line: lineNumber
+    }
+  };
+  return codeFrameColumns(rawLines, location, opts);
+}
--- a/node_modules/@babel/code-frame/package.json
+++ b/node_modules/@babel/code-frame/package.json
@ -0,0 +1,30 @@
+{
+  "name": "@babel/code-frame",
+  "version": "7.18.6",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-code-frame",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-code-frame"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/highlight": "^7.18.6"
+  },
+  "devDependencies": {
+    "@types/chalk": "^2.0.0",
+    "chalk": "^2.0.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}
--- a/node_modules/@babel/compat-data/LICENSE
+++ b/node_modules/@babel/compat-data/LICENSE
@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/@babel/compat-data/README.md
+++ b/node_modules/@babel/compat-data/README.md
@ -0,0 +1,19 @@
+# @babel/compat-data
+
+> 
+
+See our website [@babel/compat-data](https://babeljs.io/docs/en/babel-compat-data) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/compat-data
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/compat-data
+```
--- a/node_modules/@babel/compat-data/corejs2-built-ins.js
+++ b/node_modules/@babel/compat-data/corejs2-built-ins.js
@ -0,0 +1 @@
+module.exports = require("./data/corejs2-built-ins.json");
--- a/node_modules/@babel/compat-data/corejs3-shipped-proposals.js
+++ b/node_modules/@babel/compat-data/corejs3-shipped-proposals.js
@ -0,0 +1 @@
+module.exports = require("./data/corejs3-shipped-proposals.json");
--- a/node_modules/@babel/compat-data/data/corejs2-built-ins.json
+++ b/node_modules/@babel/compat-data/data/corejs2-built-ins.json
--- a/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json
+++ b/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json
@ -0,0 +1,5 @@
+[
+  "esnext.global-this",
+  "esnext.promise.all-settled",
+  "esnext.string.match-all"
+]
--- a/node_modules/@babel/compat-data/data/native-modules.json
+++ b/node_modules/@babel/compat-data/data/native-modules.json
@ -0,0 +1,18 @@
+{
+  "es6.module": {
+    "chrome": "61",
+    "and_chr": "61",
+    "edge": "16",
+    "firefox": "60",
+    "and_ff": "60",
+    "node": "13.2.0",
+    "opera": "48",
+    "op_mob": "48",
+    "safari": "10.1",
+    "ios": "10.3",
+    "samsung": "8.2",
+    "android": "61",
+    "electron": "2.0",
+    "ios_saf": "10.3"
+  }
+}
--- a/node_modules/@babel/compat-data/data/overlapping-plugins.json
+++ b/node_modules/@babel/compat-data/data/overlapping-plugins.json
@ -0,0 +1,25 @@
+{
+  "transform-async-to-generator": [
+    "bugfix/transform-async-arrows-in-class"
+  ],
+  "transform-parameters": [
+    "bugfix/transform-edge-default-parameters",
+    "bugfix/transform-safari-id-destructuring-collision-in-function-expression"
+  ],
+  "transform-function-name": [
+    "bugfix/transform-edge-function-name"
+  ],
+  "transform-block-scoping": [
+    "bugfix/transform-safari-block-shadowing",
+    "bugfix/transform-safari-for-shadowing"
+  ],
+  "transform-template-literals": [
+    "bugfix/transform-tagged-template-caching"
+  ],
+  "transform-optional-chaining": [
+    "bugfix/transform-v8-spread-parameters-in-optional-chaining"
+  ],
+  "proposal-optional-chaining": [
+    "bugfix/transform-v8-spread-parameters-in-optional-chaining"
+  ]
+}
--- a/node_modules/@babel/compat-data/data/plugin-bugfixes.json
+++ b/node_modules/@babel/compat-data/data/plugin-bugfixes.json
@ -0,0 +1,184 @@
+{
+  "bugfix/transform-async-arrows-in-class": {
+    "chrome": "55",
+    "opera": "42",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "11",
+    "node": "7.6",
+    "deno": "1",
+    "ios": "11",
+    "samsung": "6",
+    "electron": "1.6"
+  },
+  "bugfix/transform-edge-default-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "18",
+    "firefox": "52",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "bugfix/transform-edge-function-name": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "79",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "1.2"
+  },
+  "bugfix/transform-safari-block-shadowing": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "44",
+    "safari": "11",
+    "node": "6",
+    "deno": "1",
+    "ie": "11",
+    "ios": "11",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "bugfix/transform-safari-for-shadowing": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "11",
+    "node": "6",
+    "deno": "1",
+    "ie": "11",
+    "ios": "11",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "electron": "0.37"
+  },
+  "bugfix/transform-safari-id-destructuring-collision-in-function-expression": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "14",
+    "firefox": "2",
+    "node": "6",
+    "deno": "1",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "bugfix/transform-tagged-template-caching": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "13",
+    "node": "4",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "3.4",
+    "rhino": "1.7.14",
+    "electron": "0.21"
+  },
+  "bugfix/transform-v8-spread-parameters-in-optional-chaining": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "13.4",
+    "samsung": "16",
+    "electron": "13.0"
+  },
+  "transform-optional-chaining": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "electron": "8.0"
+  },
+  "proposal-optional-chaining": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "electron": "8.0"
+  },
+  "transform-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "transform-async-to-generator": {
+    "chrome": "55",
+    "opera": "42",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "10.1",
+    "node": "7.6",
+    "deno": "1",
+    "ios": "10.3",
+    "samsung": "6",
+    "electron": "1.6"
+  },
+  "transform-template-literals": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "13",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "electron": "0.21"
+  },
+  "transform-function-name": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "14",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "1.2"
+  },
+  "transform-block-scoping": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "14",
+    "firefox": "51",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.37"
+  }
+}
--- a/node_modules/@babel/compat-data/data/plugins.json
+++ b/node_modules/@babel/compat-data/data/plugins.json
@ -0,0 +1,691 @@
+{
+  "transform-class-static-block": {
+    "chrome": "94",
+    "opera": "80",
+    "edge": "94",
+    "firefox": "93",
+    "node": "16.11",
+    "deno": "1.14",
+    "samsung": "17",
+    "electron": "15.0"
+  },
+  "proposal-class-static-block": {
+    "chrome": "94",
+    "opera": "80",
+    "edge": "94",
+    "firefox": "93",
+    "node": "16.11",
+    "deno": "1.14",
+    "samsung": "17",
+    "electron": "15.0"
+  },
+  "transform-private-property-in-object": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "90",
+    "safari": "15",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "15",
+    "samsung": "16",
+    "electron": "13.0"
+  },
+  "proposal-private-property-in-object": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "90",
+    "safari": "15",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "15",
+    "samsung": "16",
+    "electron": "13.0"
+  },
+  "transform-class-properties": {
+    "chrome": "74",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "90",
+    "safari": "14.1",
+    "node": "12",
+    "deno": "1",
+    "ios": "15",
+    "samsung": "11",
+    "electron": "6.0"
+  },
+  "proposal-class-properties": {
+    "chrome": "74",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "90",
+    "safari": "14.1",
+    "node": "12",
+    "deno": "1",
+    "ios": "15",
+    "samsung": "11",
+    "electron": "6.0"
+  },
+  "transform-private-methods": {
+    "chrome": "84",
+    "opera": "70",
+    "edge": "84",
+    "firefox": "90",
+    "safari": "15",
+    "node": "14.6",
+    "deno": "1",
+    "ios": "15",
+    "samsung": "14",
+    "electron": "10.0"
+  },
+  "proposal-private-methods": {
+    "chrome": "84",
+    "opera": "70",
+    "edge": "84",
+    "firefox": "90",
+    "safari": "15",
+    "node": "14.6",
+    "deno": "1",
+    "ios": "15",
+    "samsung": "14",
+    "electron": "10.0"
+  },
+  "transform-numeric-separator": {
+    "chrome": "75",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "70",
+    "safari": "13",
+    "node": "12.5",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "11",
+    "rhino": "1.7.14",
+    "electron": "6.0"
+  },
+  "proposal-numeric-separator": {
+    "chrome": "75",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "70",
+    "safari": "13",
+    "node": "12.5",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "11",
+    "rhino": "1.7.14",
+    "electron": "6.0"
+  },
+  "transform-logical-assignment-operators": {
+    "chrome": "85",
+    "opera": "71",
+    "edge": "85",
+    "firefox": "79",
+    "safari": "14",
+    "node": "15",
+    "deno": "1.2",
+    "ios": "14",
+    "samsung": "14",
+    "electron": "10.0"
+  },
+  "proposal-logical-assignment-operators": {
+    "chrome": "85",
+    "opera": "71",
+    "edge": "85",
+    "firefox": "79",
+    "safari": "14",
+    "node": "15",
+    "deno": "1.2",
+    "ios": "14",
+    "samsung": "14",
+    "electron": "10.0"
+  },
+  "transform-nullish-coalescing-operator": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "72",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "electron": "8.0"
+  },
+  "proposal-nullish-coalescing-operator": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "72",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "electron": "8.0"
+  },
+  "transform-optional-chaining": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "13.4",
+    "samsung": "16",
+    "electron": "13.0"
+  },
+  "proposal-optional-chaining": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "13.4",
+    "samsung": "16",
+    "electron": "13.0"
+  },
+  "transform-json-strings": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "62",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "9",
+    "rhino": "1.7.14",
+    "electron": "3.0"
+  },
+  "proposal-json-strings": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "62",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "9",
+    "rhino": "1.7.14",
+    "electron": "3.0"
+  },
+  "transform-optional-catch-binding": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "58",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "electron": "3.0"
+  },
+  "proposal-optional-catch-binding": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "58",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "electron": "3.0"
+  },
+  "transform-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "18",
+    "firefox": "53",
+    "node": "6",
+    "deno": "1",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "transform-async-generator-functions": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "79",
+    "firefox": "57",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "8",
+    "electron": "3.0"
+  },
+  "proposal-async-generator-functions": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "79",
+    "firefox": "57",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "8",
+    "electron": "3.0"
+  },
+  "transform-object-rest-spread": {
+    "chrome": "60",
+    "opera": "47",
+    "edge": "79",
+    "firefox": "55",
+    "safari": "11.1",
+    "node": "8.3",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "electron": "2.0"
+  },
+  "proposal-object-rest-spread": {
+    "chrome": "60",
+    "opera": "47",
+    "edge": "79",
+    "firefox": "55",
+    "safari": "11.1",
+    "node": "8.3",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "electron": "2.0"
+  },
+  "transform-dotall-regex": {
+    "chrome": "62",
+    "opera": "49",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "8.10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "electron": "3.0"
+  },
+  "transform-unicode-property-regex": {
+    "chrome": "64",
+    "opera": "51",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "electron": "3.0"
+  },
+  "proposal-unicode-property-regex": {
+    "chrome": "64",
+    "opera": "51",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "electron": "3.0"
+  },
+  "transform-named-capturing-groups-regex": {
+    "chrome": "64",
+    "opera": "51",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "electron": "3.0"
+  },
+  "transform-async-to-generator": {
+    "chrome": "55",
+    "opera": "42",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "11",
+    "node": "7.6",
+    "deno": "1",
+    "ios": "11",
+    "samsung": "6",
+    "electron": "1.6"
+  },
+  "transform-exponentiation-operator": {
+    "chrome": "52",
+    "opera": "39",
+    "edge": "14",
+    "firefox": "52",
+    "safari": "10.1",
+    "node": "7",
+    "deno": "1",
+    "ios": "10.3",
+    "samsung": "6",
+    "rhino": "1.7.14",
+    "electron": "1.3"
+  },
+  "transform-template-literals": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "13",
+    "firefox": "34",
+    "safari": "13",
+    "node": "4",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "3.4",
+    "electron": "0.21"
+  },
+  "transform-literals": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "53",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "electron": "0.30"
+  },
+  "transform-function-name": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "79",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "1.2"
+  },
+  "transform-arrow-functions": {
+    "chrome": "47",
+    "opera": "34",
+    "edge": "13",
+    "firefox": "43",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "electron": "0.36"
+  },
+  "transform-block-scoped-functions": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "46",
+    "safari": "10",
+    "node": "4",
+    "deno": "1",
+    "ie": "11",
+    "ios": "10",
+    "samsung": "3.4",
+    "electron": "0.21"
+  },
+  "transform-classes": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.36"
+  },
+  "transform-object-super": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.36"
+  },
+  "transform-shorthand-properties": {
+    "chrome": "43",
+    "opera": "30",
+    "edge": "12",
+    "firefox": "33",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.14",
+    "electron": "0.27"
+  },
+  "transform-duplicate-keys": {
+    "chrome": "42",
+    "opera": "29",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "electron": "0.25"
+  },
+  "transform-computed-properties": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "7.1",
+    "node": "4",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "4",
+    "electron": "0.30"
+  },
+  "transform-for-of": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "1.2"
+  },
+  "transform-sticky-regex": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "13",
+    "firefox": "3",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "transform-unicode-escapes": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "53",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "electron": "0.30"
+  },
+  "transform-unicode-regex": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "13",
+    "firefox": "46",
+    "safari": "12",
+    "node": "6",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "5",
+    "electron": "1.1"
+  },
+  "transform-spread": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.36"
+  },
+  "transform-destructuring": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "1.2"
+  },
+  "transform-block-scoping": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "14",
+    "firefox": "51",
+    "safari": "11",
+    "node": "6",
+    "deno": "1",
+    "ios": "11",
+    "samsung": "5",
+    "electron": "0.37"
+  },
+  "transform-typeof-symbol": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "36",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "electron": "0.20"
+  },
+  "transform-new-target": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "14",
+    "firefox": "41",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "0.36"
+  },
+  "transform-regenerator": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "13",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "electron": "1.1"
+  },
+  "transform-member-expression-literals": {
+    "chrome": "7",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "5.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "electron": "0.20"
+  },
+  "transform-property-literals": {
+    "chrome": "7",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "5.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "electron": "0.20"
+  },
+  "transform-reserved-words": {
+    "chrome": "13",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.6",
+    "deno": "1",
+    "ie": "9",
+    "android": "4.4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "electron": "0.20"
+  },
+  "transform-export-namespace-from": {
+    "chrome": "72",
+    "and_chr": "72",
+    "edge": "79",
+    "firefox": "80",
+    "and_ff": "80",
+    "node": "13.2",
+    "opera": "60",
+    "op_mob": "51",
+    "samsung": "11.0",
+    "android": "72",
+    "electron": "5.0"
+  },
+  "proposal-export-namespace-from": {
+    "chrome": "72",
+    "and_chr": "72",
+    "edge": "79",
+    "firefox": "80",
+    "and_ff": "80",
+    "node": "13.2",
+    "opera": "60",
+    "op_mob": "51",
+    "samsung": "11.0",
+    "android": "72",
+    "electron": "5.0"
+  }
+}
--- a/node_modules/@babel/compat-data/native-modules.js
+++ b/node_modules/@babel/compat-data/native-modules.js
@ -0,0 +1 @@
+module.exports = require("./data/native-modules.json");
--- a/node_modules/@babel/compat-data/overlapping-plugins.js
+++ b/node_modules/@babel/compat-data/overlapping-plugins.js
@ -0,0 +1 @@
+module.exports = require("./data/overlapping-plugins.json");
--- a/node_modules/@babel/compat-data/package.json
+++ b/node_modules/@babel/compat-data/package.json
@ -0,0 +1,40 @@
+{
+  "name": "@babel/compat-data",
+  "version": "7.20.5",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "description": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-compat-data"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./plugins": "./plugins.js",
+    "./native-modules": "./native-modules.js",
+    "./corejs2-built-ins": "./corejs2-built-ins.js",
+    "./corejs3-shipped-proposals": "./corejs3-shipped-proposals.js",
+    "./overlapping-plugins": "./overlapping-plugins.js",
+    "./plugin-bugfixes": "./plugin-bugfixes.js"
+  },
+  "scripts": {
+    "build-data": "./scripts/download-compat-table.sh && node ./scripts/build-data.js && node ./scripts/build-modules-support.js && node ./scripts/build-bugfixes-targets.js"
+  },
+  "keywords": [
+    "babel",
+    "compat-table",
+    "compat-data"
+  ],
+  "devDependencies": {
+    "@mdn/browser-compat-data": "^4.0.10",
+    "core-js-compat": "^3.25.1",
+    "electron-to-chromium": "^1.4.248"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}
--- a/node_modules/@babel/compat-data/plugin-bugfixes.js
+++ b/node_modules/@babel/compat-data/plugin-bugfixes.js
@ -0,0 +1 @@
+module.exports = require("./data/plugin-bugfixes.json");
--- a/node_modules/@babel/compat-data/plugins.js
+++ b/node_modules/@babel/compat-data/plugins.js
@ -0,0 +1 @@
+module.exports = require("./data/plugins.json");
--- a/node_modules/@babel/core/LICENSE
+++ b/node_modules/@babel/core/LICENSE
@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/@babel/core/README.md
+++ b/node_modules/@babel/core/README.md
@ -0,0 +1,19 @@
+# @babel/core
+
+> Babel compiler core.
+
+See our website [@babel/core](https://babeljs.io/docs/en/babel-core) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20core%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/core
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/core --dev
+```
--- a/node_modules/@babel/core/cjs-proxy.cjs
+++ b/node_modules/@babel/core/cjs-proxy.cjs
@ -0,0 +1,29 @@
+"use strict";
+
+const babelP = import("./lib/index.js");
+
+const functionNames = [
+  "createConfigItem",
+  "loadPartialConfig",
+  "loadOptions",
+  "transform",
+  "transformFile",
+  "transformFromAst",
+  "parse",
+];
+
+for (const name of functionNames) {
+  exports[`${name}Sync`] = function () {
+    throw new Error(
+      `"${name}Sync" is not supported when loading @babel/core using require()`
+    );
+  };
+  exports[name] = function (...args) {
+    babelP.then(babel => {
+      babel[name](...args);
+    });
+  };
+  exports[`${name}Async`] = function (...args) {
+    return babelP.then(babel => babel[`${name}Async`](...args));
+  };
+}
--- a/node_modules/@babel/core/lib/config/cache-contexts.js
+++ b/node_modules/@babel/core/lib/config/cache-contexts.js
@ -0,0 +1,3 @@
+0 && 0;
+
+//# sourceMappingURL=cache-contexts.js.map
--- a/node_modules/@babel/core/lib/config/cache-contexts.js.map
+++ b/node_modules/@babel/core/lib/config/cache-contexts.js.map
@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/config/cache-contexts.ts"],"sourcesContent":["import type { Targets } from \"@babel/helper-compilation-targets\";\n\nimport type { ConfigContext } from \"./config-chain\";\nimport type { CallerMetadata } from \"./validation/options\";\n\nexport type { ConfigContext as FullConfig };\n\nexport type FullPreset = {\n  targets: Targets;\n} & ConfigContext;\nexport type FullPlugin = {\n  assumptions: { [name: string]: boolean };\n} & FullPreset;\n\n// Context not including filename since it is used in places that cannot\n// process 'ignore'/'only' and other filename-based logic.\nexport type SimpleConfig = {\n  envName: string;\n  caller: CallerMetadata | undefined;\n};\nexport type SimplePreset = {\n  targets: Targets;\n} & SimpleConfig;\nexport type SimplePlugin = {\n  assumptions: {\n    [name: string]: boolean;\n  };\n} & SimplePreset;\n"],"mappings":""}
--- a/node_modules/@babel/core/lib/config/caching.js
+++ b/node_modules/@babel/core/lib/config/caching.js
@ -0,0 +1,264 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSimpleType = assertSimpleType;
+exports.makeStrongCache = makeStrongCache;
+exports.makeStrongCacheSync = makeStrongCacheSync;
+exports.makeWeakCache = makeWeakCache;
+exports.makeWeakCacheSync = makeWeakCacheSync;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _async = require("../gensync-utils/async");
+var _util = require("./util");
+const synchronize = gen => {
+  return _gensync()(gen).sync;
+};
+
+function* genTrue() {
+  return true;
+}
+function makeWeakCache(handler) {
+  return makeCachedFunction(WeakMap, handler);
+}
+function makeWeakCacheSync(handler) {
+  return synchronize(makeWeakCache(handler));
+}
+function makeStrongCache(handler) {
+  return makeCachedFunction(Map, handler);
+}
+function makeStrongCacheSync(handler) {
+  return synchronize(makeStrongCache(handler));
+}
+
+function makeCachedFunction(CallCache, handler) {
+  const callCacheSync = new CallCache();
+  const callCacheAsync = new CallCache();
+  const futureCache = new CallCache();
+  return function* cachedFunction(arg, data) {
+    const asyncContext = yield* (0, _async.isAsync)();
+    const callCache = asyncContext ? callCacheAsync : callCacheSync;
+    const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);
+    if (cached.valid) return cached.value;
+    const cache = new CacheConfigurator(data);
+    const handlerResult = handler(arg, cache);
+    let finishLock;
+    let value;
+    if ((0, _util.isIterableIterator)(handlerResult)) {
+      value = yield* (0, _async.onFirstPause)(handlerResult, () => {
+        finishLock = setupAsyncLocks(cache, futureCache, arg);
+      });
+    } else {
+      value = handlerResult;
+    }
+    updateFunctionCache(callCache, cache, arg, value);
+    if (finishLock) {
+      futureCache.delete(arg);
+      finishLock.release(value);
+    }
+    return value;
+  };
+}
+function* getCachedValue(cache, arg, data) {
+  const cachedValue = cache.get(arg);
+  if (cachedValue) {
+    for (const {
+      value,
+      valid
+    } of cachedValue) {
+      if (yield* valid(data)) return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) {
+  const cached = yield* getCachedValue(callCache, arg, data);
+  if (cached.valid) {
+    return cached;
+  }
+  if (asyncContext) {
+    const cached = yield* getCachedValue(futureCache, arg, data);
+    if (cached.valid) {
+      const value = yield* (0, _async.waitFor)(cached.value.promise);
+      return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function setupAsyncLocks(config, futureCache, arg) {
+  const finishLock = new Lock();
+  updateFunctionCache(futureCache, config, arg, finishLock);
+  return finishLock;
+}
+function updateFunctionCache(cache, config, arg, value) {
+  if (!config.configured()) config.forever();
+  let cachedValue = cache.get(arg);
+  config.deactivate();
+  switch (config.mode()) {
+    case "forever":
+      cachedValue = [{
+        value,
+        valid: genTrue
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "invalidate":
+      cachedValue = [{
+        value,
+        valid: config.validator()
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "valid":
+      if (cachedValue) {
+        cachedValue.push({
+          value,
+          valid: config.validator()
+        });
+      } else {
+        cachedValue = [{
+          value,
+          valid: config.validator()
+        }];
+        cache.set(arg, cachedValue);
+      }
+  }
+}
+class CacheConfigurator {
+  constructor(data) {
+    this._active = true;
+    this._never = false;
+    this._forever = false;
+    this._invalidate = false;
+    this._configured = false;
+    this._pairs = [];
+    this._data = void 0;
+    this._data = data;
+  }
+  simple() {
+    return makeSimpleConfigurator(this);
+  }
+  mode() {
+    if (this._never) return "never";
+    if (this._forever) return "forever";
+    if (this._invalidate) return "invalidate";
+    return "valid";
+  }
+  forever() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never) {
+      throw new Error("Caching has already been configured with .never()");
+    }
+    this._forever = true;
+    this._configured = true;
+  }
+  never() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._forever) {
+      throw new Error("Caching has already been configured with .forever()");
+    }
+    this._never = true;
+    this._configured = true;
+  }
+  using(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+    this._configured = true;
+    const key = handler(this._data);
+    const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
+    if ((0, _async.isThenable)(key)) {
+      return key.then(key => {
+        this._pairs.push([key, fn]);
+        return key;
+      });
+    }
+    this._pairs.push([key, fn]);
+    return key;
+  }
+  invalidate(handler) {
+    this._invalidate = true;
+    return this.using(handler);
+  }
+  validator() {
+    const pairs = this._pairs;
+    return function* (data) {
+      for (const [key, fn] of pairs) {
+        if (key !== (yield* fn(data))) return false;
+      }
+      return true;
+    };
+  }
+  deactivate() {
+    this._active = false;
+  }
+  configured() {
+    return this._configured;
+  }
+}
+function makeSimpleConfigurator(cache) {
+  function cacheFn(val) {
+    if (typeof val === "boolean") {
+      if (val) cache.forever();else cache.never();
+      return;
+    }
+    return cache.using(() => assertSimpleType(val()));
+  }
+  cacheFn.forever = () => cache.forever();
+  cacheFn.never = () => cache.never();
+  cacheFn.using = cb => cache.using(() => assertSimpleType(cb()));
+  cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb()));
+  return cacheFn;
+}
+
+function assertSimpleType(value) {
+  if ((0, _async.isThenable)(value)) {
+    throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);
+  }
+  if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
+    throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
+  }
+  return value;
+}
+class Lock {
+  constructor() {
+    this.released = false;
+    this.promise = void 0;
+    this._resolve = void 0;
+    this.promise = new Promise(resolve => {
+      this._resolve = resolve;
+    });
+  }
+  release(value) {
+    this.released = true;
+    this._resolve(value);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=caching.js.map
--- a/node_modules/@babel/core/lib/config/caching.js.map
+++ b/node_modules/@babel/core/lib/config/caching.js.map
--- a/node_modules/@babel/core/lib/config/config-chain.js
+++ b/node_modules/@babel/core/lib/config/config-chain.js
@ -0,0 +1,482 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildPresetChain = buildPresetChain;
+exports.buildPresetChainWalker = void 0;
+exports.buildRootChain = buildRootChain;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+var _options = require("./validation/options");
+var _patternToRegex = require("./pattern-to-regex");
+var _printer = require("./printer");
+var _rewriteStackTrace = require("../errors/rewrite-stack-trace");
+var _configError = require("../errors/config-error");
+var _files = require("./files");
+var _caching = require("./caching");
+var _configDescriptors = require("./config-descriptors");
+
+const debug = _debug()("babel:config:config-chain");
+function* buildPresetChain(arg, context) {
+  const chain = yield* buildPresetChainWalker(arg, context);
+  if (!chain) return null;
+  return {
+    plugins: dedupDescriptors(chain.plugins),
+    presets: dedupDescriptors(chain.presets),
+    options: chain.options.map(o => normalizeOptions(o)),
+    files: new Set()
+  };
+}
+const buildPresetChainWalker = makeChainWalker({
+  root: preset => loadPresetDescriptors(preset),
+  env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
+  overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),
+  overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName),
+  createLogger: () => () => {}
+});
+exports.buildPresetChainWalker = buildPresetChainWalker;
+const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
+const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
+const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
+const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
+function* buildRootChain(opts, context) {
+  let configReport, babelRcReport;
+  const programmaticLogger = new _printer.ConfigPrinter();
+  const programmaticChain = yield* loadProgrammaticChain({
+    options: opts,
+    dirname: context.cwd
+  }, context, undefined, programmaticLogger);
+  if (!programmaticChain) return null;
+  const programmaticReport = yield* programmaticLogger.output();
+  let configFile;
+  if (typeof opts.configFile === "string") {
+    configFile = yield* (0, _files.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
+  } else if (opts.configFile !== false) {
+    configFile = yield* (0, _files.findRootConfig)(context.root, context.envName, context.caller);
+  }
+  let {
+    babelrc,
+    babelrcRoots
+  } = opts;
+  let babelrcRootsDirectory = context.cwd;
+  const configFileChain = emptyChain();
+  const configFileLogger = new _printer.ConfigPrinter();
+  if (configFile) {
+    const validatedFile = validateConfigFile(configFile);
+    const result = yield* loadFileChain(validatedFile, context, undefined, configFileLogger);
+    if (!result) return null;
+    configReport = yield* configFileLogger.output();
+
+    if (babelrc === undefined) {
+      babelrc = validatedFile.options.babelrc;
+    }
+    if (babelrcRoots === undefined) {
+      babelrcRootsDirectory = validatedFile.dirname;
+      babelrcRoots = validatedFile.options.babelrcRoots;
+    }
+    mergeChain(configFileChain, result);
+  }
+  let ignoreFile, babelrcFile;
+  let isIgnored = false;
+  const fileChain = emptyChain();
+  if ((babelrc === true || babelrc === undefined) && typeof context.filename === "string") {
+    const pkgData = yield* (0, _files.findPackageData)(context.filename);
+    if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) {
+      ({
+        ignore: ignoreFile,
+        config: babelrcFile
+      } = yield* (0, _files.findRelativeConfig)(pkgData, context.envName, context.caller));
+      if (ignoreFile) {
+        fileChain.files.add(ignoreFile.filepath);
+      }
+      if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
+        isIgnored = true;
+      }
+      if (babelrcFile && !isIgnored) {
+        const validatedFile = validateBabelrcFile(babelrcFile);
+        const babelrcLogger = new _printer.ConfigPrinter();
+        const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger);
+        if (!result) {
+          isIgnored = true;
+        } else {
+          babelRcReport = yield* babelrcLogger.output();
+          mergeChain(fileChain, result);
+        }
+      }
+      if (babelrcFile && isIgnored) {
+        fileChain.files.add(babelrcFile.filepath);
+      }
+    }
+  }
+  if (context.showConfig) {
+    console.log(`Babel configs on "${context.filename}" (ascending priority):\n` +
+    [configReport, babelRcReport, programmaticReport].filter(x => !!x).join("\n\n") + "\n-----End Babel configs-----");
+  }
+  const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
+  return {
+    plugins: isIgnored ? [] : dedupDescriptors(chain.plugins),
+    presets: isIgnored ? [] : dedupDescriptors(chain.presets),
+    options: isIgnored ? [] : chain.options.map(o => normalizeOptions(o)),
+    fileHandling: isIgnored ? "ignored" : "transpile",
+    ignore: ignoreFile || undefined,
+    babelrc: babelrcFile || undefined,
+    config: configFile || undefined,
+    files: chain.files
+  };
+}
+function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) {
+  if (typeof babelrcRoots === "boolean") return babelrcRoots;
+  const absoluteRoot = context.root;
+
+  if (babelrcRoots === undefined) {
+    return pkgData.directories.indexOf(absoluteRoot) !== -1;
+  }
+  let babelrcPatterns = babelrcRoots;
+  if (!Array.isArray(babelrcPatterns)) {
+    babelrcPatterns = [babelrcPatterns];
+  }
+  babelrcPatterns = babelrcPatterns.map(pat => {
+    return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat;
+  });
+
+  if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
+    return pkgData.directories.indexOf(absoluteRoot) !== -1;
+  }
+  return babelrcPatterns.some(pat => {
+    if (typeof pat === "string") {
+      pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory);
+    }
+    return pkgData.directories.some(directory => {
+      return matchPattern(pat, babelrcRootsDirectory, directory, context);
+    });
+  });
+}
+const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("configfile", file.options, file.filepath)
+}));
+const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("babelrcfile", file.options, file.filepath)
+}));
+const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("extendsfile", file.options, file.filepath)
+}));
+
+const loadProgrammaticChain = makeChainWalker({
+  root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
+  env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
+  overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index),
+  overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName),
+  createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger)
+});
+
+const loadFileChainWalker = makeChainWalker({
+  root: file => loadFileDescriptors(file),
+  env: (file, envName) => loadFileEnvDescriptors(file)(envName),
+  overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
+  overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName),
+  createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger)
+});
+function* loadFileChain(input, context, files, baseLogger) {
+  const chain = yield* loadFileChainWalker(input, context, files, baseLogger);
+  if (chain) {
+    chain.files.add(input.filepath);
+  }
+  return chain;
+}
+const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
+const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
+const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
+const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
+function buildFileLogger(filepath, context, baseLogger) {
+  if (!baseLogger) {
+    return () => {};
+  }
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, {
+    filepath
+  });
+}
+function buildRootDescriptors({
+  dirname,
+  options
+}, alias, descriptors) {
+  return descriptors(dirname, options, alias);
+}
+function buildProgrammaticLogger(_, context, baseLogger) {
+  var _context$caller;
+  if (!baseLogger) {
+    return () => {};
+  }
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, {
+    callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name
+  });
+}
+function buildEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, envName) {
+  const opts = options.env && options.env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
+}
+function buildOverrideDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index) {
+  const opts = options.overrides && options.overrides[index];
+  if (!opts) throw new Error("Assertion failure - missing override");
+  return descriptors(dirname, opts, `${alias}.overrides[${index}]`);
+}
+function buildOverrideEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index, envName) {
+  const override = options.overrides && options.overrides[index];
+  if (!override) throw new Error("Assertion failure - missing override");
+  const opts = override.env && override.env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null;
+}
+function makeChainWalker({
+  root,
+  env,
+  overrides,
+  overridesEnv,
+  createLogger
+}) {
+  return function* chainWalker(input, context, files = new Set(), baseLogger) {
+    const {
+      dirname
+    } = input;
+    const flattenedConfigs = [];
+    const rootOpts = root(input);
+    if (configIsApplicable(rootOpts, dirname, context, input.filepath)) {
+      flattenedConfigs.push({
+        config: rootOpts,
+        envName: undefined,
+        index: undefined
+      });
+      const envOpts = env(input, context.envName);
+      if (envOpts && configIsApplicable(envOpts, dirname, context, input.filepath)) {
+        flattenedConfigs.push({
+          config: envOpts,
+          envName: context.envName,
+          index: undefined
+        });
+      }
+      (rootOpts.options.overrides || []).forEach((_, index) => {
+        const overrideOps = overrides(input, index);
+        if (configIsApplicable(overrideOps, dirname, context, input.filepath)) {
+          flattenedConfigs.push({
+            config: overrideOps,
+            index,
+            envName: undefined
+          });
+          const overrideEnvOpts = overridesEnv(input, index, context.envName);
+          if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context, input.filepath)) {
+            flattenedConfigs.push({
+              config: overrideEnvOpts,
+              index,
+              envName: context.envName
+            });
+          }
+        }
+      });
+    }
+
+    if (flattenedConfigs.some(({
+      config: {
+        options: {
+          ignore,
+          only
+        }
+      }
+    }) => shouldIgnore(context, ignore, only, dirname))) {
+      return null;
+    }
+    const chain = emptyChain();
+    const logger = createLogger(input, context, baseLogger);
+    for (const {
+      config,
+      index,
+      envName
+    } of flattenedConfigs) {
+      if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) {
+        return null;
+      }
+      logger(config, index, envName);
+      yield* mergeChainOpts(chain, config);
+    }
+    return chain;
+  };
+}
+function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) {
+  if (opts.extends === undefined) return true;
+  const file = yield* (0, _files.loadConfig)(opts.extends, dirname, context.envName, context.caller);
+  if (files.has(file)) {
+    throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));
+  }
+  files.add(file);
+  const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger);
+  files.delete(file);
+  if (!fileChain) return false;
+  mergeChain(chain, fileChain);
+  return true;
+}
+function mergeChain(target, source) {
+  target.options.push(...source.options);
+  target.plugins.push(...source.plugins);
+  target.presets.push(...source.presets);
+  for (const file of source.files) {
+    target.files.add(file);
+  }
+  return target;
+}
+function* mergeChainOpts(target, {
+  options,
+  plugins,
+  presets
+}) {
+  target.options.push(options);
+  target.plugins.push(...(yield* plugins()));
+  target.presets.push(...(yield* presets()));
+  return target;
+}
+function emptyChain() {
+  return {
+    options: [],
+    presets: [],
+    plugins: [],
+    files: new Set()
+  };
+}
+function normalizeOptions(opts) {
+  const options = Object.assign({}, opts);
+  delete options.extends;
+  delete options.env;
+  delete options.overrides;
+  delete options.plugins;
+  delete options.presets;
+  delete options.passPerPreset;
+  delete options.ignore;
+  delete options.only;
+  delete options.test;
+  delete options.include;
+  delete options.exclude;
+
+  if (Object.prototype.hasOwnProperty.call(options, "sourceMap")) {
+    options.sourceMaps = options.sourceMap;
+    delete options.sourceMap;
+  }
+  return options;
+}
+function dedupDescriptors(items) {
+  const map = new Map();
+  const descriptors = [];
+  for (const item of items) {
+    if (typeof item.value === "function") {
+      const fnKey = item.value;
+      let nameMap = map.get(fnKey);
+      if (!nameMap) {
+        nameMap = new Map();
+        map.set(fnKey, nameMap);
+      }
+      let desc = nameMap.get(item.name);
+      if (!desc) {
+        desc = {
+          value: item
+        };
+        descriptors.push(desc);
+
+        if (!item.ownPass) nameMap.set(item.name, desc);
+      } else {
+        desc.value = item;
+      }
+    } else {
+      descriptors.push({
+        value: item
+      });
+    }
+  }
+  return descriptors.reduce((acc, desc) => {
+    acc.push(desc.value);
+    return acc;
+  }, []);
+}
+function configIsApplicable({
+  options
+}, dirname, context, configName) {
+  return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname, configName)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname, configName)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname, configName));
+}
+function configFieldIsApplicable(context, test, dirname, configName) {
+  const patterns = Array.isArray(test) ? test : [test];
+  return matchesPatterns(context, patterns, dirname, configName);
+}
+
+function ignoreListReplacer(_key, value) {
+  if (value instanceof RegExp) {
+    return String(value);
+  }
+  return value;
+}
+
+function shouldIgnore(context, ignore, only, dirname) {
+  if (ignore && matchesPatterns(context, ignore, dirname)) {
+    var _context$filename;
+    const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore, ignoreListReplacer)}\` from "${dirname}"`;
+    debug(message);
+    if (context.showConfig) {
+      console.log(message);
+    }
+    return true;
+  }
+  if (only && !matchesPatterns(context, only, dirname)) {
+    var _context$filename2;
+    const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only, ignoreListReplacer)}\` from "${dirname}"`;
+    debug(message);
+    if (context.showConfig) {
+      console.log(message);
+    }
+    return true;
+  }
+  return false;
+}
+
+function matchesPatterns(context, patterns, dirname, configName) {
+  return patterns.some(pattern => matchPattern(pattern, dirname, context.filename, context, configName));
+}
+function matchPattern(pattern, dirname, pathToTest, context, configName) {
+  if (typeof pattern === "function") {
+    return !!(0, _rewriteStackTrace.endHiddenCallStack)(pattern)(pathToTest, {
+      dirname,
+      envName: context.envName,
+      caller: context.caller
+    });
+  }
+  if (typeof pathToTest !== "string") {
+    throw new _configError.default(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`, configName);
+  }
+  if (typeof pattern === "string") {
+    pattern = (0, _patternToRegex.default)(pattern, dirname);
+  }
+  return pattern.test(pathToTest);
+}
+0 && 0;
+
+//# sourceMappingURL=config-chain.js.map
--- a/node_modules/@babel/core/lib/config/config-chain.js.map
+++ b/node_modules/@babel/core/lib/config/config-chain.js.map
--- a/node_modules/@babel/core/lib/config/config-descriptors.js
+++ b/node_modules/@babel/core/lib/config/config-descriptors.js
@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCachedDescriptors = createCachedDescriptors;
+exports.createDescriptor = createDescriptor;
+exports.createUncachedDescriptors = createUncachedDescriptors;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _functional = require("../gensync-utils/functional");
+var _files = require("./files");
+var _item = require("./item");
+var _caching = require("./caching");
+var _resolveTargets = require("./resolve-targets");
+function isEqualDescriptor(a, b) {
+  return a.name === b.name && a.value === b.value && a.options === b.options && a.dirname === b.dirname && a.alias === b.alias && a.ownPass === b.ownPass && (a.file && a.file.request) === (b.file && b.file.request) && (a.file && a.file.resolved) === (b.file && b.file.resolved);
+}
+function* handlerOf(value) {
+  return value;
+}
+function optionsWithResolvedBrowserslistConfigFile(options, dirname) {
+  if (typeof options.browserslistConfigFile === "string") {
+    options.browserslistConfigFile = (0, _resolveTargets.resolveBrowserslistConfigFile)(options.browserslistConfigFile, dirname);
+  }
+  return options;
+}
+
+function createCachedDescriptors(dirname, options, alias) {
+  const {
+    plugins,
+    presets,
+    passPerPreset
+  } = options;
+  return {
+    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
+    plugins: plugins ? () =>
+    createCachedPluginDescriptors(plugins, dirname)(alias) : () => handlerOf([]),
+    presets: presets ? () =>
+    createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => handlerOf([])
+  };
+}
+
+function createUncachedDescriptors(dirname, options, alias) {
+  return {
+    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
+    plugins: (0, _functional.once)(() => createPluginDescriptors(options.plugins || [], dirname, alias)),
+    presets: (0, _functional.once)(() => createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset))
+  };
+}
+const PRESET_DESCRIPTOR_CACHE = new WeakMap();
+const createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
+  const dirname = cache.using(dir => dir);
+  return (0, _caching.makeStrongCacheSync)(alias => (0, _caching.makeStrongCache)(function* (passPerPreset) {
+    const descriptors = yield* createPresetDescriptors(items, dirname, alias, passPerPreset);
+    return descriptors.map(
+    desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc));
+  }));
+});
+const PLUGIN_DESCRIPTOR_CACHE = new WeakMap();
+const createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
+  const dirname = cache.using(dir => dir);
+  return (0, _caching.makeStrongCache)(function* (alias) {
+    const descriptors = yield* createPluginDescriptors(items, dirname, alias);
+    return descriptors.map(
+    desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc));
+  });
+});
+
+const DEFAULT_OPTIONS = {};
+
+function loadCachedDescriptor(cache, desc) {
+  const {
+    value,
+    options = DEFAULT_OPTIONS
+  } = desc;
+  if (options === false) return desc;
+  let cacheByOptions = cache.get(value);
+  if (!cacheByOptions) {
+    cacheByOptions = new WeakMap();
+    cache.set(value, cacheByOptions);
+  }
+  let possibilities = cacheByOptions.get(options);
+  if (!possibilities) {
+    possibilities = [];
+    cacheByOptions.set(options, possibilities);
+  }
+  if (possibilities.indexOf(desc) === -1) {
+    const matches = possibilities.filter(possibility => isEqualDescriptor(possibility, desc));
+    if (matches.length > 0) {
+      return matches[0];
+    }
+    possibilities.push(desc);
+  }
+  return desc;
+}
+function* createPresetDescriptors(items, dirname, alias, passPerPreset) {
+  return yield* createDescriptors("preset", items, dirname, alias, passPerPreset);
+}
+function* createPluginDescriptors(items, dirname, alias) {
+  return yield* createDescriptors("plugin", items, dirname, alias);
+}
+function* createDescriptors(type, items, dirname, alias, ownPass) {
+  const descriptors = yield* _gensync().all(items.map((item, index) => createDescriptor(item, dirname, {
+    type,
+    alias: `${alias}$${index}`,
+    ownPass: !!ownPass
+  })));
+  assertNoDuplicates(descriptors);
+  return descriptors;
+}
+
+function* createDescriptor(pair, dirname, {
+  type,
+  alias,
+  ownPass
+}) {
+  const desc = (0, _item.getItemDescriptor)(pair);
+  if (desc) {
+    return desc;
+  }
+  let name;
+  let options;
+  let value = pair;
+  if (Array.isArray(value)) {
+    if (value.length === 3) {
+      [value, options, name] = value;
+    } else {
+      [value, options] = value;
+    }
+  }
+  let file = undefined;
+  let filepath = null;
+  if (typeof value === "string") {
+    if (typeof type !== "string") {
+      throw new Error("To resolve a string-based item, the type of item must be given");
+    }
+    const resolver = type === "plugin" ? _files.loadPlugin : _files.loadPreset;
+    const request = value;
+    ({
+      filepath,
+      value
+    } = yield* resolver(value, dirname));
+    file = {
+      request,
+      resolved: filepath
+    };
+  }
+  if (!value) {
+    throw new Error(`Unexpected falsy value: ${String(value)}`);
+  }
+  if (typeof value === "object" && value.__esModule) {
+    if (value.default) {
+      value = value.default;
+    } else {
+      throw new Error("Must export a default export when using ES6 modules.");
+    }
+  }
+  if (typeof value !== "object" && typeof value !== "function") {
+    throw new Error(`Unsupported format: ${typeof value}. Expected an object or a function.`);
+  }
+  if (filepath !== null && typeof value === "object" && value) {
+    throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`);
+  }
+  return {
+    name,
+    alias: filepath || alias,
+    value,
+    options,
+    dirname,
+    ownPass,
+    file
+  };
+}
+function assertNoDuplicates(items) {
+  const map = new Map();
+  for (const item of items) {
+    if (typeof item.value !== "function") continue;
+    let nameMap = map.get(item.value);
+    if (!nameMap) {
+      nameMap = new Set();
+      map.set(item.value, nameMap);
+    }
+    if (nameMap.has(item.name)) {
+      const conflicts = items.filter(i => i.value === item.value);
+      throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, `  plugins: [`, `    ['some-plugin', {}],`, `    ['some-plugin', {}, 'some unique name'],`, `  ]`, ``, `Duplicates detected are:`, `${JSON.stringify(conflicts, null, 2)}`].join("\n"));
+    }
+    nameMap.add(item.name);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=config-descriptors.js.map
--- a/node_modules/@babel/core/lib/config/config-descriptors.js.map
+++ b/node_modules/@babel/core/lib/config/config-descriptors.js.map
--- a/node_modules/@babel/core/lib/config/files/configuration.js
+++ b/node_modules/@babel/core/lib/config/files/configuration.js
@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROOT_CONFIG_FILENAMES = void 0;
+exports.findConfigUpwards = findConfigUpwards;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.resolveShowConfigPath = resolveShowConfigPath;
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _json() {
+  const data = require("json5");
+  _json = function () {
+    return data;
+  };
+  return data;
+}
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _caching = require("../caching");
+var _configApi = require("../helpers/config-api");
+var _utils = require("./utils");
+var _moduleTypes = require("./module-types");
+var _patternToRegex = require("../pattern-to-regex");
+var _configError = require("../../errors/config-error");
+var fs = require("../../gensync-utils/fs");
+function _module() {
+  const data = require("module");
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+var _rewriteStackTrace = require("../../errors/rewrite-stack-trace");
+const debug = _debug()("babel:config:loading:files:configuration");
+const ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json"];
+exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
+const RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json"];
+const BABELIGNORE_FILENAME = ".babelignore";
+const LOADING_CONFIGS = new Set();
+const readConfigJS = (0, _caching.makeStrongCache)(function* readConfigJS(filepath, cache) {
+  if (!_fs().existsSync(filepath)) {
+    cache.never();
+    return null;
+  }
+
+  if (LOADING_CONFIGS.has(filepath)) {
+    cache.never();
+    debug("Auto-ignoring usage of config %o.", filepath);
+    return {
+      filepath,
+      dirname: _path().dirname(filepath),
+      options: {}
+    };
+  }
+  let options;
+  try {
+    LOADING_CONFIGS.add(filepath);
+    options = yield* (0, _moduleTypes.default)(filepath, "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously.");
+  } finally {
+    LOADING_CONFIGS.delete(filepath);
+  }
+  let assertCache = false;
+  if (typeof options === "function") {
+    yield* [];
+    options = (0, _rewriteStackTrace.endHiddenCallStack)(options)((0, _configApi.makeConfigAPI)(cache));
+    assertCache = true;
+  }
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new _configError.default(`Configuration should be an exported JavaScript object.`, filepath);
+  }
+
+  if (typeof options.then === "function") {
+    throw new _configError.default(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`, filepath);
+  }
+  if (assertCache && !cache.configured()) throwConfigError(filepath);
+  return {
+    filepath,
+    dirname: _path().dirname(filepath),
+    options
+  };
+});
+const packageToBabelConfig = (0, _caching.makeWeakCacheSync)(file => {
+  const babel = file.options["babel"];
+  if (typeof babel === "undefined") return null;
+  if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
+    throw new _configError.default(`.babel property must be an object`, file.filepath);
+  }
+  return {
+    filepath: file.filepath,
+    dirname: file.dirname,
+    options: babel
+  };
+});
+const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  let options;
+  try {
+    options = _json().parse(content);
+  } catch (err) {
+    throw new _configError.default(`Error while parsing config - ${err.message}`, filepath);
+  }
+  if (!options) throw new _configError.default(`No config detected`, filepath);
+  if (typeof options !== "object") {
+    throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
+  }
+  if (Array.isArray(options)) {
+    throw new _configError.default(`Expected config object but found array`, filepath);
+  }
+  delete options["$schema"];
+  return {
+    filepath,
+    dirname: _path().dirname(filepath),
+    options
+  };
+});
+const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  const ignoreDir = _path().dirname(filepath);
+  const ignorePatterns = content.split("\n").map(line => line.replace(/#(.*?)$/, "").trim()).filter(line => !!line);
+  for (const pattern of ignorePatterns) {
+    if (pattern[0] === "!") {
+      throw new _configError.default(`Negation of file paths is not supported.`, filepath);
+    }
+  }
+  return {
+    filepath,
+    dirname: _path().dirname(filepath),
+    ignore: ignorePatterns.map(pattern => (0, _patternToRegex.default)(pattern, ignoreDir))
+  };
+});
+function findConfigUpwards(rootDir) {
+  let dirname = rootDir;
+  for (;;) {
+    for (const filename of ROOT_CONFIG_FILENAMES) {
+      if (_fs().existsSync(_path().join(dirname, filename))) {
+        return dirname;
+      }
+    }
+    const nextDir = _path().dirname(dirname);
+    if (dirname === nextDir) break;
+    dirname = nextDir;
+  }
+  return null;
+}
+function* findRelativeConfig(packageData, envName, caller) {
+  let config = null;
+  let ignore = null;
+  const dirname = _path().dirname(packageData.filepath);
+  for (const loc of packageData.directories) {
+    if (!config) {
+      var _packageData$pkg;
+      config = yield* loadOneConfig(RELATIVE_CONFIG_FILENAMES, loc, envName, caller, ((_packageData$pkg = packageData.pkg) == null ? void 0 : _packageData$pkg.dirname) === loc ? packageToBabelConfig(packageData.pkg) : null);
+    }
+    if (!ignore) {
+      const ignoreLoc = _path().join(loc, BABELIGNORE_FILENAME);
+      ignore = yield* readIgnoreConfig(ignoreLoc);
+      if (ignore) {
+        debug("Found ignore %o from %o.", ignore.filepath, dirname);
+      }
+    }
+  }
+  return {
+    config,
+    ignore
+  };
+}
+function findRootConfig(dirname, envName, caller) {
+  return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
+}
+function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) {
+  const configs = yield* _gensync().all(names.map(filename => readConfig(_path().join(dirname, filename), envName, caller)));
+  const config = configs.reduce((previousConfig, config) => {
+    if (config && previousConfig) {
+      throw new _configError.default(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`);
+    }
+    return config || previousConfig;
+  }, previousConfig);
+  if (config) {
+    debug("Found configuration %o from %o.", config.filepath, dirname);
+  }
+  return config;
+}
+function* loadConfig(name, dirname, envName, caller) {
+  const filepath = (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
+    paths: [b]
+  }, M = require("module")) => {
+    let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
+    if (f) return f;
+    f = new Error(`Cannot resolve module '${r}'`);
+    f.code = "MODULE_NOT_FOUND";
+    throw f;
+  })(name, {
+    paths: [dirname]
+  });
+  const conf = yield* readConfig(filepath, envName, caller);
+  if (!conf) {
+    throw new _configError.default(`Config file contains no configuration data`, filepath);
+  }
+  debug("Loaded config %o from %o.", name, dirname);
+  return conf;
+}
+
+function readConfig(filepath, envName, caller) {
+  const ext = _path().extname(filepath);
+  return ext === ".js" || ext === ".cjs" || ext === ".mjs" ? readConfigJS(filepath, {
+    envName,
+    caller
+  }) : readConfigJSON5(filepath);
+}
+function* resolveShowConfigPath(dirname) {
+  const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;
+  if (targetPath != null) {
+    const absolutePath = _path().resolve(dirname, targetPath);
+    const stats = yield* fs.stat(absolutePath);
+    if (!stats.isFile()) {
+      throw new Error(`${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`);
+    }
+    return absolutePath;
+  }
+  return null;
+}
+function throwConfigError(filepath) {
+  throw new _configError.default(`\
+Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured
+for various types of caching, using the first param of their handler functions:
+
+module.exports = function(api) {
+  // The API exposes the following:
+
+  // Cache the returned value forever and don't call this function again.
+  api.cache(true);
+
+  // Don't cache at all. Not recommended because it will be very slow.
+  api.cache(false);
+
+  // Cached based on the value of some function. If this function returns a value different from
+  // a previously-encountered value, the plugins will re-evaluate.
+  var env = api.cache(() => process.env.NODE_ENV);
+
+  // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for
+  // any possible NODE_ENV value that might come up during plugin execution.
+  var isProd = api.cache(() => process.env.NODE_ENV === "production");
+
+  // .cache(fn) will perform a linear search though instances to find the matching plugin based
+  // based on previous instantiated plugins. If you want to recreate the plugin and discard the
+  // previous instance whenever something changes, you may use:
+  var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production");
+
+  // Note, we also expose the following more-verbose versions of the above examples:
+  api.cache.forever(); // api.cache(true)
+  api.cache.never();   // api.cache(false)
+  api.cache.using(fn); // api.cache(fn)
+
+  // Return the value that will be cached.
+  return { };
+};`, filepath);
+}
+0 && 0;
+
+//# sourceMappingURL=configuration.js.map
--- a/node_modules/@babel/core/lib/config/files/configuration.js.map
+++ b/node_modules/@babel/core/lib/config/files/configuration.js.map
--- a/node_modules/@babel/core/lib/config/files/import-meta-resolve.js
+++ b/node_modules/@babel/core/lib/config/files/import-meta-resolve.js
@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = resolve;
+function _module() {
+  const data = require("module");
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+var _importMetaResolve = require("../../vendor/import-meta-resolve");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+let import_;
+try {
+  import_ = require("./import.cjs");
+} catch (_unused) {}
+
+const importMetaResolveP = import_ &&
+process.execArgv.includes("--experimental-import-meta-resolve") ? import_("data:text/javascript,export default import.meta.resolve").then(m => m.default || _importMetaResolve.resolve, () => _importMetaResolve.resolve) : Promise.resolve(_importMetaResolve.resolve);
+function resolve(_x, _x2) {
+  return _resolve.apply(this, arguments);
+}
+function _resolve() {
+  _resolve = _asyncToGenerator(function* (specifier, parent) {
+    return (yield importMetaResolveP)(specifier, parent);
+  });
+  return _resolve.apply(this, arguments);
+}
+0 && 0;
+
+//# sourceMappingURL=import-meta-resolve.js.map
--- a/node_modules/@babel/core/lib/config/files/import-meta-resolve.js.map
+++ b/node_modules/@babel/core/lib/config/files/import-meta-resolve.js.map
@ -0,0 +1 @@
+{"version":3,"names":["import_","require","importMetaResolveP","process","execArgv","includes","then","m","default","polyfill","Promise","resolve","specifier","parent"],"sources":["../../../src/config/files/import-meta-resolve.ts"],"sourcesContent":["import { createRequire } from \"module\";\nimport { resolve as polyfill } from \"../../vendor/import-meta-resolve\";\n\nconst require = createRequire(import.meta.url);\n\nlet import_;\ntry {\n  // Node < 13.3 doesn't support import() syntax.\n  import_ = require(\"./import.cjs\");\n} catch {}\n\n// import.meta.resolve is only available in ESM, but this file is compiled to CJS.\n// We can extract it using dynamic import.\nconst importMetaResolveP: Promise<ImportMeta[\"resolve\"]> =\n  import_ &&\n  // Due to a Node.js/V8 bug (https://github.com/nodejs/node/issues/35889), we cannot\n  // use always dynamic import because it segfaults when running in a Node.js `vm` context,\n  // which is used by the default Jest environment and by webpack-cli.\n  //\n  // However, import.meta.resolve is experimental and only enabled when Node.js is run\n  // with the `--experimental-import-meta-resolve` flag: we can avoid calling import()\n  // when that flag is not enabled, so that the default behavior never segfaults.\n  //\n  // Hopefully, before Node.js unflags import.meta.resolve, either:\n  // - we will move to ESM, so that we have direct access to import.meta.resolve, or\n  // - the V8 bug will be fixed so that we can safely use dynamic import by default.\n  //\n  // I (@nicolo-ribaudo) am really anoyed by this bug, because there is no known\n  // work-around other than \"don't use dynamic import if you are running in a `vm` context\",\n  // but there is no reliable way to detect it (you cannot try/catch segfaults).\n  //\n  // This is the only place where we *need* to use dynamic import because we need to access\n  // an ES module. All the other places will first try using require() and *then*, if\n  // it throws because it's a module, will fallback to import().\n  process.execArgv.includes(\"--experimental-import-meta-resolve\")\n    ? import_(\"data:text/javascript,export default import.meta.resolve\").then(\n        (m: { default: ImportMeta[\"resolve\"] | undefined }) =>\n          m.default || polyfill,\n        () => polyfill,\n      )\n    : Promise.resolve(polyfill);\n\nexport default async function resolve(\n  specifier: Parameters<ImportMeta[\"resolve\"]>[0],\n  parent?: Parameters<ImportMeta[\"resolve\"]>[1],\n): ReturnType<ImportMeta[\"resolve\"]> {\n  return (await importMetaResolveP)(specifier, parent);\n}\n"],"mappings":";;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;AAAuE;AAAA;AAIvE,IAAIA,OAAO;AACX,IAAI;EAEFA,OAAO,GAAGC,OAAO,CAAC,cAAc,CAAC;AACnC,CAAC,CAAC,gBAAM,CAAC;;AAIT,MAAMC,kBAAkD,GACtDF,OAAO;AAoBPG,OAAO,CAACC,QAAQ,CAACC,QAAQ,CAAC,oCAAoC,CAAC,GAC3DL,OAAO,CAAC,yDAAyD,CAAC,CAACM,IAAI,CACpEC,CAAiD,IAChDA,CAAC,CAACC,OAAO,IAAIC,0BAAQ,EACvB,MAAMA,0BAAQ,CACf,GACDC,OAAO,CAACC,OAAO,CAACF,0BAAQ,CAAC;AAAC,SAEFE,OAAO;EAAA;AAAA;AAAA;EAAA,6BAAtB,WACbC,SAA+C,EAC/CC,MAA6C,EACV;IACnC,OAAO,OAAOX,kBAAkB,EAAEU,SAAS,EAAEC,MAAM,CAAC;EACtD,CAAC;EAAA;AAAA;AAAA"}
--- a/node_modules/@babel/core/lib/config/files/import.cjs
+++ b/node_modules/@babel/core/lib/config/files/import.cjs
@ -0,0 +1,8 @@
+
+
+module.exports = function import_(filepath) {
+  return import(filepath);
+};
+0 && 0;
+
+//# sourceMappingURL=import.cjs.map
--- a/node_modules/@babel/core/lib/config/files/import.cjs.map
+++ b/node_modules/@babel/core/lib/config/files/import.cjs.map
@ -0,0 +1 @@
+{"version":3,"names":["module","exports","import_","filepath"],"sources":["../../../src/config/files/import.cjs"],"sourcesContent":["// We keep this in a separate file so that in older node versions, where\n// import() isn't supported, we can try/catch around the require() call\n// when loading this file.\n\nmodule.exports = function import_(filepath) {\n  return import(filepath);\n};\n"],"mappings":";;AAIAA,MAAM,CAACC,OAAO,GAAG,SAASC,OAAO,CAACC,QAAQ,EAAE;EAC1C,OAAO,MAAM,CAACA,QAAQ,CAAC;AACzB,CAAC;AAAC"}
--- a/node_modules/@babel/core/lib/config/files/index-browser.js
+++ b/node_modules/@babel/core/lib/config/files/index-browser.js
@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROOT_CONFIG_FILENAMES = void 0;
+exports.findConfigUpwards = findConfigUpwards;
+exports.findPackageData = findPackageData;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.resolveShowConfigPath = resolveShowConfigPath;
+function findConfigUpwards(
+rootDir) {
+  return null;
+}
+
+function* findPackageData(filepath) {
+  return {
+    filepath,
+    directories: [],
+    pkg: null,
+    isPackage: false
+  };
+}
+
+function* findRelativeConfig(
+pkgData,
+envName,
+caller) {
+  return {
+    config: null,
+    ignore: null
+  };
+}
+
+function* findRootConfig(
+dirname,
+envName,
+caller) {
+  return null;
+}
+
+function* loadConfig(name, dirname,
+envName,
+caller) {
+  throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
+}
+
+function* resolveShowConfigPath(
+dirname) {
+  return null;
+}
+const ROOT_CONFIG_FILENAMES = [];
+
+exports.ROOT_CONFIG_FILENAMES = ROOT_CONFIG_FILENAMES;
+function resolvePlugin(name, dirname) {
+  return null;
+}
+
+function resolvePreset(name, dirname) {
+  return null;
+}
+function loadPlugin(name, dirname) {
+  throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`);
+}
+function loadPreset(name, dirname) {
+  throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`);
+}
+0 && 0;
+
+//# sourceMappingURL=index-browser.js.map
--- a/node_modules/@babel/core/lib/config/files/index-browser.js.map
+++ b/node_modules/@babel/core/lib/config/files/index-browser.js.map
@ -0,0 +1 @@
+{"version":3,"names":["findConfigUpwards","rootDir","findPackageData","filepath","directories","pkg","isPackage","findRelativeConfig","pkgData","envName","caller","config","ignore","findRootConfig","dirname","loadConfig","name","Error","resolveShowConfigPath","ROOT_CONFIG_FILENAMES","resolvePlugin","resolvePreset","loadPlugin","loadPreset"],"sources":["../../../src/config/files/index-browser.ts"],"sourcesContent":["import type { Handler } from \"gensync\";\n\nimport type {\n  ConfigFile,\n  IgnoreFile,\n  RelativeConfig,\n  FilePackageData,\n} from \"./types\";\n\nimport type { CallerMetadata } from \"../validation/options\";\n\nexport type { ConfigFile, IgnoreFile, RelativeConfig, FilePackageData };\n\nexport function findConfigUpwards(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  rootDir: string,\n): string | null {\n  return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* findPackageData(filepath: string): Handler<FilePackageData> {\n  return {\n    filepath,\n    directories: [],\n    pkg: null,\n    isPackage: false,\n  };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRelativeConfig(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  pkgData: FilePackageData,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  envName: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  caller: CallerMetadata | undefined,\n): Handler<RelativeConfig> {\n  return { config: null, ignore: null };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRootConfig(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  dirname: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  envName: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  caller: CallerMetadata | undefined,\n): Handler<ConfigFile | null> {\n  return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* loadConfig(\n  name: string,\n  dirname: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  envName: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  caller: CallerMetadata | undefined,\n): Handler<ConfigFile> {\n  throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);\n}\n\n// eslint-disable-next-line require-yield\nexport function* resolveShowConfigPath(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  dirname: string,\n): Handler<string | null> {\n  return null;\n}\n\nexport const ROOT_CONFIG_FILENAMES: string[] = [];\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePlugin(name: string, dirname: string): string | null {\n  return null;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePreset(name: string, dirname: string): string | null {\n  return null;\n}\n\nexport function loadPlugin(\n  name: string,\n  dirname: string,\n): Handler<{\n  filepath: string;\n  value: unknown;\n}> {\n  throw new Error(\n    `Cannot load plugin ${name} relative to ${dirname} in a browser`,\n  );\n}\n\nexport function loadPreset(\n  name: string,\n  dirname: string,\n): Handler<{\n  filepath: string;\n  value: unknown;\n}> {\n  throw new Error(\n    `Cannot load preset ${name} relative to ${dirname} in a browser`,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAaO,SAASA,iBAAiB;AAE/BC,OAAe,EACA;EACf,OAAO,IAAI;AACb;;AAGO,UAAUC,eAAe,CAACC,QAAgB,EAA4B;EAC3E,OAAO;IACLA,QAAQ;IACRC,WAAW,EAAE,EAAE;IACfC,GAAG,EAAE,IAAI;IACTC,SAAS,EAAE;EACb,CAAC;AACH;;AAGO,UAAUC,kBAAkB;AAEjCC,OAAwB;AAExBC,OAAe;AAEfC,MAAkC,EACT;EACzB,OAAO;IAAEC,MAAM,EAAE,IAAI;IAAEC,MAAM,EAAE;EAAK,CAAC;AACvC;;AAGO,UAAUC,cAAc;AAE7BC,OAAe;AAEfL,OAAe;AAEfC,MAAkC,EACN;EAC5B,OAAO,IAAI;AACb;;AAGO,UAAUK,UAAU,CACzBC,IAAY,EACZF,OAAe;AAEfL,OAAe;AAEfC,MAAkC,EACb;EACrB,MAAM,IAAIO,KAAK,CAAE,eAAcD,IAAK,gBAAeF,OAAQ,eAAc,CAAC;AAC5E;;AAGO,UAAUI,qBAAqB;AAEpCJ,OAAe,EACS;EACxB,OAAO,IAAI;AACb;AAEO,MAAMK,qBAA+B,GAAG,EAAE;;AAAC;AAG3C,SAASC,aAAa,CAACJ,IAAY,EAAEF,OAAe,EAAiB;EAC1E,OAAO,IAAI;AACb;;AAGO,SAASO,aAAa,CAACL,IAAY,EAAEF,OAAe,EAAiB;EAC1E,OAAO,IAAI;AACb;AAEO,SAASQ,UAAU,CACxBN,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACZ,sBAAqBD,IAAK,gBAAeF,OAAQ,eAAc,CACjE;AACH;AAEO,SAASS,UAAU,CACxBP,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACZ,sBAAqBD,IAAK,gBAAeF,OAAQ,eAAc,CACjE;AACH;AAAC"}
--- a/node_modules/@babel/core/lib/config/files/index.js
+++ b/node_modules/@babel/core/lib/config/files/index.js
@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", {
+  enumerable: true,
+  get: function () {
+    return _configuration.ROOT_CONFIG_FILENAMES;
+  }
+});
+Object.defineProperty(exports, "findConfigUpwards", {
+  enumerable: true,
+  get: function () {
+    return _configuration.findConfigUpwards;
+  }
+});
+Object.defineProperty(exports, "findPackageData", {
+  enumerable: true,
+  get: function () {
+    return _package.findPackageData;
+  }
+});
+Object.defineProperty(exports, "findRelativeConfig", {
+  enumerable: true,
+  get: function () {
+    return _configuration.findRelativeConfig;
+  }
+});
+Object.defineProperty(exports, "findRootConfig", {
+  enumerable: true,
+  get: function () {
+    return _configuration.findRootConfig;
+  }
+});
+Object.defineProperty(exports, "loadConfig", {
+  enumerable: true,
+  get: function () {
+    return _configuration.loadConfig;
+  }
+});
+Object.defineProperty(exports, "loadPlugin", {
+  enumerable: true,
+  get: function () {
+    return plugins.loadPlugin;
+  }
+});
+Object.defineProperty(exports, "loadPreset", {
+  enumerable: true,
+  get: function () {
+    return plugins.loadPreset;
+  }
+});
+exports.resolvePreset = exports.resolvePlugin = void 0;
+Object.defineProperty(exports, "resolveShowConfigPath", {
+  enumerable: true,
+  get: function () {
+    return _configuration.resolveShowConfigPath;
+  }
+});
+var _package = require("./package");
+var _configuration = require("./configuration");
+var plugins = require("./plugins");
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+({});
+const resolvePlugin = _gensync()(plugins.resolvePlugin).sync;
+exports.resolvePlugin = resolvePlugin;
+const resolvePreset = _gensync()(plugins.resolvePreset).sync;
+exports.resolvePreset = resolvePreset;
+0 && 0;
+
+//# sourceMappingURL=index.js.map
--- a/node_modules/@babel/core/lib/config/files/index.js.map
+++ b/node_modules/@babel/core/lib/config/files/index.js.map
@ -0,0 +1 @@
+{"version":3,"names":["resolvePlugin","gensync","plugins","sync","resolvePreset"],"sources":["../../../src/config/files/index.ts"],"sourcesContent":["type indexBrowserType = typeof import(\"./index-browser\");\ntype indexType = typeof import(\"./index\");\n\n// Kind of gross, but essentially asserting that the exports of this module are the same as the\n// exports of index-browser, since this file may be replaced at bundle time with index-browser.\n({} as any as indexBrowserType as indexType);\n\nexport { findPackageData } from \"./package\";\n\nexport {\n  findConfigUpwards,\n  findRelativeConfig,\n  findRootConfig,\n  loadConfig,\n  resolveShowConfigPath,\n  ROOT_CONFIG_FILENAMES,\n} from \"./configuration\";\nexport type {\n  ConfigFile,\n  IgnoreFile,\n  RelativeConfig,\n  FilePackageData,\n} from \"./types\";\nexport { loadPlugin, loadPreset } from \"./plugins\";\n\nimport gensync from \"gensync\";\nimport * as plugins from \"./plugins\";\n\nexport const resolvePlugin = gensync(plugins.resolvePlugin).sync;\nexport const resolvePreset = gensync(plugins.resolvePreset).sync;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;AAEA;AAcA;AAEA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AApBA,CAAC,CAAC,CAAC;AAuBI,MAAMA,aAAa,GAAGC,UAAO,CAACC,OAAO,CAACF,aAAa,CAAC,CAACG,IAAI;AAAC;AAC1D,MAAMC,aAAa,GAAGH,UAAO,CAACC,OAAO,CAACE,aAAa,CAAC,CAACD,IAAI;AAAC;AAAA"}
--- a/node_modules/@babel/core/lib/config/files/module-types.js
+++ b/node_modules/@babel/core/lib/config/files/module-types.js
@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loadCjsOrMjsDefault;
+exports.supportsESM = void 0;
+var _async = require("../../gensync-utils/async");
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _url() {
+  const data = require("url");
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+function _module() {
+  const data = require("module");
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = require("semver");
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+var _rewriteStackTrace = require("../../errors/rewrite-stack-trace");
+var _configError = require("../../errors/config-error");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+let import_;
+try {
+  import_ = require("./import.cjs");
+} catch (_unused) {}
+const supportsESM = _semver().satisfies(process.versions.node,
+"^12.17 || >=13.2");
+exports.supportsESM = supportsESM;
+function* loadCjsOrMjsDefault(filepath, asyncError,
+fallbackToTranspiledModule = false) {
+  switch (guessJSModuleType(filepath)) {
+    case "cjs":
+      return loadCjsDefault(filepath, fallbackToTranspiledModule);
+    case "unknown":
+      try {
+        return loadCjsDefault(filepath, fallbackToTranspiledModule);
+      } catch (e) {
+        if (e.code !== "ERR_REQUIRE_ESM") throw e;
+      }
+    case "mjs":
+      if (yield* (0, _async.isAsync)()) {
+        return yield* (0, _async.waitFor)(loadMjsDefault(filepath));
+      }
+      throw new _configError.default(asyncError, filepath);
+  }
+}
+function guessJSModuleType(filename) {
+  switch (_path().extname(filename)) {
+    case ".cjs":
+      return "cjs";
+    case ".mjs":
+      return "mjs";
+    default:
+      return "unknown";
+  }
+}
+function loadCjsDefault(filepath, fallbackToTranspiledModule) {
+  const module = (0, _rewriteStackTrace.endHiddenCallStack)(require)(filepath);
+  return module != null && module.__esModule ?
+  module.default || (fallbackToTranspiledModule ? module : undefined) : module;
+}
+function loadMjsDefault(_x) {
+  return _loadMjsDefault.apply(this, arguments);
+}
+function _loadMjsDefault() {
+  _loadMjsDefault = _asyncToGenerator(function* (filepath) {
+    if (!import_) {
+      throw new _configError.default("Internal error: Native ECMAScript modules aren't supported" + " by this platform.\n", filepath);
+    }
+
+    const module = yield (0, _rewriteStackTrace.endHiddenCallStack)(import_)((0, _url().pathToFileURL)(filepath));
+    return module.default;
+  });
+  return _loadMjsDefault.apply(this, arguments);
+}
+0 && 0;
+
+//# sourceMappingURL=module-types.js.map
--- a/node_modules/@babel/core/lib/config/files/module-types.js.map
+++ b/node_modules/@babel/core/lib/config/files/module-types.js.map
@ -0,0 +1 @@
+{"version":3,"names":["import_","require","supportsESM","semver","satisfies","process","versions","node","loadCjsOrMjsDefault","filepath","asyncError","fallbackToTranspiledModule","guessJSModuleType","loadCjsDefault","e","code","isAsync","waitFor","loadMjsDefault","ConfigError","filename","path","extname","module","endHiddenCallStack","__esModule","default","undefined","pathToFileURL"],"sources":["../../../src/config/files/module-types.ts"],"sourcesContent":["import { isAsync, waitFor } from \"../../gensync-utils/async\";\nimport type { Handler } from \"gensync\";\nimport path from \"path\";\nimport { pathToFileURL } from \"url\";\nimport { createRequire } from \"module\";\nimport semver from \"semver\";\n\nimport { endHiddenCallStack } from \"../../errors/rewrite-stack-trace\";\nimport ConfigError from \"../../errors/config-error\";\n\nconst require = createRequire(import.meta.url);\n\nlet import_: ((specifier: string | URL) => any) | undefined;\ntry {\n  // Old Node.js versions don't support import() syntax.\n  import_ = require(\"./import.cjs\");\n} catch {}\n\nexport const supportsESM = semver.satisfies(\n  process.versions.node,\n  // older versions, starting from 10, support the dynamic\n  // import syntax but always return a rejected promise.\n  \"^12.17 || >=13.2\",\n);\n\nexport default function* loadCjsOrMjsDefault(\n  filepath: string,\n  asyncError: string,\n  // TODO(Babel 8): Remove this\n  fallbackToTranspiledModule: boolean = false,\n): Handler<unknown> {\n  switch (guessJSModuleType(filepath)) {\n    case \"cjs\":\n      return loadCjsDefault(filepath, fallbackToTranspiledModule);\n    case \"unknown\":\n      try {\n        return loadCjsDefault(filepath, fallbackToTranspiledModule);\n      } catch (e) {\n        if (e.code !== \"ERR_REQUIRE_ESM\") throw e;\n      }\n    // fall through\n    case \"mjs\":\n      if (yield* isAsync()) {\n        return yield* waitFor(loadMjsDefault(filepath));\n      }\n      throw new ConfigError(asyncError, filepath);\n  }\n}\n\nfunction guessJSModuleType(filename: string): \"cjs\" | \"mjs\" | \"unknown\" {\n  switch (path.extname(filename)) {\n    case \".cjs\":\n      return \"cjs\";\n    case \".mjs\":\n      return \"mjs\";\n    default:\n      return \"unknown\";\n  }\n}\n\nfunction loadCjsDefault(filepath: string, fallbackToTranspiledModule: boolean) {\n  const module = endHiddenCallStack(require)(filepath) as any;\n  return module?.__esModule\n    ? // TODO (Babel 8): Remove \"module\" and \"undefined\" fallback\n      module.default || (fallbackToTranspiledModule ? module : undefined)\n    : module;\n}\n\nasync function loadMjsDefault(filepath: string) {\n  if (!import_) {\n    throw new ConfigError(\n      \"Internal error: Native ECMAScript modules aren't supported\" +\n        \" by this platform.\\n\",\n      filepath,\n    );\n  }\n\n  // import() expects URLs, not file paths.\n  // https://github.com/nodejs/node/issues/31710\n  const module = await endHiddenCallStack(import_)(pathToFileURL(filepath));\n  return module.default;\n}\n"],"mappings":";;;;;;;AAAA;AAEA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEA;AACA;AAAoD;AAAA;AAIpD,IAAIA,OAAuD;AAC3D,IAAI;EAEFA,OAAO,GAAGC,OAAO,CAAC,cAAc,CAAC;AACnC,CAAC,CAAC,gBAAM,CAAC;AAEF,MAAMC,WAAW,GAAGC,SAAM,CAACC,SAAS,CACzCC,OAAO,CAACC,QAAQ,CAACC,IAAI;AAGrB,kBAAkB,CACnB;AAAC;AAEa,UAAUC,mBAAmB,CAC1CC,QAAgB,EAChBC,UAAkB;AAElBC,0BAAmC,GAAG,KAAK,EACzB;EAClB,QAAQC,iBAAiB,CAACH,QAAQ,CAAC;IACjC,KAAK,KAAK;MACR,OAAOI,cAAc,CAACJ,QAAQ,EAAEE,0BAA0B,CAAC;IAC7D,KAAK,SAAS;MACZ,IAAI;QACF,OAAOE,cAAc,CAACJ,QAAQ,EAAEE,0BAA0B,CAAC;MAC7D,CAAC,CAAC,OAAOG,CAAC,EAAE;QACV,IAAIA,CAAC,CAACC,IAAI,KAAK,iBAAiB,EAAE,MAAMD,CAAC;MAC3C;IAEF,KAAK,KAAK;MACR,IAAI,OAAO,IAAAE,cAAO,GAAE,EAAE;QACpB,OAAO,OAAO,IAAAC,cAAO,EAACC,cAAc,CAACT,QAAQ,CAAC,CAAC;MACjD;MACA,MAAM,IAAIU,oBAAW,CAACT,UAAU,EAAED,QAAQ,CAAC;EAAC;AAElD;AAEA,SAASG,iBAAiB,CAACQ,QAAgB,EAA6B;EACtE,QAAQC,OAAI,CAACC,OAAO,CAACF,QAAQ,CAAC;IAC5B,KAAK,MAAM;MACT,OAAO,KAAK;IACd,KAAK,MAAM;MACT,OAAO,KAAK;IACd;MACE,OAAO,SAAS;EAAC;AAEvB;AAEA,SAASP,cAAc,CAACJ,QAAgB,EAAEE,0BAAmC,EAAE;EAC7E,MAAMY,MAAM,GAAG,IAAAC,qCAAkB,EAACvB,OAAO,CAAC,CAACQ,QAAQ,CAAQ;EAC3D,OAAOc,MAAM,YAANA,MAAM,CAAEE,UAAU;EAErBF,MAAM,CAACG,OAAO,KAAKf,0BAA0B,GAAGY,MAAM,GAAGI,SAAS,CAAC,GACnEJ,MAAM;AACZ;AAAC,SAEcL,cAAc;EAAA;AAAA;AAAA;EAAA,oCAA7B,WAA8BT,QAAgB,EAAE;IAC9C,IAAI,CAACT,OAAO,EAAE;MACZ,MAAM,IAAImB,oBAAW,CACnB,4DAA4D,GAC1D,sBAAsB,EACxBV,QAAQ,CACT;IACH;;IAIA,MAAMc,MAAM,SAAS,IAAAC,qCAAkB,EAACxB,OAAO,CAAC,CAAC,IAAA4B,oBAAa,EAACnB,QAAQ,CAAC,CAAC;IACzE,OAAOc,MAAM,CAACG,OAAO;EACvB,CAAC;EAAA;AAAA;AAAA"}
--- a/node_modules/@babel/core/lib/config/files/package.js
+++ b/node_modules/@babel/core/lib/config/files/package.js
@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findPackageData = findPackageData;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("./utils");
+var _configError = require("../../errors/config-error");
+const PACKAGE_FILENAME = "package.json";
+const readConfigPackage = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  let options;
+  try {
+    options = JSON.parse(content);
+  } catch (err) {
+    throw new _configError.default(`Error while parsing JSON - ${err.message}`, filepath);
+  }
+  if (!options) throw new Error(`${filepath}: No config detected`);
+  if (typeof options !== "object") {
+    throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
+  }
+  if (Array.isArray(options)) {
+    throw new _configError.default(`Expected config object but found array`, filepath);
+  }
+  return {
+    filepath,
+    dirname: _path().dirname(filepath),
+    options
+  };
+});
+
+function* findPackageData(filepath) {
+  let pkg = null;
+  const directories = [];
+  let isPackage = true;
+  let dirname = _path().dirname(filepath);
+  while (!pkg && _path().basename(dirname) !== "node_modules") {
+    directories.push(dirname);
+    pkg = yield* readConfigPackage(_path().join(dirname, PACKAGE_FILENAME));
+    const nextLoc = _path().dirname(dirname);
+    if (dirname === nextLoc) {
+      isPackage = false;
+      break;
+    }
+    dirname = nextLoc;
+  }
+  return {
+    filepath,
+    directories,
+    pkg,
+    isPackage
+  };
+}
+0 && 0;
+
+//# sourceMappingURL=package.js.map
--- a/node_modules/@babel/core/lib/config/files/package.js.map
+++ b/node_modules/@babel/core/lib/config/files/package.js.map
@ -0,0 +1 @@
+{"version":3,"names":["PACKAGE_FILENAME","readConfigPackage","makeStaticFileCache","filepath","content","options","JSON","parse","err","ConfigError","message","Error","Array","isArray","dirname","path","findPackageData","pkg","directories","isPackage","basename","push","join","nextLoc"],"sources":["../../../src/config/files/package.ts"],"sourcesContent":["import path from \"path\";\nimport type { Handler } from \"gensync\";\nimport { makeStaticFileCache } from \"./utils\";\n\nimport type { ConfigFile, FilePackageData } from \"./types\";\n\nimport ConfigError from \"../../errors/config-error\";\n\nconst PACKAGE_FILENAME = \"package.json\";\n\nconst readConfigPackage = makeStaticFileCache(\n  (filepath, content): ConfigFile => {\n    let options;\n    try {\n      options = JSON.parse(content) as unknown;\n    } catch (err) {\n      throw new ConfigError(\n        `Error while parsing JSON - ${err.message}`,\n        filepath,\n      );\n    }\n\n    if (!options) throw new Error(`${filepath}: No config detected`);\n\n    if (typeof options !== \"object\") {\n      throw new ConfigError(\n        `Config returned typeof ${typeof options}`,\n        filepath,\n      );\n    }\n    if (Array.isArray(options)) {\n      throw new ConfigError(`Expected config object but found array`, filepath);\n    }\n\n    return {\n      filepath,\n      dirname: path.dirname(filepath),\n      options,\n    };\n  },\n);\n\n/**\n * Find metadata about the package that this file is inside of. Resolution\n * of Babel's config requires general package information to decide when to\n * search for .babelrc files\n */\nexport function* findPackageData(filepath: string): Handler<FilePackageData> {\n  let pkg = null;\n  const directories = [];\n  let isPackage = true;\n\n  let dirname = path.dirname(filepath);\n  while (!pkg && path.basename(dirname) !== \"node_modules\") {\n    directories.push(dirname);\n\n    pkg = yield* readConfigPackage(path.join(dirname, PACKAGE_FILENAME));\n\n    const nextLoc = path.dirname(dirname);\n    if (dirname === nextLoc) {\n      isPackage = false;\n      break;\n    }\n    dirname = nextLoc;\n  }\n\n  return { filepath, directories, pkg, isPackage };\n}\n"],"mappings":";;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEA;AAIA;AAEA,MAAMA,gBAAgB,GAAG,cAAc;AAEvC,MAAMC,iBAAiB,GAAG,IAAAC,0BAAmB,EAC3C,CAACC,QAAQ,EAAEC,OAAO,KAAiB;EACjC,IAAIC,OAAO;EACX,IAAI;IACFA,OAAO,GAAGC,IAAI,CAACC,KAAK,CAACH,OAAO,CAAY;EAC1C,CAAC,CAAC,OAAOI,GAAG,EAAE;IACZ,MAAM,IAAIC,oBAAW,CAClB,8BAA6BD,GAAG,CAACE,OAAQ,EAAC,EAC3CP,QAAQ,CACT;EACH;EAEA,IAAI,CAACE,OAAO,EAAE,MAAM,IAAIM,KAAK,CAAE,GAAER,QAAS,sBAAqB,CAAC;EAEhE,IAAI,OAAOE,OAAO,KAAK,QAAQ,EAAE;IAC/B,MAAM,IAAII,oBAAW,CAClB,0BAAyB,OAAOJ,OAAQ,EAAC,EAC1CF,QAAQ,CACT;EACH;EACA,IAAIS,KAAK,CAACC,OAAO,CAACR,OAAO,CAAC,EAAE;IAC1B,MAAM,IAAII,oBAAW,CAAE,wCAAuC,EAAEN,QAAQ,CAAC;EAC3E;EAEA,OAAO;IACLA,QAAQ;IACRW,OAAO,EAAEC,OAAI,CAACD,OAAO,CAACX,QAAQ,CAAC;IAC/BE;EACF,CAAC;AACH,CAAC,CACF;;AAOM,UAAUW,eAAe,CAACb,QAAgB,EAA4B;EAC3E,IAAIc,GAAG,GAAG,IAAI;EACd,MAAMC,WAAW,GAAG,EAAE;EACtB,IAAIC,SAAS,GAAG,IAAI;EAEpB,IAAIL,OAAO,GAAGC,OAAI,CAACD,OAAO,CAACX,QAAQ,CAAC;EACpC,OAAO,CAACc,GAAG,IAAIF,OAAI,CAACK,QAAQ,CAACN,OAAO,CAAC,KAAK,cAAc,EAAE;IACxDI,WAAW,CAACG,IAAI,CAACP,OAAO,CAAC;IAEzBG,GAAG,GAAG,OAAOhB,iBAAiB,CAACc,OAAI,CAACO,IAAI,CAACR,OAAO,EAAEd,gBAAgB,CAAC,CAAC;IAEpE,MAAMuB,OAAO,GAAGR,OAAI,CAACD,OAAO,CAACA,OAAO,CAAC;IACrC,IAAIA,OAAO,KAAKS,OAAO,EAAE;MACvBJ,SAAS,GAAG,KAAK;MACjB;IACF;IACAL,OAAO,GAAGS,OAAO;EACnB;EAEA,OAAO;IAAEpB,QAAQ;IAAEe,WAAW;IAAED,GAAG;IAAEE;EAAU,CAAC;AAClD;AAAC"}
--- a/node_modules/@babel/core/lib/config/files/plugins.js
+++ b/node_modules/@babel/core/lib/config/files/plugins.js
@ -0,0 +1,232 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _async = require("../../gensync-utils/async");
+var _moduleTypes = require("./module-types");
+function _url() {
+  const data = require("url");
+  _url = function () {
+    return data;
+  };
+  return data;
+}
+var _importMetaResolve = require("./import-meta-resolve");
+function _module() {
+  const data = require("module");
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+const debug = _debug()("babel:config:loading:files:plugins");
+const EXACT_RE = /^module:/;
+const BABEL_PLUGIN_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-plugin-)/;
+const BABEL_PRESET_PREFIX_RE = /^(?!@|module:|[^/]+\/|babel-preset-)/;
+const BABEL_PLUGIN_ORG_RE = /^(@babel\/)(?!plugin-|[^/]+\/)/;
+const BABEL_PRESET_ORG_RE = /^(@babel\/)(?!preset-|[^/]+\/)/;
+const OTHER_PLUGIN_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-plugin(?:-|\/|$)|[^/]+\/)/;
+const OTHER_PRESET_ORG_RE = /^(@(?!babel\/)[^/]+\/)(?![^/]*babel-preset(?:-|\/|$)|[^/]+\/)/;
+const OTHER_ORG_DEFAULT_RE = /^(@(?!babel$)[^/]+)$/;
+function* resolvePlugin(name, dirname) {
+  return yield* resolveStandardizedName("plugin", name, dirname);
+}
+function* resolvePreset(name, dirname) {
+  return yield* resolveStandardizedName("preset", name, dirname);
+}
+function* loadPlugin(name, dirname) {
+  const filepath = yield* resolvePlugin(name, dirname);
+  const value = yield* requireModule("plugin", filepath);
+  debug("Loaded plugin %o from %o.", name, dirname);
+  return {
+    filepath,
+    value
+  };
+}
+function* loadPreset(name, dirname) {
+  const filepath = yield* resolvePreset(name, dirname);
+  const value = yield* requireModule("preset", filepath);
+  debug("Loaded preset %o from %o.", name, dirname);
+  return {
+    filepath,
+    value
+  };
+}
+function standardizeName(type, name) {
+  if (_path().isAbsolute(name)) return name;
+  const isPreset = type === "preset";
+  return name
+  .replace(isPreset ? BABEL_PRESET_PREFIX_RE : BABEL_PLUGIN_PREFIX_RE, `babel-${type}-`)
+  .replace(isPreset ? BABEL_PRESET_ORG_RE : BABEL_PLUGIN_ORG_RE, `$1${type}-`)
+  .replace(isPreset ? OTHER_PRESET_ORG_RE : OTHER_PLUGIN_ORG_RE, `$1babel-${type}-`)
+  .replace(OTHER_ORG_DEFAULT_RE, `$1/babel-${type}`)
+  .replace(EXACT_RE, "");
+}
+function* resolveAlternativesHelper(type, name) {
+  const standardizedName = standardizeName(type, name);
+  const {
+    error,
+    value
+  } = yield standardizedName;
+  if (!error) return value;
+
+  if (error.code !== "MODULE_NOT_FOUND") throw error;
+  if (standardizedName !== name && !(yield name).error) {
+    error.message += `\n- If you want to resolve "${name}", use "module:${name}"`;
+  }
+  if (!(yield standardizeName(type, "@babel/" + name)).error) {
+    error.message += `\n- Did you mean "@babel/${name}"?`;
+  }
+  const oppositeType = type === "preset" ? "plugin" : "preset";
+  if (!(yield standardizeName(oppositeType, name)).error) {
+    error.message += `\n- Did you accidentally pass a ${oppositeType} as a ${type}?`;
+  }
+  throw error;
+}
+function tryRequireResolve(id, {
+  paths: [dirname]
+}) {
+  try {
+    return {
+      error: null,
+      value: (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
+        paths: [b]
+      }, M = require("module")) => {
+        let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
+        if (f) return f;
+        f = new Error(`Cannot resolve module '${r}'`);
+        f.code = "MODULE_NOT_FOUND";
+        throw f;
+      })(id, {
+        paths: [dirname]
+      })
+    };
+  } catch (error) {
+    return {
+      error,
+      value: null
+    };
+  }
+}
+function tryImportMetaResolve(_x, _x2) {
+  return _tryImportMetaResolve.apply(this, arguments);
+}
+function _tryImportMetaResolve() {
+  _tryImportMetaResolve = _asyncToGenerator(function* (id, options) {
+    try {
+      return {
+        error: null,
+        value: yield (0, _importMetaResolve.default)(id, options)
+      };
+    } catch (error) {
+      return {
+        error,
+        value: null
+      };
+    }
+  });
+  return _tryImportMetaResolve.apply(this, arguments);
+}
+function resolveStandardizedNameForRequire(type, name, dirname) {
+  const it = resolveAlternativesHelper(type, name);
+  let res = it.next();
+  while (!res.done) {
+    res = it.next(tryRequireResolve(res.value, {
+      paths: [dirname]
+    }));
+  }
+  return res.value;
+}
+function resolveStandardizedNameForImport(_x3, _x4, _x5) {
+  return _resolveStandardizedNameForImport.apply(this, arguments);
+}
+function _resolveStandardizedNameForImport() {
+  _resolveStandardizedNameForImport = _asyncToGenerator(function* (type, name, dirname) {
+    const parentUrl = (0, _url().pathToFileURL)(_path().join(dirname, "./babel-virtual-resolve-base.js")).href;
+    const it = resolveAlternativesHelper(type, name);
+    let res = it.next();
+    while (!res.done) {
+      res = it.next(yield tryImportMetaResolve(res.value, parentUrl));
+    }
+    return (0, _url().fileURLToPath)(res.value);
+  });
+  return _resolveStandardizedNameForImport.apply(this, arguments);
+}
+const resolveStandardizedName = _gensync()({
+  sync(type, name, dirname = process.cwd()) {
+    return resolveStandardizedNameForRequire(type, name, dirname);
+  },
+  async(type, name, dirname = process.cwd()) {
+    return _asyncToGenerator(function* () {
+      if (!_moduleTypes.supportsESM) {
+        return resolveStandardizedNameForRequire(type, name, dirname);
+      }
+      try {
+        return yield resolveStandardizedNameForImport(type, name, dirname);
+      } catch (e) {
+        try {
+          return resolveStandardizedNameForRequire(type, name, dirname);
+        } catch (e2) {
+          if (e.type === "MODULE_NOT_FOUND") throw e;
+          if (e2.type === "MODULE_NOT_FOUND") throw e2;
+          throw e;
+        }
+      }
+    })();
+  }
+});
+{
+  var LOADING_MODULES = new Set();
+}
+function* requireModule(type, name) {
+  {
+    if (!(yield* (0, _async.isAsync)()) && LOADING_MODULES.has(name)) {
+      throw new Error(`Reentrant ${type} detected trying to load "${name}". This module is not ignored ` + "and is trying to load itself while compiling itself, leading to a dependency cycle. " + 'We recommend adding it to your "ignore" list in your babelrc, or to a .babelignore.');
+    }
+  }
+  try {
+    {
+      LOADING_MODULES.add(name);
+    }
+    return yield* (0, _moduleTypes.default)(name, `You appear to be using a native ECMAScript module ${type}, ` + "which is only supported when running Babel asynchronously.",
+    true);
+  } catch (err) {
+    err.message = `[BABEL]: ${err.message} (While processing: ${name})`;
+    throw err;
+  } finally {
+    {
+      LOADING_MODULES.delete(name);
+    }
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=plugins.js.map
--- a/node_modules/@babel/core/lib/config/files/plugins.js.map
+++ b/node_modules/@babel/core/lib/config/files/plugins.js.map
--- a/node_modules/@babel/core/lib/config/files/types.js
+++ b/node_modules/@babel/core/lib/config/files/types.js
@ -0,0 +1,3 @@
+0 && 0;
+
+//# sourceMappingURL=types.js.map
--- a/node_modules/@babel/core/lib/config/files/types.js.map
+++ b/node_modules/@babel/core/lib/config/files/types.js.map
@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../../src/config/files/types.ts"],"sourcesContent":["import type { InputOptions } from \"..\";\n\nexport type ConfigFile = {\n  filepath: string;\n  dirname: string;\n  options: InputOptions & { babel?: unknown };\n};\n\nexport type IgnoreFile = {\n  filepath: string;\n  dirname: string;\n  ignore: Array<RegExp>;\n};\n\nexport type RelativeConfig = {\n  // The actual config, either from package.json#babel, .babelrc, or\n  // .babelrc.js, if there was one.\n  config: ConfigFile | null;\n  // The .babelignore, if there was one.\n  ignore: IgnoreFile | null;\n};\n\nexport type FilePackageData = {\n  // The file in the package.\n  filepath: string;\n  // Any ancestor directories of the file that are within the package.\n  directories: Array<string>;\n  // The contents of the package.json. May not be found if the package just\n  // terminated at a node_modules folder without finding one.\n  pkg: ConfigFile | null;\n  // True if a package.json or node_modules folder was found while traversing\n  // the directory structure.\n  isPackage: boolean;\n};\n"],"mappings":""}
--- a/node_modules/@babel/core/lib/config/files/utils.js
+++ b/node_modules/@babel/core/lib/config/files/utils.js
@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeStaticFileCache = makeStaticFileCache;
+var _caching = require("../caching");
+var fs = require("../../gensync-utils/fs");
+function _fs2() {
+  const data = require("fs");
+  _fs2 = function () {
+    return data;
+  };
+  return data;
+}
+function makeStaticFileCache(fn) {
+  return (0, _caching.makeStrongCache)(function* (filepath, cache) {
+    const cached = cache.invalidate(() => fileMtime(filepath));
+    if (cached === null) {
+      return null;
+    }
+    return fn(filepath, yield* fs.readFile(filepath, "utf8"));
+  });
+}
+function fileMtime(filepath) {
+  if (!_fs2().existsSync(filepath)) return null;
+  try {
+    return +_fs2().statSync(filepath).mtime;
+  } catch (e) {
+    if (e.code !== "ENOENT" && e.code !== "ENOTDIR") throw e;
+  }
+  return null;
+}
+0 && 0;
+
+//# sourceMappingURL=utils.js.map
--- a/node_modules/@babel/core/lib/config/files/utils.js.map
+++ b/node_modules/@babel/core/lib/config/files/utils.js.map
@ -0,0 +1 @@
+{"version":3,"names":["makeStaticFileCache","fn","makeStrongCache","filepath","cache","cached","invalidate","fileMtime","fs","readFile","nodeFs","existsSync","statSync","mtime","e","code"],"sources":["../../../src/config/files/utils.ts"],"sourcesContent":["import type { Handler } from \"gensync\";\n\nimport { makeStrongCache } from \"../caching\";\nimport type { CacheConfigurator } from \"../caching\";\nimport * as fs from \"../../gensync-utils/fs\";\nimport nodeFs from \"fs\";\n\nexport function makeStaticFileCache<T>(\n  fn: (filepath: string, contents: string) => T,\n) {\n  return makeStrongCache(function* (\n    filepath: string,\n    cache: CacheConfigurator<void>,\n  ): Handler<null | T> {\n    const cached = cache.invalidate(() => fileMtime(filepath));\n\n    if (cached === null) {\n      return null;\n    }\n\n    return fn(filepath, yield* fs.readFile(filepath, \"utf8\"));\n  });\n}\n\nfunction fileMtime(filepath: string): number | null {\n  if (!nodeFs.existsSync(filepath)) return null;\n\n  try {\n    return +nodeFs.statSync(filepath).mtime;\n  } catch (e) {\n    if (e.code !== \"ENOENT\" && e.code !== \"ENOTDIR\") throw e;\n  }\n\n  return null;\n}\n"],"mappings":";;;;;;AAEA;AAEA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEO,SAASA,mBAAmB,CACjCC,EAA6C,EAC7C;EACA,OAAO,IAAAC,wBAAe,EAAC,WACrBC,QAAgB,EAChBC,KAA8B,EACX;IACnB,MAAMC,MAAM,GAAGD,KAAK,CAACE,UAAU,CAAC,MAAMC,SAAS,CAACJ,QAAQ,CAAC,CAAC;IAE1D,IAAIE,MAAM,KAAK,IAAI,EAAE;MACnB,OAAO,IAAI;IACb;IAEA,OAAOJ,EAAE,CAACE,QAAQ,EAAE,OAAOK,EAAE,CAACC,QAAQ,CAACN,QAAQ,EAAE,MAAM,CAAC,CAAC;EAC3D,CAAC,CAAC;AACJ;AAEA,SAASI,SAAS,CAACJ,QAAgB,EAAiB;EAClD,IAAI,CAACO,MAAM,CAACC,UAAU,CAACR,QAAQ,CAAC,EAAE,OAAO,IAAI;EAE7C,IAAI;IACF,OAAO,CAACO,MAAM,CAACE,QAAQ,CAACT,QAAQ,CAAC,CAACU,KAAK;EACzC,CAAC,CAAC,OAAOC,CAAC,EAAE;IACV,IAAIA,CAAC,CAACC,IAAI,KAAK,QAAQ,IAAID,CAAC,CAACC,IAAI,KAAK,SAAS,EAAE,MAAMD,CAAC;EAC1D;EAEA,OAAO,IAAI;AACb;AAAC"}
--- a/node_modules/@babel/core/lib/config/full.js
+++ b/node_modules/@babel/core/lib/config/full.js
@ -0,0 +1,317 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _async = require("../gensync-utils/async");
+var _util = require("./util");
+var context = require("../index");
+var _plugin = require("./plugin");
+var _item = require("./item");
+var _configChain = require("./config-chain");
+var _deepArray = require("./helpers/deep-array");
+function _traverse() {
+  const data = require("@babel/traverse");
+  _traverse = function () {
+    return data;
+  };
+  return data;
+}
+var _caching = require("./caching");
+var _options = require("./validation/options");
+var _plugins = require("./validation/plugins");
+var _configApi = require("./helpers/config-api");
+var _partial = require("./partial");
+var _configError = require("../errors/config-error");
+var _default = _gensync()(function* loadFullConfig(inputOpts) {
+  var _opts$assumptions;
+  const result = yield* (0, _partial.default)(inputOpts);
+  if (!result) {
+    return null;
+  }
+  const {
+    options,
+    context,
+    fileHandling
+  } = result;
+  if (fileHandling === "ignored") {
+    return null;
+  }
+  const optionDefaults = {};
+  const {
+    plugins,
+    presets
+  } = options;
+  if (!plugins || !presets) {
+    throw new Error("Assertion failure - plugins and presets exist");
+  }
+  const presetContext = Object.assign({}, context, {
+    targets: options.targets
+  });
+  const toDescriptor = item => {
+    const desc = (0, _item.getItemDescriptor)(item);
+    if (!desc) {
+      throw new Error("Assertion failure - must be config item");
+    }
+    return desc;
+  };
+  const presetsDescriptors = presets.map(toDescriptor);
+  const initialPluginsDescriptors = plugins.map(toDescriptor);
+  const pluginDescriptorsByPass = [[]];
+  const passes = [];
+  const externalDependencies = [];
+  const ignored = yield* enhanceError(context, function* recursePresetDescriptors(rawPresets, pluginDescriptorsPass) {
+    const presets = [];
+    for (let i = 0; i < rawPresets.length; i++) {
+      const descriptor = rawPresets[i];
+      if (descriptor.options !== false) {
+        try {
+          var preset = yield* loadPresetDescriptor(descriptor, presetContext);
+        } catch (e) {
+          if (e.code === "BABEL_UNKNOWN_OPTION") {
+            (0, _options.checkNoUnwrappedItemOptionPairs)(rawPresets, i, "preset", e);
+          }
+          throw e;
+        }
+        externalDependencies.push(preset.externalDependencies);
+
+        if (descriptor.ownPass) {
+          presets.push({
+            preset: preset.chain,
+            pass: []
+          });
+        } else {
+          presets.unshift({
+            preset: preset.chain,
+            pass: pluginDescriptorsPass
+          });
+        }
+      }
+    }
+
+    if (presets.length > 0) {
+      pluginDescriptorsByPass.splice(1, 0, ...presets.map(o => o.pass).filter(p => p !== pluginDescriptorsPass));
+      for (const {
+        preset,
+        pass
+      } of presets) {
+        if (!preset) return true;
+        pass.push(...preset.plugins);
+        const ignored = yield* recursePresetDescriptors(preset.presets, pass);
+        if (ignored) return true;
+        preset.options.forEach(opts => {
+          (0, _util.mergeOptions)(optionDefaults, opts);
+        });
+      }
+    }
+  })(presetsDescriptors, pluginDescriptorsByPass[0]);
+  if (ignored) return null;
+  const opts = optionDefaults;
+  (0, _util.mergeOptions)(opts, options);
+  const pluginContext = Object.assign({}, presetContext, {
+    assumptions: (_opts$assumptions = opts.assumptions) != null ? _opts$assumptions : {}
+  });
+  yield* enhanceError(context, function* loadPluginDescriptors() {
+    pluginDescriptorsByPass[0].unshift(...initialPluginsDescriptors);
+    for (const descs of pluginDescriptorsByPass) {
+      const pass = [];
+      passes.push(pass);
+      for (let i = 0; i < descs.length; i++) {
+        const descriptor = descs[i];
+        if (descriptor.options !== false) {
+          try {
+            var plugin = yield* loadPluginDescriptor(descriptor, pluginContext);
+          } catch (e) {
+            if (e.code === "BABEL_UNKNOWN_PLUGIN_PROPERTY") {
+              (0, _options.checkNoUnwrappedItemOptionPairs)(descs, i, "plugin", e);
+            }
+            throw e;
+          }
+          pass.push(plugin);
+          externalDependencies.push(plugin.externalDependencies);
+        }
+      }
+    }
+  })();
+  opts.plugins = passes[0];
+  opts.presets = passes.slice(1).filter(plugins => plugins.length > 0).map(plugins => ({
+    plugins
+  }));
+  opts.passPerPreset = opts.presets.length > 0;
+  return {
+    options: opts,
+    passes: passes,
+    externalDependencies: (0, _deepArray.finalize)(externalDependencies)
+  };
+});
+exports.default = _default;
+function enhanceError(context, fn) {
+  return function* (arg1, arg2) {
+    try {
+      return yield* fn(arg1, arg2);
+    } catch (e) {
+      if (!/^\[BABEL\]/.test(e.message)) {
+        var _context$filename;
+        e.message = `[BABEL] ${(_context$filename = context.filename) != null ? _context$filename : "unknown file"}: ${e.message}`;
+      }
+      throw e;
+    }
+  };
+}
+
+const makeDescriptorLoader = apiFactory => (0, _caching.makeWeakCache)(function* ({
+  value,
+  options,
+  dirname,
+  alias
+}, cache) {
+  if (options === false) throw new Error("Assertion failure");
+  options = options || {};
+  const externalDependencies = [];
+  let item = value;
+  if (typeof value === "function") {
+    const factory = (0, _async.maybeAsync)(value, `You appear to be using an async plugin/preset, but Babel has been called synchronously`);
+    const api = Object.assign({}, context, apiFactory(cache, externalDependencies));
+    try {
+      item = yield* factory(api, options, dirname);
+    } catch (e) {
+      if (alias) {
+        e.message += ` (While processing: ${JSON.stringify(alias)})`;
+      }
+      throw e;
+    }
+  }
+  if (!item || typeof item !== "object") {
+    throw new Error("Plugin/Preset did not return an object.");
+  }
+  if ((0, _async.isThenable)(item)) {
+    yield* [];
+    throw new Error(`You appear to be using a promise as a plugin, ` + `which your current version of Babel does not support. ` + `If you're using a published plugin, ` + `you may need to upgrade your @babel/core version. ` + `As an alternative, you can prefix the promise with "await". ` + `(While processing: ${JSON.stringify(alias)})`);
+  }
+  if (externalDependencies.length > 0 && (!cache.configured() || cache.mode() === "forever")) {
+    let error = `A plugin/preset has external untracked dependencies ` + `(${externalDependencies[0]}), but the cache `;
+    if (!cache.configured()) {
+      error += `has not been configured to be invalidated when the external dependencies change. `;
+    } else {
+      error += ` has been configured to never be invalidated. `;
+    }
+    error += `Plugins/presets should configure their cache to be invalidated when the external ` + `dependencies change, for example using \`api.cache.invalidate(() => ` + `statSync(filepath).mtimeMs)\` or \`api.cache.never()\`\n` + `(While processing: ${JSON.stringify(alias)})`;
+    throw new Error(error);
+  }
+  return {
+    value: item,
+    options,
+    dirname,
+    alias,
+    externalDependencies: (0, _deepArray.finalize)(externalDependencies)
+  };
+});
+const pluginDescriptorLoader = makeDescriptorLoader(_configApi.makePluginAPI);
+const presetDescriptorLoader = makeDescriptorLoader(_configApi.makePresetAPI);
+const instantiatePlugin = (0, _caching.makeWeakCache)(function* ({
+  value,
+  options,
+  dirname,
+  alias,
+  externalDependencies
+}, cache) {
+  const pluginObj = (0, _plugins.validatePluginObject)(value);
+  const plugin = Object.assign({}, pluginObj);
+  if (plugin.visitor) {
+    plugin.visitor = _traverse().default.explode(Object.assign({}, plugin.visitor));
+  }
+  if (plugin.inherits) {
+    const inheritsDescriptor = {
+      name: undefined,
+      alias: `${alias}$inherits`,
+      value: plugin.inherits,
+      options,
+      dirname
+    };
+    const inherits = yield* (0, _async.forwardAsync)(loadPluginDescriptor, run => {
+      return cache.invalidate(data => run(inheritsDescriptor, data));
+    });
+    plugin.pre = chain(inherits.pre, plugin.pre);
+    plugin.post = chain(inherits.post, plugin.post);
+    plugin.manipulateOptions = chain(inherits.manipulateOptions, plugin.manipulateOptions);
+    plugin.visitor = _traverse().default.visitors.merge([inherits.visitor || {}, plugin.visitor || {}]);
+    if (inherits.externalDependencies.length > 0) {
+      if (externalDependencies.length === 0) {
+        externalDependencies = inherits.externalDependencies;
+      } else {
+        externalDependencies = (0, _deepArray.finalize)([externalDependencies, inherits.externalDependencies]);
+      }
+    }
+  }
+  return new _plugin.default(plugin, options, alias, externalDependencies);
+});
+
+function* loadPluginDescriptor(descriptor, context) {
+  if (descriptor.value instanceof _plugin.default) {
+    if (descriptor.options) {
+      throw new Error("Passed options to an existing Plugin instance will not work.");
+    }
+    return descriptor.value;
+  }
+  return yield* instantiatePlugin(yield* pluginDescriptorLoader(descriptor, context), context);
+}
+const needsFilename = val => val && typeof val !== "function";
+const validateIfOptionNeedsFilename = (options, descriptor) => {
+  if (needsFilename(options.test) || needsFilename(options.include) || needsFilename(options.exclude)) {
+    const formattedPresetName = descriptor.name ? `"${descriptor.name}"` : "/* your preset */";
+    throw new _configError.default([`Preset ${formattedPresetName} requires a filename to be set when babel is called directly,`, `\`\`\``, `babel.transformSync(code, { filename: 'file.ts', presets: [${formattedPresetName}] });`, `\`\`\``, `See https://babeljs.io/docs/en/options#filename for more information.`].join("\n"));
+  }
+};
+const validatePreset = (preset, context, descriptor) => {
+  if (!context.filename) {
+    const {
+      options
+    } = preset;
+    validateIfOptionNeedsFilename(options, descriptor);
+    if (options.overrides) {
+      options.overrides.forEach(overrideOptions => validateIfOptionNeedsFilename(overrideOptions, descriptor));
+    }
+  }
+};
+const instantiatePreset = (0, _caching.makeWeakCacheSync)(({
+  value,
+  dirname,
+  alias,
+  externalDependencies
+}) => {
+  return {
+    options: (0, _options.validate)("preset", value),
+    alias,
+    dirname,
+    externalDependencies
+  };
+});
+
+function* loadPresetDescriptor(descriptor, context) {
+  const preset = instantiatePreset(yield* presetDescriptorLoader(descriptor, context));
+  validatePreset(preset, context, descriptor);
+  return {
+    chain: yield* (0, _configChain.buildPresetChain)(preset, context),
+    externalDependencies: preset.externalDependencies
+  };
+}
+function chain(a, b) {
+  const fns = [a, b].filter(Boolean);
+  if (fns.length <= 1) return fns[0];
+  return function (...args) {
+    for (const fn of fns) {
+      fn.apply(this, args);
+    }
+  };
+}
+0 && 0;
+
+//# sourceMappingURL=full.js.map
--- a/node_modules/@babel/core/lib/config/full.js.map
+++ b/node_modules/@babel/core/lib/config/full.js.map
--- a/node_modules/@babel/core/lib/config/helpers/config-api.js
+++ b/node_modules/@babel/core/lib/config/helpers/config-api.js
@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeConfigAPI = makeConfigAPI;
+exports.makePluginAPI = makePluginAPI;
+exports.makePresetAPI = makePresetAPI;
+function _semver() {
+  const data = require("semver");
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+var _ = require("../../");
+var _caching = require("../caching");
+function makeConfigAPI(cache) {
+  const env = value => cache.using(data => {
+    if (typeof value === "undefined") return data.envName;
+    if (typeof value === "function") {
+      return (0, _caching.assertSimpleType)(value(data.envName));
+    }
+    return (Array.isArray(value) ? value : [value]).some(entry => {
+      if (typeof entry !== "string") {
+        throw new Error("Unexpected non-string value");
+      }
+      return entry === data.envName;
+    });
+  });
+  const caller = cb => cache.using(data => (0, _caching.assertSimpleType)(cb(data.caller)));
+  return {
+    version: _.version,
+    cache: cache.simple(),
+    env,
+    async: () => false,
+    caller,
+    assertVersion
+  };
+}
+function makePresetAPI(cache, externalDependencies) {
+  const targets = () =>
+  JSON.parse(cache.using(data => JSON.stringify(data.targets)));
+  const addExternalDependency = ref => {
+    externalDependencies.push(ref);
+  };
+  return Object.assign({}, makeConfigAPI(cache), {
+    targets,
+    addExternalDependency
+  });
+}
+function makePluginAPI(cache, externalDependencies) {
+  const assumption = name => cache.using(data => data.assumptions[name]);
+  return Object.assign({}, makePresetAPI(cache, externalDependencies), {
+    assumption
+  });
+}
+function assertVersion(range) {
+  if (typeof range === "number") {
+    if (!Number.isInteger(range)) {
+      throw new Error("Expected string or integer value.");
+    }
+    range = `^${range}.0.0-0`;
+  }
+  if (typeof range !== "string") {
+    throw new Error("Expected string or integer value.");
+  }
+  if (_semver().satisfies(_.version, range)) return;
+  const limit = Error.stackTraceLimit;
+  if (typeof limit === "number" && limit < 25) {
+    Error.stackTraceLimit = 25;
+  }
+  const err = new Error(`Requires Babel "${range}", but was loaded with "${_.version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
+  if (typeof limit === "number") {
+    Error.stackTraceLimit = limit;
+  }
+  throw Object.assign(err, {
+    code: "BABEL_VERSION_UNSUPPORTED",
+    version: _.version,
+    range
+  });
+}
+0 && 0;
+
+//# sourceMappingURL=config-api.js.map
--- a/node_modules/@babel/core/lib/config/helpers/config-api.js.map
+++ b/node_modules/@babel/core/lib/config/helpers/config-api.js.map
--- a/node_modules/@babel/core/lib/config/helpers/deep-array.js
+++ b/node_modules/@babel/core/lib/config/helpers/deep-array.js
@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.finalize = finalize;
+exports.flattenToSet = flattenToSet;
+
+function finalize(deepArr) {
+  return Object.freeze(deepArr);
+}
+function flattenToSet(arr) {
+  const result = new Set();
+  const stack = [arr];
+  while (stack.length > 0) {
+    for (const el of stack.pop()) {
+      if (Array.isArray(el)) stack.push(el);else result.add(el);
+    }
+  }
+  return result;
+}
+0 && 0;
+
+//# sourceMappingURL=deep-array.js.map
--- a/node_modules/@babel/core/lib/config/helpers/deep-array.js.map
+++ b/node_modules/@babel/core/lib/config/helpers/deep-array.js.map
@ -0,0 +1 @@
+{"version":3,"names":["finalize","deepArr","Object","freeze","flattenToSet","arr","result","Set","stack","length","el","pop","Array","isArray","push","add"],"sources":["../../../src/config/helpers/deep-array.ts"],"sourcesContent":["export type DeepArray<T> = Array<T | ReadonlyDeepArray<T>>;\n\n// Just to make sure that DeepArray<T> is not assignable to ReadonlyDeepArray<T>\ndeclare const __marker: unique symbol;\nexport type ReadonlyDeepArray<T> = ReadonlyArray<T | ReadonlyDeepArray<T>> & {\n  [__marker]: true;\n};\n\nexport function finalize<T>(deepArr: DeepArray<T>): ReadonlyDeepArray<T> {\n  return Object.freeze(deepArr) as ReadonlyDeepArray<T>;\n}\n\nexport function flattenToSet<T extends string>(\n  arr: ReadonlyDeepArray<T>,\n): Set<T> {\n  const result = new Set<T>();\n  const stack = [arr];\n  while (stack.length > 0) {\n    for (const el of stack.pop()) {\n      if (Array.isArray(el)) stack.push(el as ReadonlyDeepArray<T>);\n      else result.add(el as T);\n    }\n  }\n  return result;\n}\n"],"mappings":";;;;;;;;AAQO,SAASA,QAAQ,CAAIC,OAAqB,EAAwB;EACvE,OAAOC,MAAM,CAACC,MAAM,CAACF,OAAO,CAAC;AAC/B;AAEO,SAASG,YAAY,CAC1BC,GAAyB,EACjB;EACR,MAAMC,MAAM,GAAG,IAAIC,GAAG,EAAK;EAC3B,MAAMC,KAAK,GAAG,CAACH,GAAG,CAAC;EACnB,OAAOG,KAAK,CAACC,MAAM,GAAG,CAAC,EAAE;IACvB,KAAK,MAAMC,EAAE,IAAIF,KAAK,CAACG,GAAG,EAAE,EAAE;MAC5B,IAAIC,KAAK,CAACC,OAAO,CAACH,EAAE,CAAC,EAAEF,KAAK,CAACM,IAAI,CAACJ,EAAE,CAAyB,CAAC,KACzDJ,MAAM,CAACS,GAAG,CAACL,EAAE,CAAM;IAC1B;EACF;EACA,OAAOJ,MAAM;AACf;AAAC"}
--- a/node_modules/@babel/core/lib/config/helpers/environment.js
+++ b/node_modules/@babel/core/lib/config/helpers/environment.js
@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEnv = getEnv;
+function getEnv(defaultValue = "development") {
+  return process.env.BABEL_ENV || process.env.NODE_ENV || defaultValue;
+}
+0 && 0;
+
+//# sourceMappingURL=environment.js.map
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`module.exports = require("./data/corejs2-built-ins.json");`
				`@ -0,0 +1 @@`
				`module.exports = require("./data/native-modules.json");`
				`@ -0,0 +1 @@`
				`module.exports = require("./data/overlapping-plugins.json");`
				`@ -0,0 +1 @@`
				`module.exports = require("./data/plugin-bugfixes.json");`
				`@ -0,0 +1 @@`
				{"version":3,"names":[],"sources":["../../src/config/cache-contexts.ts"],"sourcesContent":["import type { Targets } from \"@babel/helper-compilation-targets\";\n\nimport type { ConfigContext } from \"./config-chain\";\nimport type { CallerMetadata } from \"./validation/options\";\n\nexport type { ConfigContext as FullConfig };\n\nexport type FullPreset = {\n targets: Targets;\n} & ConfigContext;\nexport type FullPlugin = {\n assumptions: { [name: string]: boolean };\n} & FullPreset;\n\n// Context not including filename since it is used in places that cannot\n// process 'ignore'/'only' and other filename-based logic.\nexport type SimpleConfig = {\n envName: string;\n caller: CallerMetadata \| undefined;\n};\nexport type SimplePreset = {\n targets: Targets;\n} & SimpleConfig;\nexport type SimplePlugin = {\n assumptions: {\n [name: string]: boolean;\n };\n} & SimplePreset;\n"],"mappings":""}
				`@ -0,0 +1 @@`
				{"version":3,"names":["import_","require","importMetaResolveP","process","execArgv","includes","then","m","default","polyfill","Promise","resolve","specifier","parent"],"sources":["../../../src/config/files/import-meta-resolve.ts"],"sourcesContent":["import { createRequire } from \"module\";\nimport { resolve as polyfill } from \"../../vendor/import-meta-resolve\";\n\nconst require = createRequire(import.meta.url);\n\nlet import_;\ntry {\n // Node < 13.3 doesn't support import() syntax.\n import_ = require(\"./import.cjs\");\n} catch {}\n\n// import.meta.resolve is only available in ESM, but this file is compiled to CJS.\n// We can extract it using dynamic import.\nconst importMetaResolveP: Promise<ImportMeta[\"resolve\"]> =\n import_ &&\n // Due to a Node.js/V8 bug (https://github.com/nodejs/node/issues/35889), we cannot\n // use always dynamic import because it segfaults when running in a Node.js `vm` context,\n // which is used by the default Jest environment and by webpack-cli.\n //\n // However, import.meta.resolve is experimental and only enabled when Node.js is run\n // with the `--experimental-import-meta-resolve` flag: we can avoid calling import()\n // when that flag is not enabled, so that the default behavior never segfaults.\n //\n // Hopefully, before Node.js unflags import.meta.resolve, either:\n // - we will move to ESM, so that we have direct access to import.meta.resolve, or\n // - the V8 bug will be fixed so that we can safely use dynamic import by default.\n //\n // I (@nicolo-ribaudo) am really anoyed by this bug, because there is no known\n // work-around other than \"don't use dynamic import if you are running in a `vm` context\",\n // but there is no reliable way to detect it (you cannot try/catch segfaults).\n //\n // This is the only place where we need to use dynamic import because we need to access\n // an ES module. All the other places will first try using require() and then, if\n // it throws because it's a module, will fallback to import().\n process.execArgv.includes(\"--experimental-import-meta-resolve\")\n ? import_(\"data:text/javascript,export default import.meta.resolve\").then(\n (m: { default: ImportMeta[\"resolve\"] \| undefined }) =>\n m.default \|\| polyfill,\n () => polyfill,\n )\n : Promise.resolve(polyfill);\n\nexport default async function resolve(\n specifier: Parameters<ImportMeta[\"resolve\"]>[0],\n parent?: Parameters<ImportMeta[\"resolve\"]>[1],\n): ReturnType<ImportMeta[\"resolve\"]> {\n return (await importMetaResolveP)(specifier, parent);\n}\n"],"mappings":";;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;AAAuE;AAAA;AAIvE,IAAIA,OAAO;AACX,IAAI;EAEFA,OAAO,GAAGC,OAAO,CAAC,cAAc,CAAC;AACnC,CAAC,CAAC,gBAAM,CAAC;;AAIT,MAAMC,kBAAkD,GACtDF,OAAO;AAoBPG,OAAO,CAACC,QAAQ,CAACC,QAAQ,CAAC,oCAAoC,CAAC,GAC3DL,OAAO,CAAC,yDAAyD,CAAC,CAACM,IAAI,CACpEC,CAAiD,IAChDA,CAAC,CAACC,OAAO,IAAIC,0BAAQ,EACvB,MAAMA,0BAAQ,CACf,GACDC,OAAO,CAACC,OAAO,CAACF,0BAAQ,CAAC;AAAC,SAEFE,OAAO;EAAA;AAAA;AAAA;EAAA,6BAAtB,WACbC,SAA+C,EAC/CC,MAA6C,EACV;IACnC,OAAO,OAAOX,kBAAkB,EAAEU,SAAS,EAAEC,MAAM,CAAC;EACtD,CAAC;EAAA;AAAA;AAAA"}
				`@ -0,0 +1 @@`
				{"version":3,"names":["module","exports","import_","filepath"],"sources":["../../../src/config/files/import.cjs"],"sourcesContent":["// We keep this in a separate file so that in older node versions, where\n// import() isn't supported, we can try/catch around the require() call\n// when loading this file.\n\nmodule.exports = function import_(filepath) {\n return import(filepath);\n};\n"],"mappings":";;AAIAA,MAAM,CAACC,OAAO,GAAG,SAASC,OAAO,CAACC,QAAQ,EAAE;EAC1C,OAAO,MAAM,CAACA,QAAQ,CAAC;AACzB,CAAC;AAAC"}
				`@ -0,0 +1 @@`
				{"version":3,"names":["findConfigUpwards","rootDir","findPackageData","filepath","directories","pkg","isPackage","findRelativeConfig","pkgData","envName","caller","config","ignore","findRootConfig","dirname","loadConfig","name","Error","resolveShowConfigPath","ROOT_CONFIG_FILENAMES","resolvePlugin","resolvePreset","loadPlugin","loadPreset"],"sources":["../../../src/config/files/index-browser.ts"],"sourcesContent":["import type { Handler } from \"gensync\";\n\nimport type {\n ConfigFile,\n IgnoreFile,\n RelativeConfig,\n FilePackageData,\n} from \"./types\";\n\nimport type { CallerMetadata } from \"../validation/options\";\n\nexport type { ConfigFile, IgnoreFile, RelativeConfig, FilePackageData };\n\nexport function findConfigUpwards(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n rootDir: string,\n): string \| null {\n return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* findPackageData(filepath: string): Handler<FilePackageData> {\n return {\n filepath,\n directories: [],\n pkg: null,\n isPackage: false,\n };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRelativeConfig(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n pkgData: FilePackageData,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n envName: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n caller: CallerMetadata \| undefined,\n): Handler<RelativeConfig> {\n return { config: null, ignore: null };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRootConfig(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n dirname: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n envName: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n caller: CallerMetadata \| undefined,\n): Handler<ConfigFile \| null> {\n return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* loadConfig(\n name: string,\n dirname: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n envName: string,\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n caller: CallerMetadata \| undefined,\n): Handler<ConfigFile> {\n throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);\n}\n\n// eslint-disable-next-line require-yield\nexport function* resolveShowConfigPath(\n // eslint-disable-next-line @typescript-eslint/no-unused-vars\n dirname: string,\n): Handler<string \| null> {\n return null;\n}\n\nexport const ROOT_CONFIG_FILENAMES: string[] = [];\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePlugin(name: string, dirname: string): string \| null {\n return null;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePreset(name: string, dirname: string): string \| null {\n return null;\n}\n\nexport function loadPlugin(\n name: string,\n dirname: string,\n): Handler<{\n filepath: string;\n value: unknown;\n}> {\n throw new Error(\n `Cannot load plugin ${name} relative to ${dirname} in a browser`,\n );\n}\n\nexport function loadPreset(\n name: string,\n dirname: string,\n): Handler<{\n filepath: string;\n value: unknown;\n}> {\n throw new Error(\n `Cannot load preset ${name} relative to ${dirname} in a browser`,\n );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAaO,SAASA,iBAAiB;AAE/BC,OAAe,EACA;EACf,OAAO,IAAI;AACb;;AAGO,UAAUC,eAAe,CAACC,QAAgB,EAA4B;EAC3E,OAAO;IACLA,QAAQ;IACRC,WAAW,EAAE,EAAE;IACfC,GAAG,EAAE,IAAI;IACTC,SAAS,EAAE;EACb,CAAC;AACH;;AAGO,UAAUC,kBAAkB;AAEjCC,OAAwB;AAExBC,OAAe;AAEfC,MAAkC,EACT;EACzB,OAAO;IAAEC,MAAM,EAAE,IAAI;IAAEC,MAAM,EAAE;EAAK,CAAC;AACvC;;AAGO,UAAUC,cAAc;AAE7BC,OAAe;AAEfL,OAAe;AAEfC,MAAkC,EACN;EAC5B,OAAO,IAAI;AACb;;AAGO,UAAUK,UAAU,CACzBC,IAAY,EACZF,OAAe;AAEfL,OAAe;AAEfC,MAAkC,EACb;EACrB,MAAM,IAAIO,KAAK,CAAE,eAAcD,IAAK,gBAAeF,OAAQ,eAAc,CAAC;AAC5E;;AAGO,UAAUI,qBAAqB;AAEpCJ,OAAe,EACS;EACxB,OAAO,IAAI;AACb;AAEO,MAAMK,qBAA+B,GAAG,EAAE;;AAAC;AAG3C,SAASC,aAAa,CAACJ,IAAY,EAAEF,OAAe,EAAiB;EAC1E,OAAO,IAAI;AACb;;AAGO,SAASO,aAAa,CAACL,IAAY,EAAEF,OAAe,EAAiB;EAC1E,OAAO,IAAI;AACb;AAEO,SAASQ,UAAU,CACxBN,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACZ,sBAAqBD,IAAK,gBAAeF,OAAQ,eAAc,CACjE;AACH;AAEO,SAASS,UAAU,CACxBP,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACZ,sBAAqBD,IAAK,gBAAeF,OAAQ,eAAc,CACjE;AACH;AAAC"}
				`@ -0,0 +1 @@`
				{"version":3,"names":["resolvePlugin","gensync","plugins","sync","resolvePreset"],"sources":["../../../src/config/files/index.ts"],"sourcesContent":["type indexBrowserType = typeof import(\"./index-browser\");\ntype indexType = typeof import(\"./index\");\n\n// Kind of gross, but essentially asserting that the exports of this module are the same as the\n// exports of index-browser, since this file may be replaced at bundle time with index-browser.\n({} as any as indexBrowserType as indexType);\n\nexport { findPackageData } from \"./package\";\n\nexport {\n findConfigUpwards,\n findRelativeConfig,\n findRootConfig,\n loadConfig,\n resolveShowConfigPath,\n ROOT_CONFIG_FILENAMES,\n} from \"./configuration\";\nexport type {\n ConfigFile,\n IgnoreFile,\n RelativeConfig,\n FilePackageData,\n} from \"./types\";\nexport { loadPlugin, loadPreset } from \"./plugins\";\n\nimport gensync from \"gensync\";\nimport * as plugins from \"./plugins\";\n\nexport const resolvePlugin = gensync(plugins.resolvePlugin).sync;\nexport const resolvePreset = gensync(plugins.resolvePreset).sync;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA;AAEA;AAcA;AAEA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AApBA,CAAC,CAAC,CAAC;AAuBI,MAAMA,aAAa,GAAGC,UAAO,CAACC,OAAO,CAACF,aAAa,CAAC,CAACG,IAAI;AAAC;AAC1D,MAAMC,aAAa,GAAGH,UAAO,CAACC,OAAO,CAACE,aAAa,CAAC,CAACD,IAAI;AAAC;AAAA"}
				`@ -0,0 +1 @@`
				{"version":3,"names":["PACKAGE_FILENAME","readConfigPackage","makeStaticFileCache","filepath","content","options","JSON","parse","err","ConfigError","message","Error","Array","isArray","dirname","path","findPackageData","pkg","directories","isPackage","basename","push","join","nextLoc"],"sources":["../../../src/config/files/package.ts"],"sourcesContent":["import path from \"path\";\nimport type { Handler } from \"gensync\";\nimport { makeStaticFileCache } from \"./utils\";\n\nimport type { ConfigFile, FilePackageData } from \"./types\";\n\nimport ConfigError from \"../../errors/config-error\";\n\nconst PACKAGE_FILENAME = \"package.json\";\n\nconst readConfigPackage = makeStaticFileCache(\n (filepath, content): ConfigFile => {\n let options;\n try {\n options = JSON.parse(content) as unknown;\n } catch (err) {\n throw new ConfigError(\n `Error while parsing JSON - ${err.message}`,\n filepath,\n );\n }\n\n if (!options) throw new Error(`${filepath}: No config detected`);\n\n if (typeof options !== \"object\") {\n throw new ConfigError(\n `Config returned typeof ${typeof options}`,\n filepath,\n );\n }\n if (Array.isArray(options)) {\n throw new ConfigError(`Expected config object but found array`, filepath);\n }\n\n return {\n filepath,\n dirname: path.dirname(filepath),\n options,\n };\n },\n);\n\n/*\n Find metadata about the package that this file is inside of. Resolution\n * of Babel's config requires general package information to decide when to\n * search for .babelrc files\n /\nexport function findPackageData(filepath: string): Handler<FilePackageData> {\n let pkg = null;\n const directories = [];\n let isPackage = true;\n\n let dirname = path.dirname(filepath);\n while (!pkg && path.basename(dirname) !== \"node_modules\") {\n directories.push(dirname);\n\n pkg = yield* readConfigPackage(path.join(dirname, PACKAGE_FILENAME));\n\n const nextLoc = path.dirname(dirname);\n if (dirname === nextLoc) {\n isPackage = false;\n break;\n }\n dirname = nextLoc;\n }\n\n return { filepath, directories, pkg, isPackage };\n}\n"],"mappings":";;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEA;AAIA;AAEA,MAAMA,gBAAgB,GAAG,cAAc;AAEvC,MAAMC,iBAAiB,GAAG,IAAAC,0BAAmB,EAC3C,CAACC,QAAQ,EAAEC,OAAO,KAAiB;EACjC,IAAIC,OAAO;EACX,IAAI;IACFA,OAAO,GAAGC,IAAI,CAACC,KAAK,CAACH,OAAO,CAAY;EAC1C,CAAC,CAAC,OAAOI,GAAG,EAAE;IACZ,MAAM,IAAIC,oBAAW,CAClB,8BAA6BD,GAAG,CAACE,OAAQ,EAAC,EAC3CP,QAAQ,CACT;EACH;EAEA,IAAI,CAACE,OAAO,EAAE,MAAM,IAAIM,KAAK,CAAE,GAAER,QAAS,sBAAqB,CAAC;EAEhE,IAAI,OAAOE,OAAO,KAAK,QAAQ,EAAE;IAC/B,MAAM,IAAII,oBAAW,CAClB,0BAAyB,OAAOJ,OAAQ,EAAC,EAC1CF,QAAQ,CACT;EACH;EACA,IAAIS,KAAK,CAACC,OAAO,CAACR,OAAO,CAAC,EAAE;IAC1B,MAAM,IAAII,oBAAW,CAAE,wCAAuC,EAAEN,QAAQ,CAAC;EAC3E;EAEA,OAAO;IACLA,QAAQ;IACRW,OAAO,EAAEC,OAAI,CAACD,OAAO,CAACX,QAAQ,CAAC;IAC/BE;EACF,CAAC;AACH,CAAC,CACF;;AAOM,UAAUW,eAAe,CAACb,QAAgB,EAA4B;EAC3E,IAAIc,GAAG,GAAG,IAAI;EACd,MAAMC,WAAW,GAAG,EAAE;EACtB,IAAIC,SAAS,GAAG,IAAI;EAEpB,IAAIL,OAAO,GAAGC,OAAI,CAACD,OAAO,CAACX,QAAQ,CAAC;EACpC,OAAO,CAACc,GAAG,IAAIF,OAAI,CAACK,QAAQ,CAACN,OAAO,CAAC,KAAK,cAAc,EAAE;IACxDI,WAAW,CAACG,IAAI,CAACP,OAAO,CAAC;IAEzBG,GAAG,GAAG,OAAOhB,iBAAiB,CAACc,OAAI,CAACO,IAAI,CAACR,OAAO,EAAEd,gBAAgB,CAAC,CAAC;IAEpE,MAAMuB,OAAO,GAAGR,OAAI,CAACD,OAAO,CAACA,OAAO,CAAC;IACrC,IAAIA,OAAO,KAAKS,OAAO,EAAE;MACvBJ,SAAS,GAAG,KAAK;MACjB;IACF;IACAL,OAAO,GAAGS,OAAO;EACnB;EAEA,OAAO;IAAEpB,QAAQ;IAAEe,WAAW;IAAED,GAAG;IAAEE;EAAU,CAAC;AAClD;AAAC"}