1 жил өмнө · 2935effa2e
--- a/day37/asset/img01.gif
+++ b/day37/asset/img01.gif
--- a/day37/dist/2d1cdbe9941b22f430ef.gif
+++ b/day37/dist/2d1cdbe9941b22f430ef.gif
--- a/day37/dist/index.html
+++ b/day37/dist/index.html
@@ -0,0 +1,12 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
			
 
				+    <title>Document</title>
			
 
				+    <script defer src="./main.js"></script>
			
 
				+</head>
			
 
				+<body>
			
 
				+    
			
 
				+</body>
			
 
				+</html>
			
--- a/day37/dist/main.js
+++ b/day37/dist/main.js
--- a/day37/hello/fileMode.js
+++ b/day37/hello/fileMode.js
@@ -0,0 +1 @@
 
				+console.log("a1页面"),(()=>{"use strict";sayHi()})();
			
--- a/day37/node_modules/.bin/acorn
+++ b/day37/node_modules/.bin/acorn
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../acorn/bin/acorn" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../acorn/bin/acorn" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/acorn.cmd
+++ b/day37/node_modules/.bin/acorn.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\acorn\bin\acorn" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\acorn\bin\acorn" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/browserslist
+++ b/day37/node_modules/.bin/browserslist
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../browserslist/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../browserslist/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/browserslist.cmd
+++ b/day37/node_modules/.bin/browserslist.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\browserslist\cli.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\browserslist\cli.js" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/cssesc
+++ b/day37/node_modules/.bin/cssesc
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../cssesc/bin/cssesc" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../cssesc/bin/cssesc" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/cssesc.cmd
+++ b/day37/node_modules/.bin/cssesc.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\cssesc\bin\cssesc" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\cssesc\bin\cssesc" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/envinfo
+++ b/day37/node_modules/.bin/envinfo
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../envinfo/dist/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../envinfo/dist/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/envinfo.cmd
+++ b/day37/node_modules/.bin/envinfo.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\envinfo\dist\cli.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\envinfo\dist\cli.js" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/flat
+++ b/day37/node_modules/.bin/flat
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../flat/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../flat/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/flat.cmd
+++ b/day37/node_modules/.bin/flat.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\flat\cli.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\flat\cli.js" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/import-local-fixture
+++ b/day37/node_modules/.bin/import-local-fixture
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../import-local/fixtures/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../import-local/fixtures/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/import-local-fixture.cmd
+++ b/day37/node_modules/.bin/import-local-fixture.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\import-local\fixtures\cli.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\import-local\fixtures\cli.js" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/nanoid
+++ b/day37/node_modules/.bin/nanoid
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/nanoid.cmd
+++ b/day37/node_modules/.bin/nanoid.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\nanoid\bin\nanoid.cjs" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\nanoid\bin\nanoid.cjs" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/node-which
+++ b/day37/node_modules/.bin/node-which
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../which/bin/node-which" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../which/bin/node-which" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/node-which.cmd
+++ b/day37/node_modules/.bin/node-which.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\which\bin\node-which" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\which\bin\node-which" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/resolve
+++ b/day37/node_modules/.bin/resolve
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../resolve/bin/resolve" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../resolve/bin/resolve" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/resolve.cmd
+++ b/day37/node_modules/.bin/resolve.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\resolve\bin\resolve" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\resolve\bin\resolve" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/semver
+++ b/day37/node_modules/.bin/semver
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../semver/bin/semver.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../semver/bin/semver.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/semver.cmd
+++ b/day37/node_modules/.bin/semver.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\semver\bin\semver.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\semver\bin\semver.js" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/terser
+++ b/day37/node_modules/.bin/terser
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../terser/bin/terser" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../terser/bin/terser" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/terser.cmd
+++ b/day37/node_modules/.bin/terser.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\terser\bin\terser" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\terser\bin\terser" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/update-browserslist-db
+++ b/day37/node_modules/.bin/update-browserslist-db
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../update-browserslist-db/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../update-browserslist-db/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/update-browserslist-db.cmd
+++ b/day37/node_modules/.bin/update-browserslist-db.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\update-browserslist-db\cli.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\update-browserslist-db\cli.js" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/webpack
+++ b/day37/node_modules/.bin/webpack
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../webpack/bin/webpack.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../webpack/bin/webpack.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/webpack-cli
+++ b/day37/node_modules/.bin/webpack-cli
@@ -0,0 +1,15 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  "$basedir/node"  "$basedir/../webpack-cli/bin/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+else 
			
 
				+  node  "$basedir/../webpack-cli/bin/cli.js" "$@"
			
 
				+  ret=$?
			
 
				+fi
			
 
				+exit $ret
			
--- a/day37/node_modules/.bin/webpack-cli.cmd
+++ b/day37/node_modules/.bin/webpack-cli.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\webpack-cli\bin\cli.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\webpack-cli\bin\cli.js" %*
			
 
				+)
			
--- a/day37/node_modules/.bin/webpack.cmd
+++ b/day37/node_modules/.bin/webpack.cmd
@@ -0,0 +1,7 @@
 
				+@IF EXIST "%~dp0\node.exe" (
			
 
				+  "%~dp0\node.exe"  "%~dp0\..\webpack\bin\webpack.js" %*
			
 
				+) ELSE (
			
 
				+  @SETLOCAL
			
 
				+  @SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+  node  "%~dp0\..\webpack\bin\webpack.js" %*
			
 
				+)
			
--- a/day37/node_modules/.yarn-integrity
+++ b/day37/node_modules/.yarn-integrity
@@ -0,0 +1,168 @@
 
				+{
			
 
				+  "systemParams": "win32-x64-115",
			
 
				+  "modulesFolders": [
			
 
				+    "node_modules"
			
 
				+  ],
			
 
				+  "flags": [],
			
 
				+  "linkedModules": [],
			
 
				+  "topLevelPatterns": [
			
 
				+    "css-loader@^6.8.1",
			
 
				+    "style-loader@^3.3.3",
			
 
				+    "webpack-cli@^5.1.4",
			
 
				+    "webpack@^5.89.0"
			
 
				+  ],
			
 
				+  "lockfileEntries": {
			
 
				+    "@discoveryjs/json-ext@^0.5.0": "https://registry.yarnpkg.com/@discoveryjs/json-ext/-/json-ext-0.5.7.tgz#1d572bfbbe14b7704e0ba0f39b74815b84870d70",
			
 
				+    "@jridgewell/gen-mapping@^0.3.0": "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.3.tgz#7e02e6eb5df901aaedb08514203b096614024098",
			
 
				+    "@jridgewell/resolve-uri@^3.1.0": "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz#c08679063f279615a3326583ba3a90d1d82cc721",
			
 
				+    "@jridgewell/set-array@^1.0.1": "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72",
			
 
				+    "@jridgewell/source-map@^0.3.3": "https://registry.yarnpkg.com/@jridgewell/source-map/-/source-map-0.3.5.tgz#a3bb4d5c6825aab0d281268f47f6ad5853431e91",
			
 
				+    "@jridgewell/sourcemap-codec@^1.4.10": "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32",
			
 
				+    "@jridgewell/sourcemap-codec@^1.4.14": "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32",
			
 
				+    "@jridgewell/trace-mapping@^0.3.17": "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz#72e45707cf240fa6b081d0366f8265b0cd10197f",
			
 
				+    "@jridgewell/trace-mapping@^0.3.9": "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.20.tgz#72e45707cf240fa6b081d0366f8265b0cd10197f",
			
 
				+    "@types/eslint-scope@^3.7.3": "https://registry.yarnpkg.com/@types/eslint-scope/-/eslint-scope-3.7.6.tgz#585578b368ed170e67de8aae7b93f54a1b2fdc26",
			
 
				+    "@types/eslint@*": "https://registry.yarnpkg.com/@types/eslint/-/eslint-8.44.6.tgz#60e564551966dd255f4c01c459f0b4fb87068603",
			
 
				+    "@types/estree@*": "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.4.tgz#d9748f5742171b26218516cf1828b8eafaf8a9fa",
			
 
				+    "@types/estree@^1.0.0": "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.4.tgz#d9748f5742171b26218516cf1828b8eafaf8a9fa",
			
 
				+    "@types/json-schema@*": "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.14.tgz#74a97a5573980802f32c8e47b663530ab3b6b7d1",
			
 
				+    "@types/json-schema@^7.0.8": "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.14.tgz#74a97a5573980802f32c8e47b663530ab3b6b7d1",
			
 
				+    "@types/node@*": "https://registry.yarnpkg.com/@types/node/-/node-20.8.10.tgz#a5448b895c753ae929c26ce85cab557c6d4a365e",
			
 
				+    "@webassemblyjs/ast@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.6.tgz#db046555d3c413f8966ca50a95176a0e2c642e24",
			
 
				+    "@webassemblyjs/ast@^1.11.5": "https://registry.yarnpkg.com/@webassemblyjs/ast/-/ast-1.11.6.tgz#db046555d3c413f8966ca50a95176a0e2c642e24",
			
 
				+    "@webassemblyjs/floating-point-hex-parser@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.11.6.tgz#dacbcb95aff135c8260f77fa3b4c5fea600a6431",
			
 
				+    "@webassemblyjs/helper-api-error@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/helper-api-error/-/helper-api-error-1.11.6.tgz#6132f68c4acd59dcd141c44b18cbebbd9f2fa768",
			
 
				+    "@webassemblyjs/helper-buffer@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/helper-buffer/-/helper-buffer-1.11.6.tgz#b66d73c43e296fd5e88006f18524feb0f2c7c093",
			
 
				+    "@webassemblyjs/helper-numbers@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/helper-numbers/-/helper-numbers-1.11.6.tgz#cbce5e7e0c1bd32cf4905ae444ef64cea919f1b5",
			
 
				+    "@webassemblyjs/helper-wasm-bytecode@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.11.6.tgz#bb2ebdb3b83aa26d9baad4c46d4315283acd51e9",
			
 
				+    "@webassemblyjs/helper-wasm-section@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.11.6.tgz#ff97f3863c55ee7f580fd5c41a381e9def4aa577",
			
 
				+    "@webassemblyjs/ieee754@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/ieee754/-/ieee754-1.11.6.tgz#bb665c91d0b14fffceb0e38298c329af043c6e3a",
			
 
				+    "@webassemblyjs/leb128@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/leb128/-/leb128-1.11.6.tgz#70e60e5e82f9ac81118bc25381a0b283893240d7",
			
 
				+    "@webassemblyjs/utf8@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/utf8/-/utf8-1.11.6.tgz#90f8bc34c561595fe156603be7253cdbcd0fab5a",
			
 
				+    "@webassemblyjs/wasm-edit@^1.11.5": "https://registry.yarnpkg.com/@webassemblyjs/wasm-edit/-/wasm-edit-1.11.6.tgz#c72fa8220524c9b416249f3d94c2958dfe70ceab",
			
 
				+    "@webassemblyjs/wasm-gen@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/wasm-gen/-/wasm-gen-1.11.6.tgz#fb5283e0e8b4551cc4e9c3c0d7184a65faf7c268",
			
 
				+    "@webassemblyjs/wasm-opt@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/wasm-opt/-/wasm-opt-1.11.6.tgz#d9a22d651248422ca498b09aa3232a81041487c2",
			
 
				+    "@webassemblyjs/wasm-parser@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.6.tgz#bb85378c527df824004812bbdb784eea539174a1",
			
 
				+    "@webassemblyjs/wasm-parser@^1.11.5": "https://registry.yarnpkg.com/@webassemblyjs/wasm-parser/-/wasm-parser-1.11.6.tgz#bb85378c527df824004812bbdb784eea539174a1",
			
 
				+    "@webassemblyjs/wast-printer@1.11.6": "https://registry.yarnpkg.com/@webassemblyjs/wast-printer/-/wast-printer-1.11.6.tgz#a7bf8dd7e362aeb1668ff43f35cb849f188eff20",
			
 
				+    "@webpack-cli/configtest@^2.1.1": "https://registry.yarnpkg.com/@webpack-cli/configtest/-/configtest-2.1.1.tgz#3b2f852e91dac6e3b85fb2a314fb8bef46d94646",
			
 
				+    "@webpack-cli/info@^2.0.2": "https://registry.yarnpkg.com/@webpack-cli/info/-/info-2.0.2.tgz#cc3fbf22efeb88ff62310cf885c5b09f44ae0fdd",
			
 
				+    "@webpack-cli/serve@^2.0.5": "https://registry.yarnpkg.com/@webpack-cli/serve/-/serve-2.0.5.tgz#325db42395cd49fe6c14057f9a900e427df8810e",
			
 
				+    "@xtuc/ieee754@^1.2.0": "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790",
			
 
				+    "@xtuc/long@4.2.2": "https://registry.yarnpkg.com/@xtuc/long/-/long-4.2.2.tgz#d291c6a4e97989b5c61d9acf396ae4fe133a718d",
			
 
				+    "acorn-import-assertions@^1.9.0": "https://registry.yarnpkg.com/acorn-import-assertions/-/acorn-import-assertions-1.9.0.tgz#507276249d684797c84e0734ef84860334cfb1ac",
			
 
				+    "acorn@^8.7.1": "https://registry.yarnpkg.com/acorn/-/acorn-8.11.2.tgz#ca0d78b51895be5390a5903c5b3bdcdaf78ae40b",
			
 
				+    "acorn@^8.8.2": "https://registry.yarnpkg.com/acorn/-/acorn-8.11.2.tgz#ca0d78b51895be5390a5903c5b3bdcdaf78ae40b",
			
 
				+    "ajv-keywords@^3.5.2": "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.5.2.tgz#31f29da5ab6e00d1c2d329acf7b5929614d5014d",
			
 
				+    "ajv@^6.12.5": "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4",
			
 
				+    "browserslist@^4.14.5": "https://registry.yarnpkg.com/browserslist/-/browserslist-4.22.1.tgz#ba91958d1a59b87dab6fed8dfbcb3da5e2e9c619",
			
 
				+    "buffer-from@^1.0.0": "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5",
			
 
				+    "caniuse-lite@^1.0.30001541": "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001559.tgz#95a982440d3d314c471db68d02664fb7536c5a30",
			
 
				+    "chrome-trace-event@^1.0.2": "https://registry.yarnpkg.com/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz#1015eced4741e15d06664a957dbbf50d041e26ac",
			
 
				+    "clone-deep@^4.0.1": "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387",
			
 
				+    "colorette@^2.0.14": "https://registry.yarnpkg.com/colorette/-/colorette-2.0.20.tgz#9eb793e6833067f7235902fcd3b09917a000a95a",
			
 
				+    "commander@^10.0.1": "https://registry.yarnpkg.com/commander/-/commander-10.0.1.tgz#881ee46b4f77d1c1dccc5823433aa39b022cbe06",
			
 
				+    "commander@^2.20.0": "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33",
			
 
				+    "cross-spawn@^7.0.3": "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6",
			
 
				+    "css-loader@^6.8.1": "https://registry.yarnpkg.com/css-loader/-/css-loader-6.8.1.tgz#0f8f52699f60f5e679eab4ec0fcd68b8e8a50a88",
			
 
				+    "cssesc@^3.0.0": "https://registry.yarnpkg.com/cssesc/-/cssesc-3.0.0.tgz#37741919903b868565e1c09ea747445cd18983ee",
			
 
				+    "electron-to-chromium@^1.4.535": "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.576.tgz#0c6940fdc0d60f7e34bd742b29d8fa847c9294d1",
			
 
				+    "enhanced-resolve@^5.15.0": "https://registry.yarnpkg.com/enhanced-resolve/-/enhanced-resolve-5.15.0.tgz#1af946c7d93603eb88e9896cee4904dc012e9c35",
			
 
				+    "envinfo@^7.7.3": "https://registry.yarnpkg.com/envinfo/-/envinfo-7.11.0.tgz#c3793f44284a55ff8c82faf1ffd91bc6478ea01f",
			
 
				+    "es-module-lexer@^1.2.1": "https://registry.yarnpkg.com/es-module-lexer/-/es-module-lexer-1.3.1.tgz#c1b0dd5ada807a3b3155315911f364dc4e909db1",
			
 
				+    "escalade@^3.1.1": "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40",
			
 
				+    "eslint-scope@5.1.1": "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c",
			
 
				+    "esrecurse@^4.3.0": "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921",
			
 
				+    "estraverse@^4.1.1": "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d",
			
 
				+    "estraverse@^5.2.0": "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123",
			
 
				+    "events@^3.2.0": "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400",
			
 
				+    "fast-deep-equal@^3.1.1": "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525",
			
 
				+    "fast-json-stable-stringify@^2.0.0": "https://registry.yarnpkg.com/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz#874bf69c6f404c2b5d99c481341399fd55892633",
			
 
				+    "fastest-levenshtein@^1.0.12": "https://registry.yarnpkg.com/fastest-levenshtein/-/fastest-levenshtein-1.0.16.tgz#210e61b6ff181de91ea9b3d1b84fdedd47e034e5",
			
 
				+    "find-up@^4.0.0": "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19",
			
 
				+    "flat@^5.0.2": "https://registry.yarnpkg.com/flat/-/flat-5.0.2.tgz#8ca6fe332069ffa9d324c327198c598259ceb241",
			
 
				+    "function-bind@^1.1.2": "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c",
			
 
				+    "glob-to-regexp@^0.4.1": "https://registry.yarnpkg.com/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz#c75297087c851b9a578bd217dd59a92f59fe546e",
			
 
				+    "graceful-fs@^4.1.2": "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3",
			
 
				+    "graceful-fs@^4.2.4": "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3",
			
 
				+    "graceful-fs@^4.2.9": "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3",
			
 
				+    "has-flag@^4.0.0": "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b",
			
 
				+    "hasown@^2.0.0": "https://registry.yarnpkg.com/hasown/-/hasown-2.0.0.tgz#f4c513d454a57b7c7e1650778de226b11700546c",
			
 
				+    "icss-utils@^5.0.0": "https://registry.yarnpkg.com/icss-utils/-/icss-utils-5.1.0.tgz#c6be6858abd013d768e98366ae47e25d5887b1ae",
			
 
				+    "icss-utils@^5.1.0": "https://registry.yarnpkg.com/icss-utils/-/icss-utils-5.1.0.tgz#c6be6858abd013d768e98366ae47e25d5887b1ae",
			
 
				+    "import-local@^3.0.2": "https://registry.yarnpkg.com/import-local/-/import-local-3.1.0.tgz#b4479df8a5fd44f6cdce24070675676063c95cb4",
			
 
				+    "interpret@^3.1.1": "https://registry.yarnpkg.com/interpret/-/interpret-3.1.1.tgz#5be0ceed67ca79c6c4bc5cf0d7ee843dcea110c4",
			
 
				+    "is-core-module@^2.13.0": "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.13.1.tgz#ad0d7532c6fea9da1ebdc82742d74525c6273384",
			
 
				+    "is-plain-object@^2.0.4": "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677",
			
 
				+    "isexe@^2.0.0": "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10",
			
 
				+    "isobject@^3.0.1": "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df",
			
 
				+    "jest-worker@^27.4.5": "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.5.1.tgz#8d146f0900e8973b106b6f73cc1e9a8cb86f8db0",
			
 
				+    "json-parse-even-better-errors@^2.3.1": "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d",
			
 
				+    "json-schema-traverse@^0.4.1": "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660",
			
 
				+    "kind-of@^6.0.2": "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd",
			
 
				+    "loader-runner@^4.2.0": "https://registry.yarnpkg.com/loader-runner/-/loader-runner-4.3.0.tgz#c1b4a163b99f614830353b16755e7149ac2314e1",
			
 
				+    "locate-path@^5.0.0": "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0",
			
 
				+    "lru-cache@^6.0.0": "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94",
			
 
				+    "merge-stream@^2.0.0": "https://registry.yarnpkg.com/merge-stream/-/merge-stream-2.0.0.tgz#52823629a14dd00c9770fb6ad47dc6310f2c1f60",
			
 
				+    "mime-db@1.52.0": "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70",
			
 
				+    "mime-types@^2.1.27": "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a",
			
 
				+    "nanoid@^3.3.6": "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.6.tgz#443380c856d6e9f9824267d960b4236ad583ea4c",
			
 
				+    "neo-async@^2.6.2": "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f",
			
 
				+    "node-releases@^2.0.13": "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.13.tgz#d5ed1627c23e3461e819b02e57b75e4899b1c81d",
			
 
				+    "p-limit@^2.2.0": "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1",
			
 
				+    "p-locate@^4.1.0": "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07",
			
 
				+    "p-try@^2.0.0": "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6",
			
 
				+    "path-exists@^4.0.0": "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3",
			
 
				+    "path-key@^3.1.0": "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375",
			
 
				+    "path-parse@^1.0.7": "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735",
			
 
				+    "picocolors@^1.0.0": "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c",
			
 
				+    "pkg-dir@^4.2.0": "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-4.2.0.tgz#f099133df7ede422e81d1d8448270eeb3e4261f3",
			
 
				+    "postcss-modules-extract-imports@^3.0.0": "https://registry.yarnpkg.com/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.0.0.tgz#cda1f047c0ae80c97dbe28c3e76a43b88025741d",
			
 
				+    "postcss-modules-local-by-default@^4.0.3": "https://registry.yarnpkg.com/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.0.3.tgz#b08eb4f083050708998ba2c6061b50c2870ca524",
			
 
				+    "postcss-modules-scope@^3.0.0": "https://registry.yarnpkg.com/postcss-modules-scope/-/postcss-modules-scope-3.0.0.tgz#9ef3151456d3bbfa120ca44898dfca6f2fa01f06",
			
 
				+    "postcss-modules-values@^4.0.0": "https://registry.yarnpkg.com/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz#d7c5e7e68c3bb3c9b27cbf48ca0bb3ffb4602c9c",
			
 
				+    "postcss-selector-parser@^6.0.2": "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz#d05d8d76b1e8e173257ef9d60b706a8e5e99bf1b",
			
 
				+    "postcss-selector-parser@^6.0.4": "https://registry.yarnpkg.com/postcss-selector-parser/-/postcss-selector-parser-6.0.13.tgz#d05d8d76b1e8e173257ef9d60b706a8e5e99bf1b",
			
 
				+    "postcss-value-parser@^4.1.0": "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz#723c09920836ba6d3e5af019f92bc0971c02e514",
			
 
				+    "postcss-value-parser@^4.2.0": "https://registry.yarnpkg.com/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz#723c09920836ba6d3e5af019f92bc0971c02e514",
			
 
				+    "postcss@^8.4.21": "https://registry.yarnpkg.com/postcss/-/postcss-8.4.31.tgz#92b451050a9f914da6755af352bdc0192508656d",
			
 
				+    "punycode@^2.1.0": "https://registry.yarnpkg.com/punycode/-/punycode-2.3.1.tgz#027422e2faec0b25e1549c3e1bd8309b9133b6e5",
			
 
				+    "randombytes@^2.1.0": "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a",
			
 
				+    "rechoir@^0.8.0": "https://registry.yarnpkg.com/rechoir/-/rechoir-0.8.0.tgz#49f866e0d32146142da3ad8f0eff352b3215ff22",
			
 
				+    "resolve-cwd@^3.0.0": "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-3.0.0.tgz#0f0075f1bb2544766cf73ba6a6e2adfebcb13f2d",
			
 
				+    "resolve-from@^5.0.0": "https://registry.yarnpkg.com/resolve-from/-/resolve-from-5.0.0.tgz#c35225843df8f776df21c57557bc087e9dfdfc69",
			
 
				+    "resolve@^1.20.0": "https://registry.yarnpkg.com/resolve/-/resolve-1.22.8.tgz#b6c87a9f2aa06dfab52e3d70ac8cde321fa5a48d",
			
 
				+    "safe-buffer@^5.1.0": "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6",
			
 
				+    "schema-utils@^3.1.1": "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.3.0.tgz#f50a88877c3c01652a15b622ae9e9795df7a60fe",
			
 
				+    "schema-utils@^3.2.0": "https://registry.yarnpkg.com/schema-utils/-/schema-utils-3.3.0.tgz#f50a88877c3c01652a15b622ae9e9795df7a60fe",
			
 
				+    "semver@^7.3.8": "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e",
			
 
				+    "serialize-javascript@^6.0.1": "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-6.0.1.tgz#b206efb27c3da0b0ab6b52f48d170b7996458e5c",
			
 
				+    "shallow-clone@^3.0.0": "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3",
			
 
				+    "shebang-command@^2.0.0": "https://registry.yarnpkg.com/shebang-command/-/shebang-command-2.0.0.tgz#ccd0af4f8835fbdc265b82461aaf0c36663f34ea",
			
 
				+    "shebang-regex@^3.0.0": "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172",
			
 
				+    "source-map-js@^1.0.2": "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.0.2.tgz#adbc361d9c62df380125e7f161f71c826f1e490c",
			
 
				+    "source-map-support@~0.5.20": "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f",
			
 
				+    "source-map@^0.6.0": "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263",
			
 
				+    "style-loader@^3.3.3": "https://registry.yarnpkg.com/style-loader/-/style-loader-3.3.3.tgz#bba8daac19930169c0c9c96706749a597ae3acff",
			
 
				+    "supports-color@^8.0.0": "https://registry.yarnpkg.com/supports-color/-/supports-color-8.1.1.tgz#cd6fc17e28500cff56c1b86c0a7fd4a54a73005c",
			
 
				+    "supports-preserve-symlinks-flag@^1.0.0": "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09",
			
 
				+    "tapable@^2.1.1": "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0",
			
 
				+    "tapable@^2.2.0": "https://registry.yarnpkg.com/tapable/-/tapable-2.2.1.tgz#1967a73ef4060a82f12ab96af86d52fdb76eeca0",
			
 
				+    "terser-webpack-plugin@^5.3.7": "https://registry.yarnpkg.com/terser-webpack-plugin/-/terser-webpack-plugin-5.3.9.tgz#832536999c51b46d468067f9e37662a3b96adfe1",
			
 
				+    "terser@^5.16.8": "https://registry.yarnpkg.com/terser/-/terser-5.24.0.tgz#4ae50302977bca4831ccc7b4fef63a3c04228364",
			
 
				+    "undici-types@~5.26.4": "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617",
			
 
				+    "update-browserslist-db@^1.0.13": "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.13.tgz#3c5e4f5c083661bd38ef64b6328c26ed6c8248c4",
			
 
				+    "uri-js@^4.2.2": "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e",
			
 
				+    "util-deprecate@^1.0.2": "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf",
			
 
				+    "watchpack@^2.4.0": "https://registry.yarnpkg.com/watchpack/-/watchpack-2.4.0.tgz#fa33032374962c78113f93c7f2fb4c54c9862a5d",
			
 
				+    "webpack-cli@^5.1.4": "https://registry.yarnpkg.com/webpack-cli/-/webpack-cli-5.1.4.tgz#c8e046ba7eaae4911d7e71e2b25b776fcc35759b",
			
 
				+    "webpack-merge@^5.7.3": "https://registry.yarnpkg.com/webpack-merge/-/webpack-merge-5.10.0.tgz#a3ad5d773241e9c682803abf628d4cd62b8a4177",
			
 
				+    "webpack-sources@^3.2.3": "https://registry.yarnpkg.com/webpack-sources/-/webpack-sources-3.2.3.tgz#2d4daab8451fd4b240cc27055ff6a0c2ccea0cde",
			
 
				+    "webpack@^5.89.0": "https://registry.yarnpkg.com/webpack/-/webpack-5.89.0.tgz#56b8bf9a34356e93a6625770006490bf3a7f32dc",
			
 
				+    "which@^2.0.1": "https://registry.yarnpkg.com/which/-/which-2.0.2.tgz#7c6a8dd0a636a0327e10b59c9286eee93f3f51b1",
			
 
				+    "wildcard@^2.0.0": "https://registry.yarnpkg.com/wildcard/-/wildcard-2.0.1.tgz#5ab10d02487198954836b6349f74fff961e10f67",
			
 
				+    "yallist@^4.0.0": "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
			
 
				+  },
			
 
				+  "files": [],
			
 
				+  "artifacts": {}
			
 
				+}
			
--- a/day37/node_modules/@discoveryjs/json-ext/LICENSE
+++ b/day37/node_modules/@discoveryjs/json-ext/LICENSE
@@ -0,0 +1,21 @@
 
				+MIT License
			
 
				+
			
 
				+Copyright (c) 2020 Roman Dvornov <rdvornov@gmail.com>
			
 
				+
			
 
				+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/day37/node_modules/@discoveryjs/json-ext/README.md
+++ b/day37/node_modules/@discoveryjs/json-ext/README.md
@@ -0,0 +1,256 @@
 
				+# json-ext
			
 
				+
			
 
				+[![NPM version](https://img.shields.io/npm/v/@discoveryjs/json-ext.svg)](https://www.npmjs.com/package/@discoveryjs/json-ext)
			
 
				+[![Build Status](https://github.com/discoveryjs/json-ext/actions/workflows/ci.yml/badge.svg)](https://github.com/discoveryjs/json-ext/actions/workflows/ci.yml)
			
 
				+[![Coverage Status](https://coveralls.io/repos/github/discoveryjs/json-ext/badge.svg?branch=master)](https://coveralls.io/github/discoveryjs/json-ext?)
			
 
				+[![NPM Downloads](https://img.shields.io/npm/dm/@discoveryjs/json-ext.svg)](https://www.npmjs.com/package/@discoveryjs/json-ext)
			
 
				+
			
 
				+A set of utilities that extend the use of JSON. Designed to be fast and memory efficient
			
 
				+
			
 
				+Features:
			
 
				+
			
 
				+- [x] `parseChunked()` – Parse JSON that comes by chunks (e.g. FS readable stream or fetch response stream)
			
 
				+- [x] `stringifyStream()` – Stringify stream (Node.js)
			
 
				+- [x] `stringifyInfo()` – Get estimated size and other facts of JSON.stringify() without converting a value to string
			
 
				+- [ ] **TBD** Support for circular references
			
 
				+- [ ] **TBD** Binary representation [branch](https://github.com/discoveryjs/json-ext/tree/binary)
			
 
				+- [ ] **TBD** WHATWG [Streams](https://streams.spec.whatwg.org/) support
			
 
				+
			
 
				+## Install
			
 
				+
			
 
				+```bash
			
 
				+npm install @discoveryjs/json-ext
			
 
				+```
			
 
				+
			
 
				+## API
			
 
				+
			
 
				+- [parseChunked(chunkEmitter)](#parsechunkedchunkemitter)
			
 
				+- [stringifyStream(value[, replacer[, space]])](#stringifystreamvalue-replacer-space)
			
 
				+- [stringifyInfo(value[, replacer[, space[, options]]])](#stringifyinfovalue-replacer-space-options)
			
 
				+    - [Options](#options)
			
 
				+        - [async](#async)
			
 
				+        - [continueOnCircular](#continueoncircular)
			
 
				+- [version](#version)
			
 
				+
			
 
				+### parseChunked(chunkEmitter)
			
 
				+
			
 
				+Works the same as [`JSON.parse()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse) but takes `chunkEmitter` instead of string and returns [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
			
 
				+
			
 
				+> NOTE: `reviver` parameter is not supported yet, but will be added in next releases.
			
 
				+> NOTE: WHATWG streams aren't supported yet
			
 
				+
			
 
				+When to use:
			
 
				+- It's required to avoid freezing the main thread during big JSON parsing, since this process can be distributed in time
			
 
				+- Huge JSON needs to be parsed (e.g. >500MB on Node.js)
			
 
				+- Needed to reduce memory pressure. `JSON.parse()` needs to receive the entire JSON before parsing it. With `parseChunked()` you may parse JSON as first bytes of it comes. This approach helps to avoid storing a huge string in the memory at a single time point and following GC.
			
 
				+
			
 
				+[Benchmark](https://github.com/discoveryjs/json-ext/tree/master/benchmarks#parse-chunked)
			
 
				+
			
 
				+Usage:
			
 
				+
			
 
				+```js
			
 
				+const { parseChunked } = require('@discoveryjs/json-ext');
			
 
				+
			
 
				+// as a regular Promise
			
 
				+parseChunked(chunkEmitter)
			
 
				+    .then(data => {
			
 
				+        /* data is parsed JSON */
			
 
				+    });
			
 
				+
			
 
				+// using await (keep in mind that not every runtime has a support for top level await)
			
 
				+const data = await parseChunked(chunkEmitter);
			
 
				+```
			
 
				+
			
 
				+Parameter `chunkEmitter` can be:
			
 
				+- [`ReadableStream`](https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_readable_streams) (Node.js only)
			
 
				+```js
			
 
				+const fs = require('fs');
			
 
				+const { parseChunked } = require('@discoveryjs/json-ext');
			
 
				+
			
 
				+parseChunked(fs.createReadStream('path/to/file.json'))
			
 
				+```
			
 
				+- Generator, async generator or function that returns iterable (chunks). Chunk might be a `string`, `Uint8Array` or `Buffer` (Node.js only):
			
 
				+```js
			
 
				+const { parseChunked } = require('@discoveryjs/json-ext');
			
 
				+const encoder = new TextEncoder();
			
 
				+
			
 
				+// generator
			
 
				+parseChunked(function*() {
			
 
				+    yield '{ "hello":';
			
 
				+    yield Buffer.from(' "wor');    // Node.js only
			
 
				+    yield encoder.encode('ld" }'); // returns Uint8Array(5) [ 108, 100, 34, 32, 125 ]
			
 
				+});
			
 
				+
			
 
				+// async generator
			
 
				+parseChunked(async function*() {
			
 
				+    for await (const chunk of someAsyncSource) {
			
 
				+        yield chunk;
			
 
				+    }
			
 
				+});
			
 
				+
			
 
				+// function that returns iterable
			
 
				+parseChunked(() => ['{ "hello":', ' "world"}'])
			
 
				+```
			
 
				+
			
 
				+Using with [fetch()](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API):
			
 
				+
			
 
				+```js
			
 
				+async function loadData(url) {
			
 
				+    const response = await fetch(url);
			
 
				+    const reader = response.body.getReader();
			
 
				+
			
 
				+    return parseChunked(async function*() {
			
 
				+        while (true) {
			
 
				+            const { done, value } = await reader.read();
			
 
				+
			
 
				+            if (done) {
			
 
				+                break;
			
 
				+            }
			
 
				+
			
 
				+            yield value;
			
 
				+        }
			
 
				+    });
			
 
				+}
			
 
				+
			
 
				+loadData('https://example.com/data.json')
			
 
				+    .then(data => {
			
 
				+        /* data is parsed JSON */
			
 
				+    })
			
 
				+```
			
 
				+
			
 
				+### stringifyStream(value[, replacer[, space]])
			
 
				+
			
 
				+Works the same as [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify), but returns an instance of [`ReadableStream`](https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_readable_streams) instead of string.
			
 
				+
			
 
				+> NOTE: WHATWG Streams aren't supported yet, so function available for Node.js only for now
			
 
				+
			
 
				+Departs from JSON.stringify():
			
 
				+- Outputs `null` when `JSON.stringify()` returns `undefined` (since streams may not emit `undefined`)
			
 
				+- A promise is resolving and the resulting value is stringifying as a regular one
			
 
				+- A stream in non-object mode is piping to output as is
			
 
				+- A stream in object mode is piping to output as an array of objects
			
 
				+
			
 
				+When to use:
			
 
				+- Huge JSON needs to be generated (e.g. >500MB on Node.js)
			
 
				+- Needed to reduce memory pressure. `JSON.stringify()` needs to generate the entire JSON before send or write it to somewhere. With `stringifyStream()` you may send a result to somewhere as first bytes of the result appears. This approach helps to avoid storing a huge string in the memory at a single time point.
			
 
				+- The object being serialized contains Promises or Streams (see Usage for examples)
			
 
				+
			
 
				+[Benchmark](https://github.com/discoveryjs/json-ext/tree/master/benchmarks#stream-stringifying)
			
 
				+
			
 
				+Usage:
			
 
				+
			
 
				+```js
			
 
				+const { stringifyStream } = require('@discoveryjs/json-ext');
			
 
				+
			
 
				+// handle events
			
 
				+stringifyStream(data)
			
 
				+    .on('data', chunk => console.log(chunk))
			
 
				+    .on('error', error => consold.error(error))
			
 
				+    .on('finish', () => console.log('DONE!'));
			
 
				+
			
 
				+// pipe into a stream
			
 
				+stringifyStream(data)
			
 
				+    .pipe(writableStream);
			
 
				+```
			
 
				+
			
 
				+Using Promise or ReadableStream in serializing object:
			
 
				+
			
 
				+```js
			
 
				+const fs = require('fs');
			
 
				+const { stringifyStream } = require('@discoveryjs/json-ext');
			
 
				+
			
 
				+// output will be
			
 
				+// {"name":"example","willSerializeResolvedValue":42,"fromFile":[1, 2, 3],"at":{"any":{"level":"promise!"}}}
			
 
				+stringifyStream({
			
 
				+    name: 'example',
			
 
				+    willSerializeResolvedValue: Promise.resolve(42),
			
 
				+    fromFile: fs.createReadStream('path/to/file.json'), // support file content is "[1, 2, 3]", it'll be inserted as it
			
 
				+    at: {
			
 
				+        any: {
			
 
				+            level: new Promise(resolve => setTimeout(() => resolve('promise!'), 100))
			
 
				+        }
			
 
				+    }
			
 
				+})
			
 
				+
			
 
				+// in case several async requests are used in object, it's prefered
			
 
				+// to put fastest requests first, because in this case
			
 
				+stringifyStream({
			
 
				+    foo: fetch('http://example.com/request_takes_2s').then(req => req.json()),
			
 
				+    bar: fetch('http://example.com/request_takes_5s').then(req => req.json())
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+Using with [`WritableStream`](https://nodejs.org/dist/latest-v14.x/docs/api/stream.html#stream_writable_streams) (Node.js only):
			
 
				+
			
 
				+```js
			
 
				+const fs = require('fs');
			
 
				+const { stringifyStream } = require('@discoveryjs/json-ext');
			
 
				+
			
 
				+// pipe into a console
			
 
				+stringifyStream(data)
			
 
				+    .pipe(process.stdout);
			
 
				+
			
 
				+// pipe into a file
			
 
				+stringifyStream(data)
			
 
				+    .pipe(fs.createWriteStream('path/to/file.json'));
			
 
				+
			
 
				+// wrapping into a Promise
			
 
				+new Promise((resolve, reject) => {
			
 
				+    stringifyStream(data)
			
 
				+        .on('error', reject)
			
 
				+        .pipe(stream)
			
 
				+        .on('error', reject)
			
 
				+        .on('finish', resolve);
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+### stringifyInfo(value[, replacer[, space[, options]]])
			
 
				+
			
 
				+`value`, `replacer` and `space` arguments are the same as for `JSON.stringify()`.
			
 
				+
			
 
				+Result is an object:
			
 
				+
			
 
				+```js
			
 
				+{
			
 
				+    minLength: Number,  // minimal bytes when values is stringified
			
 
				+    circular: [...],    // list of circular references
			
 
				+    duplicate: [...],   // list of objects that occur more than once
			
 
				+    async: [...]        // list of async values, i.e. promises and streams
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+Example:
			
 
				+
			
 
				+```js
			
 
				+const { stringifyInfo } = require('@discoveryjs/json-ext');
			
 
				+
			
 
				+console.log(
			
 
				+    stringifyInfo({ test: true }).minLength
			
 
				+);
			
 
				+// > 13
			
 
				+// that equals '{"test":true}'.length
			
 
				+```
			
 
				+
			
 
				+#### Options
			
 
				+
			
 
				+##### async
			
 
				+
			
 
				+Type: `Boolean`  
			
 
				+Default: `false`
			
 
				+
			
 
				+Collect async values (promises and streams) or not.
			
 
				+
			
 
				+##### continueOnCircular
			
 
				+
			
 
				+Type: `Boolean`  
			
 
				+Default: `false`
			
 
				+
			
 
				+Stop collecting info for a value or not whenever circular reference is found. Setting option to `true` allows to find all circular references.
			
 
				+
			
 
				+### version
			
 
				+
			
 
				+The version of library, e.g. `"0.3.1"`.
			
 
				+
			
 
				+## License
			
 
				+
			
 
				+MIT
			
--- a/day37/node_modules/@discoveryjs/json-ext/dist/json-ext.js
+++ b/day37/node_modules/@discoveryjs/json-ext/dist/json-ext.js
@@ -0,0 +1,791 @@
 
				+(function (global, factory) {
			
 
				+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
			
 
				+    typeof define === 'function' && define.amd ? define(factory) :
			
 
				+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.jsonExt = factory());
			
 
				+})(this, (function () { 'use strict';
			
 
				+
			
 
				+    var version = "0.5.7";
			
 
				+
			
 
				+    const PrimitiveType = 1;
			
 
				+    const ObjectType = 2;
			
 
				+    const ArrayType = 3;
			
 
				+    const PromiseType = 4;
			
 
				+    const ReadableStringType = 5;
			
 
				+    const ReadableObjectType = 6;
			
 
				+    // https://tc39.es/ecma262/#table-json-single-character-escapes
			
 
				+    const escapableCharCodeSubstitution$1 = { // JSON Single Character Escape Sequences
			
 
				+        0x08: '\\b',
			
 
				+        0x09: '\\t',
			
 
				+        0x0a: '\\n',
			
 
				+        0x0c: '\\f',
			
 
				+        0x0d: '\\r',
			
 
				+        0x22: '\\\"',
			
 
				+        0x5c: '\\\\'
			
 
				+    };
			
 
				+
			
 
				+    function isLeadingSurrogate$1(code) {
			
 
				+        return code >= 0xD800 && code <= 0xDBFF;
			
 
				+    }
			
 
				+
			
 
				+    function isTrailingSurrogate$1(code) {
			
 
				+        return code >= 0xDC00 && code <= 0xDFFF;
			
 
				+    }
			
 
				+
			
 
				+    function isReadableStream$1(value) {
			
 
				+        return (
			
 
				+            typeof value.pipe === 'function' &&
			
 
				+            typeof value._read === 'function' &&
			
 
				+            typeof value._readableState === 'object' && value._readableState !== null
			
 
				+        );
			
 
				+    }
			
 
				+
			
 
				+    function replaceValue$1(holder, key, value, replacer) {
			
 
				+        if (value && typeof value.toJSON === 'function') {
			
 
				+            value = value.toJSON();
			
 
				+        }
			
 
				+
			
 
				+        if (replacer !== null) {
			
 
				+            value = replacer.call(holder, String(key), value);
			
 
				+        }
			
 
				+
			
 
				+        switch (typeof value) {
			
 
				+            case 'function':
			
 
				+            case 'symbol':
			
 
				+                value = undefined;
			
 
				+                break;
			
 
				+
			
 
				+            case 'object':
			
 
				+                if (value !== null) {
			
 
				+                    const cls = value.constructor;
			
 
				+                    if (cls === String || cls === Number || cls === Boolean) {
			
 
				+                        value = value.valueOf();
			
 
				+                    }
			
 
				+                }
			
 
				+                break;
			
 
				+        }
			
 
				+
			
 
				+        return value;
			
 
				+    }
			
 
				+
			
 
				+    function getTypeNative$1(value) {
			
 
				+        if (value === null || typeof value !== 'object') {
			
 
				+            return PrimitiveType;
			
 
				+        }
			
 
				+
			
 
				+        if (Array.isArray(value)) {
			
 
				+            return ArrayType;
			
 
				+        }
			
 
				+
			
 
				+        return ObjectType;
			
 
				+    }
			
 
				+
			
 
				+    function getTypeAsync$1(value) {
			
 
				+        if (value === null || typeof value !== 'object') {
			
 
				+            return PrimitiveType;
			
 
				+        }
			
 
				+
			
 
				+        if (typeof value.then === 'function') {
			
 
				+            return PromiseType;
			
 
				+        }
			
 
				+
			
 
				+        if (isReadableStream$1(value)) {
			
 
				+            return value._readableState.objectMode ? ReadableObjectType : ReadableStringType;
			
 
				+        }
			
 
				+
			
 
				+        if (Array.isArray(value)) {
			
 
				+            return ArrayType;
			
 
				+        }
			
 
				+
			
 
				+        return ObjectType;
			
 
				+    }
			
 
				+
			
 
				+    function normalizeReplacer$1(replacer) {
			
 
				+        if (typeof replacer === 'function') {
			
 
				+            return replacer;
			
 
				+        }
			
 
				+
			
 
				+        if (Array.isArray(replacer)) {
			
 
				+            const allowlist = new Set(replacer
			
 
				+                .map(item => {
			
 
				+                    const cls = item && item.constructor;
			
 
				+                    return cls === String || cls === Number ? String(item) : null;
			
 
				+                })
			
 
				+                .filter(item => typeof item === 'string')
			
 
				+            );
			
 
				+
			
 
				+            return [...allowlist];
			
 
				+        }
			
 
				+
			
 
				+        return null;
			
 
				+    }
			
 
				+
			
 
				+    function normalizeSpace$1(space) {
			
 
				+        if (typeof space === 'number') {
			
 
				+            if (!Number.isFinite(space) || space < 1) {
			
 
				+                return false;
			
 
				+            }
			
 
				+
			
 
				+            return ' '.repeat(Math.min(space, 10));
			
 
				+        }
			
 
				+
			
 
				+        if (typeof space === 'string') {
			
 
				+            return space.slice(0, 10) || false;
			
 
				+        }
			
 
				+
			
 
				+        return false;
			
 
				+    }
			
 
				+
			
 
				+    var utils = {
			
 
				+        escapableCharCodeSubstitution: escapableCharCodeSubstitution$1,
			
 
				+        isLeadingSurrogate: isLeadingSurrogate$1,
			
 
				+        isTrailingSurrogate: isTrailingSurrogate$1,
			
 
				+        type: {
			
 
				+            PRIMITIVE: PrimitiveType,
			
 
				+            PROMISE: PromiseType,
			
 
				+            ARRAY: ArrayType,
			
 
				+            OBJECT: ObjectType,
			
 
				+            STRING_STREAM: ReadableStringType,
			
 
				+            OBJECT_STREAM: ReadableObjectType
			
 
				+        },
			
 
				+
			
 
				+        isReadableStream: isReadableStream$1,
			
 
				+        replaceValue: replaceValue$1,
			
 
				+        getTypeNative: getTypeNative$1,
			
 
				+        getTypeAsync: getTypeAsync$1,
			
 
				+        normalizeReplacer: normalizeReplacer$1,
			
 
				+        normalizeSpace: normalizeSpace$1
			
 
				+    };
			
 
				+
			
 
				+    const {
			
 
				+        normalizeReplacer,
			
 
				+        normalizeSpace,
			
 
				+        replaceValue,
			
 
				+        getTypeNative,
			
 
				+        getTypeAsync,
			
 
				+        isLeadingSurrogate,
			
 
				+        isTrailingSurrogate,
			
 
				+        escapableCharCodeSubstitution,
			
 
				+        type: {
			
 
				+            PRIMITIVE,
			
 
				+            OBJECT,
			
 
				+            ARRAY,
			
 
				+            PROMISE,
			
 
				+            STRING_STREAM,
			
 
				+            OBJECT_STREAM
			
 
				+        }
			
 
				+    } = utils;
			
 
				+    const charLength2048 = Array.from({ length: 2048 }).map((_, code) => {
			
 
				+        if (escapableCharCodeSubstitution.hasOwnProperty(code)) {
			
 
				+            return 2; // \X
			
 
				+        }
			
 
				+
			
 
				+        if (code < 0x20) {
			
 
				+            return 6; // \uXXXX
			
 
				+        }
			
 
				+
			
 
				+        return code < 128 ? 1 : 2; // UTF8 bytes
			
 
				+    });
			
 
				+
			
 
				+    function stringLength(str) {
			
 
				+        let len = 0;
			
 
				+        let prevLeadingSurrogate = false;
			
 
				+
			
 
				+        for (let i = 0; i < str.length; i++) {
			
 
				+            const code = str.charCodeAt(i);
			
 
				+
			
 
				+            if (code < 2048) {
			
 
				+                len += charLength2048[code];
			
 
				+            } else if (isLeadingSurrogate(code)) {
			
 
				+                len += 6; // \uXXXX since no pair with trailing surrogate yet
			
 
				+                prevLeadingSurrogate = true;
			
 
				+                continue;
			
 
				+            } else if (isTrailingSurrogate(code)) {
			
 
				+                len = prevLeadingSurrogate
			
 
				+                    ? len - 2  // surrogate pair (4 bytes), since we calculate prev leading surrogate as 6 bytes, substruct 2 bytes
			
 
				+                    : len + 6; // \uXXXX
			
 
				+            } else {
			
 
				+                len += 3; // code >= 2048 is 3 bytes length for UTF8
			
 
				+            }
			
 
				+
			
 
				+            prevLeadingSurrogate = false;
			
 
				+        }
			
 
				+
			
 
				+        return len + 2; // +2 for quotes
			
 
				+    }
			
 
				+
			
 
				+    function primitiveLength(value) {
			
 
				+        switch (typeof value) {
			
 
				+            case 'string':
			
 
				+                return stringLength(value);
			
 
				+
			
 
				+            case 'number':
			
 
				+                return Number.isFinite(value) ? String(value).length : 4 /* null */;
			
 
				+
			
 
				+            case 'boolean':
			
 
				+                return value ? 4 /* true */ : 5 /* false */;
			
 
				+
			
 
				+            case 'undefined':
			
 
				+            case 'object':
			
 
				+                return 4; /* null */
			
 
				+
			
 
				+            default:
			
 
				+                return 0;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    function spaceLength(space) {
			
 
				+        space = normalizeSpace(space);
			
 
				+        return typeof space === 'string' ? space.length : 0;
			
 
				+    }
			
 
				+
			
 
				+    var stringifyInfo = function jsonStringifyInfo(value, replacer, space, options) {
			
 
				+        function walk(holder, key, value) {
			
 
				+            if (stop) {
			
 
				+                return;
			
 
				+            }
			
 
				+
			
 
				+            value = replaceValue(holder, key, value, replacer);
			
 
				+
			
 
				+            let type = getType(value);
			
 
				+
			
 
				+            // check for circular structure
			
 
				+            if (type !== PRIMITIVE && stack.has(value)) {
			
 
				+                circular.add(value);
			
 
				+                length += 4; // treat as null
			
 
				+
			
 
				+                if (!options.continueOnCircular) {
			
 
				+                    stop = true;
			
 
				+                }
			
 
				+
			
 
				+                return;
			
 
				+            }
			
 
				+
			
 
				+            switch (type) {
			
 
				+                case PRIMITIVE:
			
 
				+                    if (value !== undefined || Array.isArray(holder)) {
			
 
				+                        length += primitiveLength(value);
			
 
				+                    } else if (holder === root) {
			
 
				+                        length += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?
			
 
				+                    }
			
 
				+                    break;
			
 
				+
			
 
				+                case OBJECT: {
			
 
				+                    if (visited.has(value)) {
			
 
				+                        duplicate.add(value);
			
 
				+                        length += visited.get(value);
			
 
				+                        break;
			
 
				+                    }
			
 
				+
			
 
				+                    const valueLength = length;
			
 
				+                    let entries = 0;
			
 
				+
			
 
				+                    length += 2; // {}
			
 
				+
			
 
				+                    stack.add(value);
			
 
				+
			
 
				+                    for (const key in value) {
			
 
				+                        if (hasOwnProperty.call(value, key) && (allowlist === null || allowlist.has(key))) {
			
 
				+                            const prevLength = length;
			
 
				+                            walk(value, key, value[key]);
			
 
				+
			
 
				+                            if (prevLength !== length) {
			
 
				+                                // value is printed
			
 
				+                                length += stringLength(key) + 1; // "key":
			
 
				+                                entries++;
			
 
				+                            }
			
 
				+                        }
			
 
				+                    }
			
 
				+
			
 
				+                    if (entries > 1) {
			
 
				+                        length += entries - 1; // commas
			
 
				+                    }
			
 
				+
			
 
				+                    stack.delete(value);
			
 
				+
			
 
				+                    if (space > 0 && entries > 0) {
			
 
				+                        length += (1 + (stack.size + 1) * space + 1) * entries; // for each key-value: \n{space}
			
 
				+                        length += 1 + stack.size * space; // for }
			
 
				+                    }
			
 
				+
			
 
				+                    visited.set(value, length - valueLength);
			
 
				+
			
 
				+                    break;
			
 
				+                }
			
 
				+
			
 
				+                case ARRAY: {
			
 
				+                    if (visited.has(value)) {
			
 
				+                        duplicate.add(value);
			
 
				+                        length += visited.get(value);
			
 
				+                        break;
			
 
				+                    }
			
 
				+
			
 
				+                    const valueLength = length;
			
 
				+
			
 
				+                    length += 2; // []
			
 
				+
			
 
				+                    stack.add(value);
			
 
				+
			
 
				+                    for (let i = 0; i < value.length; i++) {
			
 
				+                        walk(value, i, value[i]);
			
 
				+                    }
			
 
				+
			
 
				+                    if (value.length > 1) {
			
 
				+                        length += value.length - 1; // commas
			
 
				+                    }
			
 
				+
			
 
				+                    stack.delete(value);
			
 
				+
			
 
				+                    if (space > 0 && value.length > 0) {
			
 
				+                        length += (1 + (stack.size + 1) * space) * value.length; // for each element: \n{space}
			
 
				+                        length += 1 + stack.size * space; // for ]
			
 
				+                    }
			
 
				+
			
 
				+                    visited.set(value, length - valueLength);
			
 
				+
			
 
				+                    break;
			
 
				+                }
			
 
				+
			
 
				+                case PROMISE:
			
 
				+                case STRING_STREAM:
			
 
				+                    async.add(value);
			
 
				+                    break;
			
 
				+
			
 
				+                case OBJECT_STREAM:
			
 
				+                    length += 2; // []
			
 
				+                    async.add(value);
			
 
				+                    break;
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        let allowlist = null;
			
 
				+        replacer = normalizeReplacer(replacer);
			
 
				+
			
 
				+        if (Array.isArray(replacer)) {
			
 
				+            allowlist = new Set(replacer);
			
 
				+            replacer = null;
			
 
				+        }
			
 
				+
			
 
				+        space = spaceLength(space);
			
 
				+        options = options || {};
			
 
				+
			
 
				+        const visited = new Map();
			
 
				+        const stack = new Set();
			
 
				+        const duplicate = new Set();
			
 
				+        const circular = new Set();
			
 
				+        const async = new Set();
			
 
				+        const getType = options.async ? getTypeAsync : getTypeNative;
			
 
				+        const root = { '': value };
			
 
				+        let stop = false;
			
 
				+        let length = 0;
			
 
				+
			
 
				+        walk(root, '', value);
			
 
				+
			
 
				+        return {
			
 
				+            minLength: isNaN(length) ? Infinity : length,
			
 
				+            circular: [...circular],
			
 
				+            duplicate: [...duplicate],
			
 
				+            async: [...async]
			
 
				+        };
			
 
				+    };
			
 
				+
			
 
				+    var stringifyStreamBrowser = () => {
			
 
				+        throw new Error('Method is not supported');
			
 
				+    };
			
 
				+
			
 
				+    var textDecoderBrowser = TextDecoder;
			
 
				+
			
 
				+    const { isReadableStream } = utils;
			
 
				+
			
 
				+
			
 
				+    const STACK_OBJECT = 1;
			
 
				+    const STACK_ARRAY = 2;
			
 
				+    const decoder = new textDecoderBrowser();
			
 
				+
			
 
				+    function isObject(value) {
			
 
				+        return value !== null && typeof value === 'object';
			
 
				+    }
			
 
				+
			
 
				+    function adjustPosition(error, parser) {
			
 
				+        if (error.name === 'SyntaxError' && parser.jsonParseOffset) {
			
 
				+            error.message = error.message.replace(/at position (\d+)/, (_, pos) =>
			
 
				+                'at position ' + (Number(pos) + parser.jsonParseOffset)
			
 
				+            );
			
 
				+        }
			
 
				+
			
 
				+        return error;
			
 
				+    }
			
 
				+
			
 
				+    function append(array, elements) {
			
 
				+        // Note: Avoid to use array.push(...elements) since it may lead to
			
 
				+        // "RangeError: Maximum call stack size exceeded" for a long arrays
			
 
				+        const initialLength = array.length;
			
 
				+        array.length += elements.length;
			
 
				+
			
 
				+        for (let i = 0; i < elements.length; i++) {
			
 
				+            array[initialLength + i] = elements[i];
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    var parseChunked = function(chunkEmitter) {
			
 
				+        let parser = new ChunkParser();
			
 
				+
			
 
				+        if (isObject(chunkEmitter) && isReadableStream(chunkEmitter)) {
			
 
				+            return new Promise((resolve, reject) => {
			
 
				+                chunkEmitter
			
 
				+                    .on('data', chunk => {
			
 
				+                        try {
			
 
				+                            parser.push(chunk);
			
 
				+                        } catch (e) {
			
 
				+                            reject(adjustPosition(e, parser));
			
 
				+                            parser = null;
			
 
				+                        }
			
 
				+                    })
			
 
				+                    .on('error', (e) => {
			
 
				+                        parser = null;
			
 
				+                        reject(e);
			
 
				+                    })
			
 
				+                    .on('end', () => {
			
 
				+                        try {
			
 
				+                            resolve(parser.finish());
			
 
				+                        } catch (e) {
			
 
				+                            reject(adjustPosition(e, parser));
			
 
				+                        } finally {
			
 
				+                            parser = null;
			
 
				+                        }
			
 
				+                    });
			
 
				+            });
			
 
				+        }
			
 
				+
			
 
				+        if (typeof chunkEmitter === 'function') {
			
 
				+            const iterator = chunkEmitter();
			
 
				+
			
 
				+            if (isObject(iterator) && (Symbol.iterator in iterator || Symbol.asyncIterator in iterator)) {
			
 
				+                return new Promise(async (resolve, reject) => {
			
 
				+                    try {
			
 
				+                        for await (const chunk of iterator) {
			
 
				+                            parser.push(chunk);
			
 
				+                        }
			
 
				+
			
 
				+                        resolve(parser.finish());
			
 
				+                    } catch (e) {
			
 
				+                        reject(adjustPosition(e, parser));
			
 
				+                    } finally {
			
 
				+                        parser = null;
			
 
				+                    }
			
 
				+                });
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        throw new Error(
			
 
				+            'Chunk emitter should be readable stream, generator, ' +
			
 
				+            'async generator or function returning an iterable object'
			
 
				+        );
			
 
				+    };
			
 
				+
			
 
				+    class ChunkParser {
			
 
				+        constructor() {
			
 
				+            this.value = undefined;
			
 
				+            this.valueStack = null;
			
 
				+
			
 
				+            this.stack = new Array(100);
			
 
				+            this.lastFlushDepth = 0;
			
 
				+            this.flushDepth = 0;
			
 
				+            this.stateString = false;
			
 
				+            this.stateStringEscape = false;
			
 
				+            this.pendingByteSeq = null;
			
 
				+            this.pendingChunk = null;
			
 
				+            this.chunkOffset = 0;
			
 
				+            this.jsonParseOffset = 0;
			
 
				+        }
			
 
				+
			
 
				+        parseAndAppend(fragment, wrap) {
			
 
				+            // Append new entries or elements
			
 
				+            if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
			
 
				+                if (wrap) {
			
 
				+                    this.jsonParseOffset--;
			
 
				+                    fragment = '{' + fragment + '}';
			
 
				+                }
			
 
				+
			
 
				+                Object.assign(this.valueStack.value, JSON.parse(fragment));
			
 
				+            } else {
			
 
				+                if (wrap) {
			
 
				+                    this.jsonParseOffset--;
			
 
				+                    fragment = '[' + fragment + ']';
			
 
				+                }
			
 
				+
			
 
				+                append(this.valueStack.value, JSON.parse(fragment));
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        prepareAddition(fragment) {
			
 
				+            const { value } = this.valueStack;
			
 
				+            const expectComma = Array.isArray(value)
			
 
				+                ? value.length !== 0
			
 
				+                : Object.keys(value).length !== 0;
			
 
				+
			
 
				+            if (expectComma) {
			
 
				+                // Skip a comma at the beginning of fragment, otherwise it would
			
 
				+                // fail to parse
			
 
				+                if (fragment[0] === ',') {
			
 
				+                    this.jsonParseOffset++;
			
 
				+                    return fragment.slice(1);
			
 
				+                }
			
 
				+
			
 
				+                // When value (an object or array) is not empty and a fragment
			
 
				+                // doesn't start with a comma, a single valid fragment starting
			
 
				+                // is a closing bracket. If it's not, a prefix is adding to fail
			
 
				+                // parsing. Otherwise, the sequence of chunks can be successfully
			
 
				+                // parsed, although it should not, e.g. ["[{}", "{}]"]
			
 
				+                if (fragment[0] !== '}' && fragment[0] !== ']') {
			
 
				+                    this.jsonParseOffset -= 3;
			
 
				+                    return '[[]' + fragment;
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            return fragment;
			
 
				+        }
			
 
				+
			
 
				+        flush(chunk, start, end) {
			
 
				+            let fragment = chunk.slice(start, end);
			
 
				+
			
 
				+            // Save position correction an error in JSON.parse() if any
			
 
				+            this.jsonParseOffset = this.chunkOffset + start;
			
 
				+
			
 
				+            // Prepend pending chunk if any
			
 
				+            if (this.pendingChunk !== null) {
			
 
				+                fragment = this.pendingChunk + fragment;
			
 
				+                this.jsonParseOffset -= this.pendingChunk.length;
			
 
				+                this.pendingChunk = null;
			
 
				+            }
			
 
				+
			
 
				+            if (this.flushDepth === this.lastFlushDepth) {
			
 
				+                // Depth didn't changed, so it's a root value or entry/element set
			
 
				+                if (this.flushDepth > 0) {
			
 
				+                    this.parseAndAppend(this.prepareAddition(fragment), true);
			
 
				+                } else {
			
 
				+                    // That's an entire value on a top level
			
 
				+                    this.value = JSON.parse(fragment);
			
 
				+                    this.valueStack = {
			
 
				+                        value: this.value,
			
 
				+                        prev: null
			
 
				+                    };
			
 
				+                }
			
 
				+            } else if (this.flushDepth > this.lastFlushDepth) {
			
 
				+                // Add missed closing brackets/parentheses
			
 
				+                for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {
			
 
				+                    fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';
			
 
				+                }
			
 
				+
			
 
				+                if (this.lastFlushDepth === 0) {
			
 
				+                    // That's a root value
			
 
				+                    this.value = JSON.parse(fragment);
			
 
				+                    this.valueStack = {
			
 
				+                        value: this.value,
			
 
				+                        prev: null
			
 
				+                    };
			
 
				+                } else {
			
 
				+                    this.parseAndAppend(this.prepareAddition(fragment), true);
			
 
				+                }
			
 
				+
			
 
				+                // Move down to the depths to the last object/array, which is current now
			
 
				+                for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
			
 
				+                    let value = this.valueStack.value;
			
 
				+
			
 
				+                    if (this.stack[i - 1] === STACK_OBJECT) {
			
 
				+                        // find last entry
			
 
				+                        let key;
			
 
				+                        // eslint-disable-next-line curly
			
 
				+                        for (key in value);
			
 
				+                        value = value[key];
			
 
				+                    } else {
			
 
				+                        // last element
			
 
				+                        value = value[value.length - 1];
			
 
				+                    }
			
 
				+
			
 
				+                    this.valueStack = {
			
 
				+                        value,
			
 
				+                        prev: this.valueStack
			
 
				+                    };
			
 
				+                }
			
 
				+            } else /* this.flushDepth < this.lastFlushDepth */ {
			
 
				+                fragment = this.prepareAddition(fragment);
			
 
				+
			
 
				+                // Add missed opening brackets/parentheses
			
 
				+                for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
			
 
				+                    this.jsonParseOffset--;
			
 
				+                    fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;
			
 
				+                }
			
 
				+
			
 
				+                this.parseAndAppend(fragment, false);
			
 
				+
			
 
				+                for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
			
 
				+                    this.valueStack = this.valueStack.prev;
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            this.lastFlushDepth = this.flushDepth;
			
 
				+        }
			
 
				+
			
 
				+        push(chunk) {
			
 
				+            if (typeof chunk !== 'string') {
			
 
				+                // Suppose chunk is Buffer or Uint8Array
			
 
				+
			
 
				+                // Prepend uncompleted byte sequence if any
			
 
				+                if (this.pendingByteSeq !== null) {
			
 
				+                    const origRawChunk = chunk;
			
 
				+                    chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
			
 
				+                    chunk.set(this.pendingByteSeq);
			
 
				+                    chunk.set(origRawChunk, this.pendingByteSeq.length);
			
 
				+                    this.pendingByteSeq = null;
			
 
				+                }
			
 
				+
			
 
				+                // In case Buffer/Uint8Array, an input is encoded in UTF8
			
 
				+                // Seek for parts of uncompleted UTF8 symbol on the ending
			
 
				+                // This makes sense only if we expect more chunks and last char is not multi-bytes
			
 
				+                if (chunk[chunk.length - 1] > 127) {
			
 
				+                    for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
			
 
				+                        const byte = chunk[chunk.length - 1 - seqLength];
			
 
				+
			
 
				+                        // 10xxxxxx - 2nd, 3rd or 4th byte
			
 
				+                        // 110xxxxx – first byte of 2-byte sequence
			
 
				+                        // 1110xxxx - first byte of 3-byte sequence
			
 
				+                        // 11110xxx - first byte of 4-byte sequence
			
 
				+                        if (byte >> 6 === 3) {
			
 
				+                            seqLength++;
			
 
				+
			
 
				+                            // If the sequence is really incomplete, then preserve it
			
 
				+                            // for the future chunk and cut off it from the current chunk
			
 
				+                            if ((seqLength !== 4 && byte >> 3 === 0b11110) ||
			
 
				+                                (seqLength !== 3 && byte >> 4 === 0b1110) ||
			
 
				+                                (seqLength !== 2 && byte >> 5 === 0b110)) {
			
 
				+                                this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
			
 
				+                                chunk = chunk.slice(0, -seqLength);
			
 
				+                            }
			
 
				+
			
 
				+                            break;
			
 
				+                        }
			
 
				+                    }
			
 
				+                }
			
 
				+
			
 
				+                // Convert chunk to a string, since single decode per chunk
			
 
				+                // is much effective than decode multiple small substrings
			
 
				+                chunk = decoder.decode(chunk);
			
 
				+            }
			
 
				+
			
 
				+            const chunkLength = chunk.length;
			
 
				+            let lastFlushPoint = 0;
			
 
				+            let flushPoint = 0;
			
 
				+
			
 
				+            // Main scan loop
			
 
				+            scan: for (let i = 0; i < chunkLength; i++) {
			
 
				+                if (this.stateString) {
			
 
				+                    for (; i < chunkLength; i++) {
			
 
				+                        if (this.stateStringEscape) {
			
 
				+                            this.stateStringEscape = false;
			
 
				+                        } else {
			
 
				+                            switch (chunk.charCodeAt(i)) {
			
 
				+                                case 0x22: /* " */
			
 
				+                                    this.stateString = false;
			
 
				+                                    continue scan;
			
 
				+
			
 
				+                                case 0x5C: /* \ */
			
 
				+                                    this.stateStringEscape = true;
			
 
				+                            }
			
 
				+                        }
			
 
				+                    }
			
 
				+
			
 
				+                    break;
			
 
				+                }
			
 
				+
			
 
				+                switch (chunk.charCodeAt(i)) {
			
 
				+                    case 0x22: /* " */
			
 
				+                        this.stateString = true;
			
 
				+                        this.stateStringEscape = false;
			
 
				+                        break;
			
 
				+
			
 
				+                    case 0x2C: /* , */
			
 
				+                        flushPoint = i;
			
 
				+                        break;
			
 
				+
			
 
				+                    case 0x7B: /* { */
			
 
				+                        // Open an object
			
 
				+                        flushPoint = i + 1;
			
 
				+                        this.stack[this.flushDepth++] = STACK_OBJECT;
			
 
				+                        break;
			
 
				+
			
 
				+                    case 0x5B: /* [ */
			
 
				+                        // Open an array
			
 
				+                        flushPoint = i + 1;
			
 
				+                        this.stack[this.flushDepth++] = STACK_ARRAY;
			
 
				+                        break;
			
 
				+
			
 
				+                    case 0x5D: /* ] */
			
 
				+                    case 0x7D: /* } */
			
 
				+                        // Close an object or array
			
 
				+                        flushPoint = i + 1;
			
 
				+                        this.flushDepth--;
			
 
				+
			
 
				+                        if (this.flushDepth < this.lastFlushDepth) {
			
 
				+                            this.flush(chunk, lastFlushPoint, flushPoint);
			
 
				+                            lastFlushPoint = flushPoint;
			
 
				+                        }
			
 
				+
			
 
				+                        break;
			
 
				+
			
 
				+                    case 0x09: /* \t */
			
 
				+                    case 0x0A: /* \n */
			
 
				+                    case 0x0D: /* \r */
			
 
				+                    case 0x20: /* space */
			
 
				+                        // Move points forward when they points on current position and it's a whitespace
			
 
				+                        if (lastFlushPoint === i) {
			
 
				+                            lastFlushPoint++;
			
 
				+                        }
			
 
				+
			
 
				+                        if (flushPoint === i) {
			
 
				+                            flushPoint++;
			
 
				+                        }
			
 
				+
			
 
				+                        break;
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            if (flushPoint > lastFlushPoint) {
			
 
				+                this.flush(chunk, lastFlushPoint, flushPoint);
			
 
				+            }
			
 
				+
			
 
				+            // Produce pendingChunk if something left
			
 
				+            if (flushPoint < chunkLength) {
			
 
				+                if (this.pendingChunk !== null) {
			
 
				+                    // When there is already a pending chunk then no flush happened,
			
 
				+                    // appending entire chunk to pending one
			
 
				+                    this.pendingChunk += chunk;
			
 
				+                } else {
			
 
				+                    // Create a pending chunk, it will start with non-whitespace since
			
 
				+                    // flushPoint was moved forward away from whitespaces on scan
			
 
				+                    this.pendingChunk = chunk.slice(flushPoint, chunkLength);
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            this.chunkOffset += chunkLength;
			
 
				+        }
			
 
				+
			
 
				+        finish() {
			
 
				+            if (this.pendingChunk !== null) {
			
 
				+                this.flush('', 0, 0);
			
 
				+                this.pendingChunk = null;
			
 
				+            }
			
 
				+
			
 
				+            return this.value;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    var src = {
			
 
				+        version: version,
			
 
				+        stringifyInfo: stringifyInfo,
			
 
				+        stringifyStream: stringifyStreamBrowser,
			
 
				+        parseChunked: parseChunked
			
 
				+    };
			
 
				+
			
 
				+    return src;
			
 
				+
			
 
				+}));
			
--- a/day37/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js
+++ b/day37/node_modules/@discoveryjs/json-ext/dist/json-ext.min.js
--- a/day37/node_modules/@discoveryjs/json-ext/dist/version.js
+++ b/day37/node_modules/@discoveryjs/json-ext/dist/version.js
@@ -0,0 +1 @@
 
				+module.exports = "0.5.7";
			
--- a/day37/node_modules/@discoveryjs/json-ext/index.d.ts
+++ b/day37/node_modules/@discoveryjs/json-ext/index.d.ts
@@ -0,0 +1,31 @@
 
				+declare module '@discoveryjs/json-ext' {
			
 
				+    import { Readable } from 'stream';
			
 
				+
			
 
				+    type TReplacer =
			
 
				+        | ((this: any, key: string, value: any) => any)
			
 
				+        | string[]
			
 
				+        | number[]
			
 
				+        | null;
			
 
				+    type TSpace = string | number | null;
			
 
				+    type TChunk = string | Buffer | Uint8Array;
			
 
				+
			
 
				+    export function parseChunked(input: Readable): Promise<any>;
			
 
				+    export function parseChunked(input: () => (Iterable<TChunk> | AsyncIterable<TChunk>)): Promise<any>;
			
 
				+
			
 
				+    export function stringifyStream(value: any, replacer?: TReplacer, space?: TSpace): Readable;
			
 
				+
			
 
				+    export function stringifyInfo(
			
 
				+        value: any,
			
 
				+        replacer?: TReplacer,
			
 
				+        space?: TSpace,
			
 
				+        options?: {
			
 
				+            async?: boolean;
			
 
				+            continueOnCircular?: boolean;
			
 
				+        }
			
 
				+    ): {
			
 
				+        minLength: number;
			
 
				+        circular: any[];
			
 
				+        duplicate: any[];
			
 
				+        async: any[];
			
 
				+    };
			
 
				+}
			
--- a/day37/node_modules/@discoveryjs/json-ext/package.json
+++ b/day37/node_modules/@discoveryjs/json-ext/package.json
@@ -0,0 +1,56 @@
 
				+{
			
 
				+    "name": "@discoveryjs/json-ext",
			
 
				+    "version": "0.5.7",
			
 
				+    "description": "A set of utilities that extend the use of JSON",
			
 
				+    "keywords": [
			
 
				+        "json",
			
 
				+        "utils",
			
 
				+        "stream",
			
 
				+        "async",
			
 
				+        "promise",
			
 
				+        "stringify",
			
 
				+        "info"
			
 
				+    ],
			
 
				+    "author": "Roman Dvornov <rdvornov@gmail.com> (https://github.com/lahmatiy)",
			
 
				+    "license": "MIT",
			
 
				+    "repository": "discoveryjs/json-ext",
			
 
				+    "main": "./src/index",
			
 
				+    "browser": {
			
 
				+        "./src/stringify-stream.js": "./src/stringify-stream-browser.js",
			
 
				+        "./src/text-decoder.js": "./src/text-decoder-browser.js",
			
 
				+        "./src/version.js": "./dist/version.js"
			
 
				+    },
			
 
				+    "types": "./index.d.ts",
			
 
				+    "scripts": {
			
 
				+        "test": "mocha --reporter progress",
			
 
				+        "lint": "eslint src test",
			
 
				+        "lint-and-test": "npm run lint && npm test",
			
 
				+        "build": "rollup --config",
			
 
				+        "test:all": "npm run test:src && npm run test:dist",
			
 
				+        "test:src": "npm test",
			
 
				+        "test:dist": "cross-env MODE=dist npm test && cross-env MODE=dist-min npm test",
			
 
				+        "build-and-test": "npm run build && npm run test:dist",
			
 
				+        "coverage": "c8 --reporter=lcovonly npm test",
			
 
				+        "prepublishOnly": "npm run lint && npm test && npm run build-and-test"
			
 
				+    },
			
 
				+    "devDependencies": {
			
 
				+        "@rollup/plugin-commonjs": "^15.1.0",
			
 
				+        "@rollup/plugin-json": "^4.1.0",
			
 
				+        "@rollup/plugin-node-resolve": "^9.0.0",
			
 
				+        "c8": "^7.10.0",
			
 
				+        "chalk": "^4.1.0",
			
 
				+        "cross-env": "^7.0.3",
			
 
				+        "eslint": "^8.10.0",
			
 
				+        "mocha": "^8.4.0",
			
 
				+        "rollup": "^2.28.2",
			
 
				+        "rollup-plugin-terser": "^7.0.2"
			
 
				+    },
			
 
				+    "engines": {
			
 
				+        "node": ">=10.0.0"
			
 
				+    },
			
 
				+    "files": [
			
 
				+        "dist",
			
 
				+        "src",
			
 
				+        "index.d.ts"
			
 
				+    ]
			
 
				+}
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/index.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/index.js
@@ -0,0 +1,6 @@
 
				+module.exports = {
			
 
				+    version: require('./version'),
			
 
				+    stringifyInfo: require('./stringify-info'),
			
 
				+    stringifyStream: require('./stringify-stream'),
			
 
				+    parseChunked: require('./parse-chunked')
			
 
				+};
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/parse-chunked.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/parse-chunked.js
@@ -0,0 +1,384 @@
 
				+const { isReadableStream } = require('./utils');
			
 
				+const TextDecoder = require('./text-decoder');
			
 
				+
			
 
				+const STACK_OBJECT = 1;
			
 
				+const STACK_ARRAY = 2;
			
 
				+const decoder = new TextDecoder();
			
 
				+
			
 
				+function isObject(value) {
			
 
				+    return value !== null && typeof value === 'object';
			
 
				+}
			
 
				+
			
 
				+function adjustPosition(error, parser) {
			
 
				+    if (error.name === 'SyntaxError' && parser.jsonParseOffset) {
			
 
				+        error.message = error.message.replace(/at position (\d+)/, (_, pos) =>
			
 
				+            'at position ' + (Number(pos) + parser.jsonParseOffset)
			
 
				+        );
			
 
				+    }
			
 
				+
			
 
				+    return error;
			
 
				+}
			
 
				+
			
 
				+function append(array, elements) {
			
 
				+    // Note: Avoid to use array.push(...elements) since it may lead to
			
 
				+    // "RangeError: Maximum call stack size exceeded" for a long arrays
			
 
				+    const initialLength = array.length;
			
 
				+    array.length += elements.length;
			
 
				+
			
 
				+    for (let i = 0; i < elements.length; i++) {
			
 
				+        array[initialLength + i] = elements[i];
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+module.exports = function(chunkEmitter) {
			
 
				+    let parser = new ChunkParser();
			
 
				+
			
 
				+    if (isObject(chunkEmitter) && isReadableStream(chunkEmitter)) {
			
 
				+        return new Promise((resolve, reject) => {
			
 
				+            chunkEmitter
			
 
				+                .on('data', chunk => {
			
 
				+                    try {
			
 
				+                        parser.push(chunk);
			
 
				+                    } catch (e) {
			
 
				+                        reject(adjustPosition(e, parser));
			
 
				+                        parser = null;
			
 
				+                    }
			
 
				+                })
			
 
				+                .on('error', (e) => {
			
 
				+                    parser = null;
			
 
				+                    reject(e);
			
 
				+                })
			
 
				+                .on('end', () => {
			
 
				+                    try {
			
 
				+                        resolve(parser.finish());
			
 
				+                    } catch (e) {
			
 
				+                        reject(adjustPosition(e, parser));
			
 
				+                    } finally {
			
 
				+                        parser = null;
			
 
				+                    }
			
 
				+                });
			
 
				+        });
			
 
				+    }
			
 
				+
			
 
				+    if (typeof chunkEmitter === 'function') {
			
 
				+        const iterator = chunkEmitter();
			
 
				+
			
 
				+        if (isObject(iterator) && (Symbol.iterator in iterator || Symbol.asyncIterator in iterator)) {
			
 
				+            return new Promise(async (resolve, reject) => {
			
 
				+                try {
			
 
				+                    for await (const chunk of iterator) {
			
 
				+                        parser.push(chunk);
			
 
				+                    }
			
 
				+
			
 
				+                    resolve(parser.finish());
			
 
				+                } catch (e) {
			
 
				+                    reject(adjustPosition(e, parser));
			
 
				+                } finally {
			
 
				+                    parser = null;
			
 
				+                }
			
 
				+            });
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    throw new Error(
			
 
				+        'Chunk emitter should be readable stream, generator, ' +
			
 
				+        'async generator or function returning an iterable object'
			
 
				+    );
			
 
				+};
			
 
				+
			
 
				+class ChunkParser {
			
 
				+    constructor() {
			
 
				+        this.value = undefined;
			
 
				+        this.valueStack = null;
			
 
				+
			
 
				+        this.stack = new Array(100);
			
 
				+        this.lastFlushDepth = 0;
			
 
				+        this.flushDepth = 0;
			
 
				+        this.stateString = false;
			
 
				+        this.stateStringEscape = false;
			
 
				+        this.pendingByteSeq = null;
			
 
				+        this.pendingChunk = null;
			
 
				+        this.chunkOffset = 0;
			
 
				+        this.jsonParseOffset = 0;
			
 
				+    }
			
 
				+
			
 
				+    parseAndAppend(fragment, wrap) {
			
 
				+        // Append new entries or elements
			
 
				+        if (this.stack[this.lastFlushDepth - 1] === STACK_OBJECT) {
			
 
				+            if (wrap) {
			
 
				+                this.jsonParseOffset--;
			
 
				+                fragment = '{' + fragment + '}';
			
 
				+            }
			
 
				+
			
 
				+            Object.assign(this.valueStack.value, JSON.parse(fragment));
			
 
				+        } else {
			
 
				+            if (wrap) {
			
 
				+                this.jsonParseOffset--;
			
 
				+                fragment = '[' + fragment + ']';
			
 
				+            }
			
 
				+
			
 
				+            append(this.valueStack.value, JSON.parse(fragment));
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    prepareAddition(fragment) {
			
 
				+        const { value } = this.valueStack;
			
 
				+        const expectComma = Array.isArray(value)
			
 
				+            ? value.length !== 0
			
 
				+            : Object.keys(value).length !== 0;
			
 
				+
			
 
				+        if (expectComma) {
			
 
				+            // Skip a comma at the beginning of fragment, otherwise it would
			
 
				+            // fail to parse
			
 
				+            if (fragment[0] === ',') {
			
 
				+                this.jsonParseOffset++;
			
 
				+                return fragment.slice(1);
			
 
				+            }
			
 
				+
			
 
				+            // When value (an object or array) is not empty and a fragment
			
 
				+            // doesn't start with a comma, a single valid fragment starting
			
 
				+            // is a closing bracket. If it's not, a prefix is adding to fail
			
 
				+            // parsing. Otherwise, the sequence of chunks can be successfully
			
 
				+            // parsed, although it should not, e.g. ["[{}", "{}]"]
			
 
				+            if (fragment[0] !== '}' && fragment[0] !== ']') {
			
 
				+                this.jsonParseOffset -= 3;
			
 
				+                return '[[]' + fragment;
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        return fragment;
			
 
				+    }
			
 
				+
			
 
				+    flush(chunk, start, end) {
			
 
				+        let fragment = chunk.slice(start, end);
			
 
				+
			
 
				+        // Save position correction an error in JSON.parse() if any
			
 
				+        this.jsonParseOffset = this.chunkOffset + start;
			
 
				+
			
 
				+        // Prepend pending chunk if any
			
 
				+        if (this.pendingChunk !== null) {
			
 
				+            fragment = this.pendingChunk + fragment;
			
 
				+            this.jsonParseOffset -= this.pendingChunk.length;
			
 
				+            this.pendingChunk = null;
			
 
				+        }
			
 
				+
			
 
				+        if (this.flushDepth === this.lastFlushDepth) {
			
 
				+            // Depth didn't changed, so it's a root value or entry/element set
			
 
				+            if (this.flushDepth > 0) {
			
 
				+                this.parseAndAppend(this.prepareAddition(fragment), true);
			
 
				+            } else {
			
 
				+                // That's an entire value on a top level
			
 
				+                this.value = JSON.parse(fragment);
			
 
				+                this.valueStack = {
			
 
				+                    value: this.value,
			
 
				+                    prev: null
			
 
				+                };
			
 
				+            }
			
 
				+        } else if (this.flushDepth > this.lastFlushDepth) {
			
 
				+            // Add missed closing brackets/parentheses
			
 
				+            for (let i = this.flushDepth - 1; i >= this.lastFlushDepth; i--) {
			
 
				+                fragment += this.stack[i] === STACK_OBJECT ? '}' : ']';
			
 
				+            }
			
 
				+
			
 
				+            if (this.lastFlushDepth === 0) {
			
 
				+                // That's a root value
			
 
				+                this.value = JSON.parse(fragment);
			
 
				+                this.valueStack = {
			
 
				+                    value: this.value,
			
 
				+                    prev: null
			
 
				+                };
			
 
				+            } else {
			
 
				+                this.parseAndAppend(this.prepareAddition(fragment), true);
			
 
				+            }
			
 
				+
			
 
				+            // Move down to the depths to the last object/array, which is current now
			
 
				+            for (let i = this.lastFlushDepth || 1; i < this.flushDepth; i++) {
			
 
				+                let value = this.valueStack.value;
			
 
				+
			
 
				+                if (this.stack[i - 1] === STACK_OBJECT) {
			
 
				+                    // find last entry
			
 
				+                    let key;
			
 
				+                    // eslint-disable-next-line curly
			
 
				+                    for (key in value);
			
 
				+                    value = value[key];
			
 
				+                } else {
			
 
				+                    // last element
			
 
				+                    value = value[value.length - 1];
			
 
				+                }
			
 
				+
			
 
				+                this.valueStack = {
			
 
				+                    value,
			
 
				+                    prev: this.valueStack
			
 
				+                };
			
 
				+            }
			
 
				+        } else /* this.flushDepth < this.lastFlushDepth */ {
			
 
				+            fragment = this.prepareAddition(fragment);
			
 
				+
			
 
				+            // Add missed opening brackets/parentheses
			
 
				+            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
			
 
				+                this.jsonParseOffset--;
			
 
				+                fragment = (this.stack[i] === STACK_OBJECT ? '{' : '[') + fragment;
			
 
				+            }
			
 
				+
			
 
				+            this.parseAndAppend(fragment, false);
			
 
				+
			
 
				+            for (let i = this.lastFlushDepth - 1; i >= this.flushDepth; i--) {
			
 
				+                this.valueStack = this.valueStack.prev;
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        this.lastFlushDepth = this.flushDepth;
			
 
				+    }
			
 
				+
			
 
				+    push(chunk) {
			
 
				+        if (typeof chunk !== 'string') {
			
 
				+            // Suppose chunk is Buffer or Uint8Array
			
 
				+
			
 
				+            // Prepend uncompleted byte sequence if any
			
 
				+            if (this.pendingByteSeq !== null) {
			
 
				+                const origRawChunk = chunk;
			
 
				+                chunk = new Uint8Array(this.pendingByteSeq.length + origRawChunk.length);
			
 
				+                chunk.set(this.pendingByteSeq);
			
 
				+                chunk.set(origRawChunk, this.pendingByteSeq.length);
			
 
				+                this.pendingByteSeq = null;
			
 
				+            }
			
 
				+
			
 
				+            // In case Buffer/Uint8Array, an input is encoded in UTF8
			
 
				+            // Seek for parts of uncompleted UTF8 symbol on the ending
			
 
				+            // This makes sense only if we expect more chunks and last char is not multi-bytes
			
 
				+            if (chunk[chunk.length - 1] > 127) {
			
 
				+                for (let seqLength = 0; seqLength < chunk.length; seqLength++) {
			
 
				+                    const byte = chunk[chunk.length - 1 - seqLength];
			
 
				+
			
 
				+                    // 10xxxxxx - 2nd, 3rd or 4th byte
			
 
				+                    // 110xxxxx – first byte of 2-byte sequence
			
 
				+                    // 1110xxxx - first byte of 3-byte sequence
			
 
				+                    // 11110xxx - first byte of 4-byte sequence
			
 
				+                    if (byte >> 6 === 3) {
			
 
				+                        seqLength++;
			
 
				+
			
 
				+                        // If the sequence is really incomplete, then preserve it
			
 
				+                        // for the future chunk and cut off it from the current chunk
			
 
				+                        if ((seqLength !== 4 && byte >> 3 === 0b11110) ||
			
 
				+                            (seqLength !== 3 && byte >> 4 === 0b1110) ||
			
 
				+                            (seqLength !== 2 && byte >> 5 === 0b110)) {
			
 
				+                            this.pendingByteSeq = chunk.slice(chunk.length - seqLength);
			
 
				+                            chunk = chunk.slice(0, -seqLength);
			
 
				+                        }
			
 
				+
			
 
				+                        break;
			
 
				+                    }
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            // Convert chunk to a string, since single decode per chunk
			
 
				+            // is much effective than decode multiple small substrings
			
 
				+            chunk = decoder.decode(chunk);
			
 
				+        }
			
 
				+
			
 
				+        const chunkLength = chunk.length;
			
 
				+        let lastFlushPoint = 0;
			
 
				+        let flushPoint = 0;
			
 
				+
			
 
				+        // Main scan loop
			
 
				+        scan: for (let i = 0; i < chunkLength; i++) {
			
 
				+            if (this.stateString) {
			
 
				+                for (; i < chunkLength; i++) {
			
 
				+                    if (this.stateStringEscape) {
			
 
				+                        this.stateStringEscape = false;
			
 
				+                    } else {
			
 
				+                        switch (chunk.charCodeAt(i)) {
			
 
				+                            case 0x22: /* " */
			
 
				+                                this.stateString = false;
			
 
				+                                continue scan;
			
 
				+
			
 
				+                            case 0x5C: /* \ */
			
 
				+                                this.stateStringEscape = true;
			
 
				+                        }
			
 
				+                    }
			
 
				+                }
			
 
				+
			
 
				+                break;
			
 
				+            }
			
 
				+
			
 
				+            switch (chunk.charCodeAt(i)) {
			
 
				+                case 0x22: /* " */
			
 
				+                    this.stateString = true;
			
 
				+                    this.stateStringEscape = false;
			
 
				+                    break;
			
 
				+
			
 
				+                case 0x2C: /* , */
			
 
				+                    flushPoint = i;
			
 
				+                    break;
			
 
				+
			
 
				+                case 0x7B: /* { */
			
 
				+                    // Open an object
			
 
				+                    flushPoint = i + 1;
			
 
				+                    this.stack[this.flushDepth++] = STACK_OBJECT;
			
 
				+                    break;
			
 
				+
			
 
				+                case 0x5B: /* [ */
			
 
				+                    // Open an array
			
 
				+                    flushPoint = i + 1;
			
 
				+                    this.stack[this.flushDepth++] = STACK_ARRAY;
			
 
				+                    break;
			
 
				+
			
 
				+                case 0x5D: /* ] */
			
 
				+                case 0x7D: /* } */
			
 
				+                    // Close an object or array
			
 
				+                    flushPoint = i + 1;
			
 
				+                    this.flushDepth--;
			
 
				+
			
 
				+                    if (this.flushDepth < this.lastFlushDepth) {
			
 
				+                        this.flush(chunk, lastFlushPoint, flushPoint);
			
 
				+                        lastFlushPoint = flushPoint;
			
 
				+                    }
			
 
				+
			
 
				+                    break;
			
 
				+
			
 
				+                case 0x09: /* \t */
			
 
				+                case 0x0A: /* \n */
			
 
				+                case 0x0D: /* \r */
			
 
				+                case 0x20: /* space */
			
 
				+                    // Move points forward when they points on current position and it's a whitespace
			
 
				+                    if (lastFlushPoint === i) {
			
 
				+                        lastFlushPoint++;
			
 
				+                    }
			
 
				+
			
 
				+                    if (flushPoint === i) {
			
 
				+                        flushPoint++;
			
 
				+                    }
			
 
				+
			
 
				+                    break;
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        if (flushPoint > lastFlushPoint) {
			
 
				+            this.flush(chunk, lastFlushPoint, flushPoint);
			
 
				+        }
			
 
				+
			
 
				+        // Produce pendingChunk if something left
			
 
				+        if (flushPoint < chunkLength) {
			
 
				+            if (this.pendingChunk !== null) {
			
 
				+                // When there is already a pending chunk then no flush happened,
			
 
				+                // appending entire chunk to pending one
			
 
				+                this.pendingChunk += chunk;
			
 
				+            } else {
			
 
				+                // Create a pending chunk, it will start with non-whitespace since
			
 
				+                // flushPoint was moved forward away from whitespaces on scan
			
 
				+                this.pendingChunk = chunk.slice(flushPoint, chunkLength);
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        this.chunkOffset += chunkLength;
			
 
				+    }
			
 
				+
			
 
				+    finish() {
			
 
				+        if (this.pendingChunk !== null) {
			
 
				+            this.flush('', 0, 0);
			
 
				+            this.pendingChunk = null;
			
 
				+        }
			
 
				+
			
 
				+        return this.value;
			
 
				+    }
			
 
				+};
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/stringify-info.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/stringify-info.js
@@ -0,0 +1,231 @@
 
				+const {
			
 
				+    normalizeReplacer,
			
 
				+    normalizeSpace,
			
 
				+    replaceValue,
			
 
				+    getTypeNative,
			
 
				+    getTypeAsync,
			
 
				+    isLeadingSurrogate,
			
 
				+    isTrailingSurrogate,
			
 
				+    escapableCharCodeSubstitution,
			
 
				+    type: {
			
 
				+        PRIMITIVE,
			
 
				+        OBJECT,
			
 
				+        ARRAY,
			
 
				+        PROMISE,
			
 
				+        STRING_STREAM,
			
 
				+        OBJECT_STREAM
			
 
				+    }
			
 
				+} = require('./utils');
			
 
				+const charLength2048 = Array.from({ length: 2048 }).map((_, code) => {
			
 
				+    if (escapableCharCodeSubstitution.hasOwnProperty(code)) {
			
 
				+        return 2; // \X
			
 
				+    }
			
 
				+
			
 
				+    if (code < 0x20) {
			
 
				+        return 6; // \uXXXX
			
 
				+    }
			
 
				+
			
 
				+    return code < 128 ? 1 : 2; // UTF8 bytes
			
 
				+});
			
 
				+
			
 
				+function stringLength(str) {
			
 
				+    let len = 0;
			
 
				+    let prevLeadingSurrogate = false;
			
 
				+
			
 
				+    for (let i = 0; i < str.length; i++) {
			
 
				+        const code = str.charCodeAt(i);
			
 
				+
			
 
				+        if (code < 2048) {
			
 
				+            len += charLength2048[code];
			
 
				+        } else if (isLeadingSurrogate(code)) {
			
 
				+            len += 6; // \uXXXX since no pair with trailing surrogate yet
			
 
				+            prevLeadingSurrogate = true;
			
 
				+            continue;
			
 
				+        } else if (isTrailingSurrogate(code)) {
			
 
				+            len = prevLeadingSurrogate
			
 
				+                ? len - 2  // surrogate pair (4 bytes), since we calculate prev leading surrogate as 6 bytes, substruct 2 bytes
			
 
				+                : len + 6; // \uXXXX
			
 
				+        } else {
			
 
				+            len += 3; // code >= 2048 is 3 bytes length for UTF8
			
 
				+        }
			
 
				+
			
 
				+        prevLeadingSurrogate = false;
			
 
				+    }
			
 
				+
			
 
				+    return len + 2; // +2 for quotes
			
 
				+}
			
 
				+
			
 
				+function primitiveLength(value) {
			
 
				+    switch (typeof value) {
			
 
				+        case 'string':
			
 
				+            return stringLength(value);
			
 
				+
			
 
				+        case 'number':
			
 
				+            return Number.isFinite(value) ? String(value).length : 4 /* null */;
			
 
				+
			
 
				+        case 'boolean':
			
 
				+            return value ? 4 /* true */ : 5 /* false */;
			
 
				+
			
 
				+        case 'undefined':
			
 
				+        case 'object':
			
 
				+            return 4; /* null */
			
 
				+
			
 
				+        default:
			
 
				+            return 0;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+function spaceLength(space) {
			
 
				+    space = normalizeSpace(space);
			
 
				+    return typeof space === 'string' ? space.length : 0;
			
 
				+}
			
 
				+
			
 
				+module.exports = function jsonStringifyInfo(value, replacer, space, options) {
			
 
				+    function walk(holder, key, value) {
			
 
				+        if (stop) {
			
 
				+            return;
			
 
				+        }
			
 
				+
			
 
				+        value = replaceValue(holder, key, value, replacer);
			
 
				+
			
 
				+        let type = getType(value);
			
 
				+
			
 
				+        // check for circular structure
			
 
				+        if (type !== PRIMITIVE && stack.has(value)) {
			
 
				+            circular.add(value);
			
 
				+            length += 4; // treat as null
			
 
				+
			
 
				+            if (!options.continueOnCircular) {
			
 
				+                stop = true;
			
 
				+            }
			
 
				+
			
 
				+            return;
			
 
				+        }
			
 
				+
			
 
				+        switch (type) {
			
 
				+            case PRIMITIVE:
			
 
				+                if (value !== undefined || Array.isArray(holder)) {
			
 
				+                    length += primitiveLength(value);
			
 
				+                } else if (holder === root) {
			
 
				+                    length += 9; // FIXME: that's the length of undefined, should we normalize behaviour to convert it to null?
			
 
				+                }
			
 
				+                break;
			
 
				+
			
 
				+            case OBJECT: {
			
 
				+                if (visited.has(value)) {
			
 
				+                    duplicate.add(value);
			
 
				+                    length += visited.get(value);
			
 
				+                    break;
			
 
				+                }
			
 
				+
			
 
				+                const valueLength = length;
			
 
				+                let entries = 0;
			
 
				+
			
 
				+                length += 2; // {}
			
 
				+
			
 
				+                stack.add(value);
			
 
				+
			
 
				+                for (const key in value) {
			
 
				+                    if (hasOwnProperty.call(value, key) && (allowlist === null || allowlist.has(key))) {
			
 
				+                        const prevLength = length;
			
 
				+                        walk(value, key, value[key]);
			
 
				+
			
 
				+                        if (prevLength !== length) {
			
 
				+                            // value is printed
			
 
				+                            length += stringLength(key) + 1; // "key":
			
 
				+                            entries++;
			
 
				+                        }
			
 
				+                    }
			
 
				+                }
			
 
				+
			
 
				+                if (entries > 1) {
			
 
				+                    length += entries - 1; // commas
			
 
				+                }
			
 
				+
			
 
				+                stack.delete(value);
			
 
				+
			
 
				+                if (space > 0 && entries > 0) {
			
 
				+                    length += (1 + (stack.size + 1) * space + 1) * entries; // for each key-value: \n{space}
			
 
				+                    length += 1 + stack.size * space; // for }
			
 
				+                }
			
 
				+
			
 
				+                visited.set(value, length - valueLength);
			
 
				+
			
 
				+                break;
			
 
				+            }
			
 
				+
			
 
				+            case ARRAY: {
			
 
				+                if (visited.has(value)) {
			
 
				+                    duplicate.add(value);
			
 
				+                    length += visited.get(value);
			
 
				+                    break;
			
 
				+                }
			
 
				+
			
 
				+                const valueLength = length;
			
 
				+
			
 
				+                length += 2; // []
			
 
				+
			
 
				+                stack.add(value);
			
 
				+
			
 
				+                for (let i = 0; i < value.length; i++) {
			
 
				+                    walk(value, i, value[i]);
			
 
				+                }
			
 
				+
			
 
				+                if (value.length > 1) {
			
 
				+                    length += value.length - 1; // commas
			
 
				+                }
			
 
				+
			
 
				+                stack.delete(value);
			
 
				+
			
 
				+                if (space > 0 && value.length > 0) {
			
 
				+                    length += (1 + (stack.size + 1) * space) * value.length; // for each element: \n{space}
			
 
				+                    length += 1 + stack.size * space; // for ]
			
 
				+                }
			
 
				+
			
 
				+                visited.set(value, length - valueLength);
			
 
				+
			
 
				+                break;
			
 
				+            }
			
 
				+
			
 
				+            case PROMISE:
			
 
				+            case STRING_STREAM:
			
 
				+                async.add(value);
			
 
				+                break;
			
 
				+
			
 
				+            case OBJECT_STREAM:
			
 
				+                length += 2; // []
			
 
				+                async.add(value);
			
 
				+                break;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    let allowlist = null;
			
 
				+    replacer = normalizeReplacer(replacer);
			
 
				+
			
 
				+    if (Array.isArray(replacer)) {
			
 
				+        allowlist = new Set(replacer);
			
 
				+        replacer = null;
			
 
				+    }
			
 
				+
			
 
				+    space = spaceLength(space);
			
 
				+    options = options || {};
			
 
				+
			
 
				+    const visited = new Map();
			
 
				+    const stack = new Set();
			
 
				+    const duplicate = new Set();
			
 
				+    const circular = new Set();
			
 
				+    const async = new Set();
			
 
				+    const getType = options.async ? getTypeAsync : getTypeNative;
			
 
				+    const root = { '': value };
			
 
				+    let stop = false;
			
 
				+    let length = 0;
			
 
				+
			
 
				+    walk(root, '', value);
			
 
				+
			
 
				+    return {
			
 
				+        minLength: isNaN(length) ? Infinity : length,
			
 
				+        circular: [...circular],
			
 
				+        duplicate: [...duplicate],
			
 
				+        async: [...async]
			
 
				+    };
			
 
				+};
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/stringify-stream-browser.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/stringify-stream-browser.js
@@ -0,0 +1,3 @@
 
				+module.exports = () => {
			
 
				+    throw new Error('Method is not supported');
			
 
				+};
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/stringify-stream.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/stringify-stream.js
@@ -0,0 +1,408 @@
 
				+const { Readable } = require('stream');
			
 
				+const {
			
 
				+    normalizeReplacer,
			
 
				+    normalizeSpace,
			
 
				+    replaceValue,
			
 
				+    getTypeAsync,
			
 
				+    type: {
			
 
				+        PRIMITIVE,
			
 
				+        OBJECT,
			
 
				+        ARRAY,
			
 
				+        PROMISE,
			
 
				+        STRING_STREAM,
			
 
				+        OBJECT_STREAM
			
 
				+    }
			
 
				+} = require('./utils');
			
 
				+const noop = () => {};
			
 
				+const hasOwnProperty = Object.prototype.hasOwnProperty;
			
 
				+
			
 
				+// TODO: Remove when drop support for Node.js 10
			
 
				+// Node.js 10 has no well-formed JSON.stringify()
			
 
				+// https://github.com/tc39/proposal-well-formed-stringify
			
 
				+// Adopted code from https://bugs.chromium.org/p/v8/issues/detail?id=7782#c12
			
 
				+const wellformedStringStringify = JSON.stringify('\ud800') === '"\\ud800"'
			
 
				+    ? JSON.stringify
			
 
				+    : s => JSON.stringify(s).replace(
			
 
				+        /\p{Surrogate}/gu,
			
 
				+        m => `\\u${m.charCodeAt(0).toString(16)}`
			
 
				+    );
			
 
				+
			
 
				+function push() {
			
 
				+    this.push(this._stack.value);
			
 
				+    this.popStack();
			
 
				+}
			
 
				+
			
 
				+function pushPrimitive(value) {
			
 
				+    switch (typeof value) {
			
 
				+        case 'string':
			
 
				+            this.push(this.encodeString(value));
			
 
				+            break;
			
 
				+
			
 
				+        case 'number':
			
 
				+            this.push(Number.isFinite(value) ? this.encodeNumber(value) : 'null');
			
 
				+            break;
			
 
				+
			
 
				+        case 'boolean':
			
 
				+            this.push(value ? 'true' : 'false');
			
 
				+            break;
			
 
				+
			
 
				+        case 'undefined':
			
 
				+        case 'object': // typeof null === 'object'
			
 
				+            this.push('null');
			
 
				+            break;
			
 
				+
			
 
				+        default:
			
 
				+            this.destroy(new TypeError(`Do not know how to serialize a ${value.constructor && value.constructor.name || typeof value}`));
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+function processObjectEntry(key) {
			
 
				+    const current = this._stack;
			
 
				+
			
 
				+    if (!current.first) {
			
 
				+        current.first = true;
			
 
				+    } else {
			
 
				+        this.push(',');
			
 
				+    }
			
 
				+
			
 
				+    if (this.space) {
			
 
				+        this.push(`\n${this.space.repeat(this._depth)}${this.encodeString(key)}: `);
			
 
				+    } else {
			
 
				+        this.push(this.encodeString(key) + ':');
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+function processObject() {
			
 
				+    const current = this._stack;
			
 
				+
			
 
				+    // when no keys left, remove obj from stack
			
 
				+    if (current.index === current.keys.length) {
			
 
				+        if (this.space && current.first) {
			
 
				+            this.push(`\n${this.space.repeat(this._depth - 1)}}`);
			
 
				+        } else {
			
 
				+            this.push('}');
			
 
				+        }
			
 
				+
			
 
				+        this.popStack();
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    const key = current.keys[current.index];
			
 
				+
			
 
				+    this.processValue(current.value, key, current.value[key], processObjectEntry);
			
 
				+    current.index++;
			
 
				+}
			
 
				+
			
 
				+function processArrayItem(index) {
			
 
				+    if (index !== 0) {
			
 
				+        this.push(',');
			
 
				+    }
			
 
				+
			
 
				+    if (this.space) {
			
 
				+        this.push(`\n${this.space.repeat(this._depth)}`);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+function processArray() {
			
 
				+    const current = this._stack;
			
 
				+
			
 
				+    if (current.index === current.value.length) {
			
 
				+        if (this.space && current.index > 0) {
			
 
				+            this.push(`\n${this.space.repeat(this._depth - 1)}]`);
			
 
				+        } else {
			
 
				+            this.push(']');
			
 
				+        }
			
 
				+
			
 
				+        this.popStack();
			
 
				+        return;
			
 
				+    }
			
 
				+
			
 
				+    this.processValue(current.value, current.index, current.value[current.index], processArrayItem);
			
 
				+    current.index++;
			
 
				+}
			
 
				+
			
 
				+function createStreamReader(fn) {
			
 
				+    return function() {
			
 
				+        const current = this._stack;
			
 
				+        const data = current.value.read(this._readSize);
			
 
				+
			
 
				+        if (data !== null) {
			
 
				+            current.first = false;
			
 
				+            fn.call(this, data, current);
			
 
				+        } else {
			
 
				+            if ((current.first && !current.value._readableState.reading) || current.ended) {
			
 
				+                this.popStack();
			
 
				+            } else {
			
 
				+                current.first = true;
			
 
				+                current.awaiting = true;
			
 
				+            }
			
 
				+        }
			
 
				+    };
			
 
				+}
			
 
				+
			
 
				+const processReadableObject = createStreamReader(function(data, current) {
			
 
				+    this.processValue(current.value, current.index, data, processArrayItem);
			
 
				+    current.index++;
			
 
				+});
			
 
				+
			
 
				+const processReadableString = createStreamReader(function(data) {
			
 
				+    this.push(data);
			
 
				+});
			
 
				+
			
 
				+class JsonStringifyStream extends Readable {
			
 
				+    constructor(value, replacer, space) {
			
 
				+        super({
			
 
				+            autoDestroy: true
			
 
				+        });
			
 
				+
			
 
				+        this.getKeys = Object.keys;
			
 
				+        this.replacer = normalizeReplacer(replacer);
			
 
				+
			
 
				+        if (Array.isArray(this.replacer)) {
			
 
				+            const allowlist = this.replacer;
			
 
				+
			
 
				+            this.getKeys = (value) => allowlist.filter(key => hasOwnProperty.call(value, key));
			
 
				+            this.replacer = null;
			
 
				+        }
			
 
				+
			
 
				+        this.space = normalizeSpace(space);
			
 
				+        this._depth = 0;
			
 
				+
			
 
				+        this.error = null;
			
 
				+        this._processing = false;
			
 
				+        this._ended = false;
			
 
				+
			
 
				+        this._readSize = 0;
			
 
				+        this._buffer = '';
			
 
				+
			
 
				+        this._stack = null;
			
 
				+        this._visited = new WeakSet();
			
 
				+
			
 
				+        this.pushStack({
			
 
				+            handler: () => {
			
 
				+                this.popStack();
			
 
				+                this.processValue({ '': value }, '', value, noop);
			
 
				+            }
			
 
				+        });
			
 
				+    }
			
 
				+
			
 
				+    encodeString(value) {
			
 
				+        if (/[^\x20-\uD799]|[\x22\x5c]/.test(value)) {
			
 
				+            return wellformedStringStringify(value);
			
 
				+        }
			
 
				+
			
 
				+        return '"' + value + '"';
			
 
				+    }
			
 
				+
			
 
				+    encodeNumber(value) {
			
 
				+        return value;
			
 
				+    }
			
 
				+
			
 
				+    processValue(holder, key, value, callback) {
			
 
				+        value = replaceValue(holder, key, value, this.replacer);
			
 
				+
			
 
				+        let type = getTypeAsync(value);
			
 
				+
			
 
				+        switch (type) {
			
 
				+            case PRIMITIVE:
			
 
				+                if (callback !== processObjectEntry || value !== undefined) {
			
 
				+                    callback.call(this, key);
			
 
				+                    pushPrimitive.call(this, value);
			
 
				+                }
			
 
				+                break;
			
 
				+
			
 
				+            case OBJECT:
			
 
				+                callback.call(this, key);
			
 
				+
			
 
				+                // check for circular structure
			
 
				+                if (this._visited.has(value)) {
			
 
				+                    return this.destroy(new TypeError('Converting circular structure to JSON'));
			
 
				+                }
			
 
				+
			
 
				+                this._visited.add(value);
			
 
				+                this._depth++;
			
 
				+                this.push('{');
			
 
				+                this.pushStack({
			
 
				+                    handler: processObject,
			
 
				+                    value,
			
 
				+                    index: 0,
			
 
				+                    first: false,
			
 
				+                    keys: this.getKeys(value)
			
 
				+                });
			
 
				+                break;
			
 
				+
			
 
				+            case ARRAY:
			
 
				+                callback.call(this, key);
			
 
				+
			
 
				+                // check for circular structure
			
 
				+                if (this._visited.has(value)) {
			
 
				+                    return this.destroy(new TypeError('Converting circular structure to JSON'));
			
 
				+                }
			
 
				+
			
 
				+                this._visited.add(value);
			
 
				+
			
 
				+                this.push('[');
			
 
				+                this.pushStack({
			
 
				+                    handler: processArray,
			
 
				+                    value,
			
 
				+                    index: 0
			
 
				+                });
			
 
				+                this._depth++;
			
 
				+                break;
			
 
				+
			
 
				+            case PROMISE:
			
 
				+                this.pushStack({
			
 
				+                    handler: noop,
			
 
				+                    awaiting: true
			
 
				+                });
			
 
				+
			
 
				+                Promise.resolve(value)
			
 
				+                    .then(resolved => {
			
 
				+                        this.popStack();
			
 
				+                        this.processValue(holder, key, resolved, callback);
			
 
				+                        this.processStack();
			
 
				+                    })
			
 
				+                    .catch(error => {
			
 
				+                        this.destroy(error);
			
 
				+                    });
			
 
				+                break;
			
 
				+
			
 
				+            case STRING_STREAM:
			
 
				+            case OBJECT_STREAM:
			
 
				+                callback.call(this, key);
			
 
				+
			
 
				+                // TODO: Remove when drop support for Node.js 10
			
 
				+                // Used `_readableState.endEmitted` as fallback, since Node.js 10 has no `readableEnded` getter
			
 
				+                if (value.readableEnded || value._readableState.endEmitted) {
			
 
				+                    return this.destroy(new Error('Readable Stream has ended before it was serialized. All stream data have been lost'));
			
 
				+                }
			
 
				+
			
 
				+                if (value.readableFlowing) {
			
 
				+                    return this.destroy(new Error('Readable Stream is in flowing mode, data may have been lost. Trying to pause stream.'));
			
 
				+                }
			
 
				+
			
 
				+                if (type === OBJECT_STREAM) {
			
 
				+                    this.push('[');
			
 
				+                    this.pushStack({
			
 
				+                        handler: push,
			
 
				+                        value: this.space ? '\n' + this.space.repeat(this._depth) + ']' : ']'
			
 
				+                    });
			
 
				+                    this._depth++;
			
 
				+                }
			
 
				+
			
 
				+                const self = this.pushStack({
			
 
				+                    handler: type === OBJECT_STREAM ? processReadableObject : processReadableString,
			
 
				+                    value,
			
 
				+                    index: 0,
			
 
				+                    first: false,
			
 
				+                    ended: false,
			
 
				+                    awaiting: !value.readable || value.readableLength === 0
			
 
				+                });
			
 
				+                const continueProcessing = () => {
			
 
				+                    if (self.awaiting) {
			
 
				+                        self.awaiting = false;
			
 
				+                        this.processStack();
			
 
				+                    }
			
 
				+                };
			
 
				+
			
 
				+                value.once('error', error => this.destroy(error));
			
 
				+                value.once('end', () => {
			
 
				+                    self.ended = true;
			
 
				+                    continueProcessing();
			
 
				+                });
			
 
				+                value.on('readable', continueProcessing);
			
 
				+                break;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    pushStack(node) {
			
 
				+        node.prev = this._stack;
			
 
				+        return this._stack = node;
			
 
				+    }
			
 
				+
			
 
				+    popStack() {
			
 
				+        const { handler, value } = this._stack;
			
 
				+
			
 
				+        if (handler === processObject || handler === processArray || handler === processReadableObject) {
			
 
				+            this._visited.delete(value);
			
 
				+            this._depth--;
			
 
				+        }
			
 
				+
			
 
				+        this._stack = this._stack.prev;
			
 
				+    }
			
 
				+
			
 
				+    processStack() {
			
 
				+        if (this._processing || this._ended) {
			
 
				+            return;
			
 
				+        }
			
 
				+
			
 
				+        try {
			
 
				+            this._processing = true;
			
 
				+
			
 
				+            while (this._stack !== null && !this._stack.awaiting) {
			
 
				+                this._stack.handler.call(this);
			
 
				+
			
 
				+                if (!this._processing) {
			
 
				+                    return;
			
 
				+                }
			
 
				+            }
			
 
				+
			
 
				+            this._processing = false;
			
 
				+        } catch (error) {
			
 
				+            this.destroy(error);
			
 
				+            return;
			
 
				+        }
			
 
				+
			
 
				+        if (this._stack === null && !this._ended) {
			
 
				+            this._finish();
			
 
				+            this.push(null);
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    push(data) {
			
 
				+        if (data !== null) {
			
 
				+            this._buffer += data;
			
 
				+
			
 
				+            // check buffer overflow
			
 
				+            if (this._buffer.length < this._readSize) {
			
 
				+                return;
			
 
				+            }
			
 
				+
			
 
				+            // flush buffer
			
 
				+            data = this._buffer;
			
 
				+            this._buffer = '';
			
 
				+            this._processing = false;
			
 
				+        }
			
 
				+
			
 
				+        super.push(data);
			
 
				+    }
			
 
				+
			
 
				+    _read(size) {
			
 
				+        // start processing
			
 
				+        this._readSize = size || this.readableHighWaterMark;
			
 
				+        this.processStack();
			
 
				+    }
			
 
				+
			
 
				+    _finish() {
			
 
				+        this._ended = true;
			
 
				+        this._processing = false;
			
 
				+        this._stack = null;
			
 
				+        this._visited = null;
			
 
				+
			
 
				+        if (this._buffer && this._buffer.length) {
			
 
				+            super.push(this._buffer); // flush buffer
			
 
				+        }
			
 
				+
			
 
				+        this._buffer = '';
			
 
				+    }
			
 
				+
			
 
				+    _destroy(error, cb) {
			
 
				+        this.error = this.error || error;
			
 
				+        this._finish();
			
 
				+        cb(error);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+module.exports = function createJsonStringifyStream(value, replacer, space) {
			
 
				+    return new JsonStringifyStream(value, replacer, space);
			
 
				+};
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/text-decoder-browser.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/text-decoder-browser.js
@@ -0,0 +1 @@
 
				+module.exports = TextDecoder;
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/text-decoder.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/text-decoder.js
@@ -0,0 +1 @@
 
				+module.exports = require('util').TextDecoder;
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/utils.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/utils.js
@@ -0,0 +1,149 @@
 
				+const PrimitiveType = 1;
			
 
				+const ObjectType = 2;
			
 
				+const ArrayType = 3;
			
 
				+const PromiseType = 4;
			
 
				+const ReadableStringType = 5;
			
 
				+const ReadableObjectType = 6;
			
 
				+// https://tc39.es/ecma262/#table-json-single-character-escapes
			
 
				+const escapableCharCodeSubstitution = { // JSON Single Character Escape Sequences
			
 
				+    0x08: '\\b',
			
 
				+    0x09: '\\t',
			
 
				+    0x0a: '\\n',
			
 
				+    0x0c: '\\f',
			
 
				+    0x0d: '\\r',
			
 
				+    0x22: '\\\"',
			
 
				+    0x5c: '\\\\'
			
 
				+};
			
 
				+
			
 
				+function isLeadingSurrogate(code) {
			
 
				+    return code >= 0xD800 && code <= 0xDBFF;
			
 
				+}
			
 
				+
			
 
				+function isTrailingSurrogate(code) {
			
 
				+    return code >= 0xDC00 && code <= 0xDFFF;
			
 
				+}
			
 
				+
			
 
				+function isReadableStream(value) {
			
 
				+    return (
			
 
				+        typeof value.pipe === 'function' &&
			
 
				+        typeof value._read === 'function' &&
			
 
				+        typeof value._readableState === 'object' && value._readableState !== null
			
 
				+    );
			
 
				+}
			
 
				+
			
 
				+function replaceValue(holder, key, value, replacer) {
			
 
				+    if (value && typeof value.toJSON === 'function') {
			
 
				+        value = value.toJSON();
			
 
				+    }
			
 
				+
			
 
				+    if (replacer !== null) {
			
 
				+        value = replacer.call(holder, String(key), value);
			
 
				+    }
			
 
				+
			
 
				+    switch (typeof value) {
			
 
				+        case 'function':
			
 
				+        case 'symbol':
			
 
				+            value = undefined;
			
 
				+            break;
			
 
				+
			
 
				+        case 'object':
			
 
				+            if (value !== null) {
			
 
				+                const cls = value.constructor;
			
 
				+                if (cls === String || cls === Number || cls === Boolean) {
			
 
				+                    value = value.valueOf();
			
 
				+                }
			
 
				+            }
			
 
				+            break;
			
 
				+    }
			
 
				+
			
 
				+    return value;
			
 
				+}
			
 
				+
			
 
				+function getTypeNative(value) {
			
 
				+    if (value === null || typeof value !== 'object') {
			
 
				+        return PrimitiveType;
			
 
				+    }
			
 
				+
			
 
				+    if (Array.isArray(value)) {
			
 
				+        return ArrayType;
			
 
				+    }
			
 
				+
			
 
				+    return ObjectType;
			
 
				+}
			
 
				+
			
 
				+function getTypeAsync(value) {
			
 
				+    if (value === null || typeof value !== 'object') {
			
 
				+        return PrimitiveType;
			
 
				+    }
			
 
				+
			
 
				+    if (typeof value.then === 'function') {
			
 
				+        return PromiseType;
			
 
				+    }
			
 
				+
			
 
				+    if (isReadableStream(value)) {
			
 
				+        return value._readableState.objectMode ? ReadableObjectType : ReadableStringType;
			
 
				+    }
			
 
				+
			
 
				+    if (Array.isArray(value)) {
			
 
				+        return ArrayType;
			
 
				+    }
			
 
				+
			
 
				+    return ObjectType;
			
 
				+}
			
 
				+
			
 
				+function normalizeReplacer(replacer) {
			
 
				+    if (typeof replacer === 'function') {
			
 
				+        return replacer;
			
 
				+    }
			
 
				+
			
 
				+    if (Array.isArray(replacer)) {
			
 
				+        const allowlist = new Set(replacer
			
 
				+            .map(item => {
			
 
				+                const cls = item && item.constructor;
			
 
				+                return cls === String || cls === Number ? String(item) : null;
			
 
				+            })
			
 
				+            .filter(item => typeof item === 'string')
			
 
				+        );
			
 
				+
			
 
				+        return [...allowlist];
			
 
				+    }
			
 
				+
			
 
				+    return null;
			
 
				+}
			
 
				+
			
 
				+function normalizeSpace(space) {
			
 
				+    if (typeof space === 'number') {
			
 
				+        if (!Number.isFinite(space) || space < 1) {
			
 
				+            return false;
			
 
				+        }
			
 
				+
			
 
				+        return ' '.repeat(Math.min(space, 10));
			
 
				+    }
			
 
				+
			
 
				+    if (typeof space === 'string') {
			
 
				+        return space.slice(0, 10) || false;
			
 
				+    }
			
 
				+
			
 
				+    return false;
			
 
				+}
			
 
				+
			
 
				+module.exports = {
			
 
				+    escapableCharCodeSubstitution,
			
 
				+    isLeadingSurrogate,
			
 
				+    isTrailingSurrogate,
			
 
				+    type: {
			
 
				+        PRIMITIVE: PrimitiveType,
			
 
				+        PROMISE: PromiseType,
			
 
				+        ARRAY: ArrayType,
			
 
				+        OBJECT: ObjectType,
			
 
				+        STRING_STREAM: ReadableStringType,
			
 
				+        OBJECT_STREAM: ReadableObjectType
			
 
				+    },
			
 
				+
			
 
				+    isReadableStream,
			
 
				+    replaceValue,
			
 
				+    getTypeNative,
			
 
				+    getTypeAsync,
			
 
				+    normalizeReplacer,
			
 
				+    normalizeSpace
			
 
				+};
			
--- a/day37/node_modules/@discoveryjs/json-ext/src/version.js
+++ b/day37/node_modules/@discoveryjs/json-ext/src/version.js
@@ -0,0 +1 @@
 
				+module.exports = require('../package.json').version;
			
--- a/day37/node_modules/@jridgewell/gen-mapping/LICENSE
+++ b/day37/node_modules/@jridgewell/gen-mapping/LICENSE
@@ -0,0 +1,19 @@
 
				+Copyright 2022 Justin Ridgewell <jridgewell@google.com>
			
 
				+
			
 
				+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/day37/node_modules/@jridgewell/gen-mapping/README.md
+++ b/day37/node_modules/@jridgewell/gen-mapping/README.md
@@ -0,0 +1,227 @@
 
				+# @jridgewell/gen-mapping
			
 
				+
			
 
				+> Generate source maps
			
 
				+
			
 
				+`gen-mapping` allows you to generate a source map during transpilation or minification.
			
 
				+With a source map, you're able to trace the original location in the source file, either in Chrome's
			
 
				+DevTools or using a library like [`@jridgewell/trace-mapping`][trace-mapping].
			
 
				+
			
 
				+You may already be familiar with the [`source-map`][source-map] package's `SourceMapGenerator`. This
			
 
				+provides the same `addMapping` and `setSourceContent` API.
			
 
				+
			
 
				+## Installation
			
 
				+
			
 
				+```sh
			
 
				+npm install @jridgewell/gen-mapping
			
 
				+```
			
 
				+
			
 
				+## Usage
			
 
				+
			
 
				+```typescript
			
 
				+import { GenMapping, addMapping, setSourceContent, toEncodedMap, toDecodedMap } from '@jridgewell/gen-mapping';
			
 
				+
			
 
				+const map = new GenMapping({
			
 
				+  file: 'output.js',
			
 
				+  sourceRoot: 'https://example.com/',
			
 
				+});
			
 
				+
			
 
				+setSourceContent(map, 'input.js', `function foo() {}`);
			
 
				+
			
 
				+addMapping(map, {
			
 
				+  // Lines start at line 1, columns at column 0.
			
 
				+  generated: { line: 1, column: 0 },
			
 
				+  source: 'input.js',
			
 
				+  original: { line: 1, column: 0 },
			
 
				+});
			
 
				+
			
 
				+addMapping(map, {
			
 
				+  generated: { line: 1, column: 9 },
			
 
				+  source: 'input.js',
			
 
				+  original: { line: 1, column: 9 },
			
 
				+  name: 'foo',
			
 
				+});
			
 
				+
			
 
				+assert.deepEqual(toDecodedMap(map), {
			
 
				+  version: 3,
			
 
				+  file: 'output.js',
			
 
				+  names: ['foo'],
			
 
				+  sourceRoot: 'https://example.com/',
			
 
				+  sources: ['input.js'],
			
 
				+  sourcesContent: ['function foo() {}'],
			
 
				+  mappings: [
			
 
				+    [ [0, 0, 0, 0], [9, 0, 0, 9, 0] ]
			
 
				+  ],
			
 
				+});
			
 
				+
			
 
				+assert.deepEqual(toEncodedMap(map), {
			
 
				+  version: 3,
			
 
				+  file: 'output.js',
			
 
				+  names: ['foo'],
			
 
				+  sourceRoot: 'https://example.com/',
			
 
				+  sources: ['input.js'],
			
 
				+  sourcesContent: ['function foo() {}'],
			
 
				+  mappings: 'AAAA,SAASA',
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+### Smaller Sourcemaps
			
 
				+
			
 
				+Not everything needs to be added to a sourcemap, and needless markings can cause signficantly
			
 
				+larger file sizes. `gen-mapping` exposes `maybeAddSegment`/`maybeAddMapping` APIs that will
			
 
				+intelligently determine if this marking adds useful information. If not, the marking will be
			
 
				+skipped.
			
 
				+
			
 
				+```typescript
			
 
				+import { maybeAddMapping } from '@jridgewell/gen-mapping';
			
 
				+
			
 
				+const map = new GenMapping();
			
 
				+
			
 
				+// Adding a sourceless marking at the beginning of a line isn't useful.
			
 
				+maybeAddMapping(map, {
			
 
				+  generated: { line: 1, column: 0 },
			
 
				+});
			
 
				+
			
 
				+// Adding a new source marking is useful.
			
 
				+maybeAddMapping(map, {
			
 
				+  generated: { line: 1, column: 0 },
			
 
				+  source: 'input.js',
			
 
				+  original: { line: 1, column: 0 },
			
 
				+});
			
 
				+
			
 
				+// But adding another marking pointing to the exact same original location isn't, even if the
			
 
				+// generated column changed.
			
 
				+maybeAddMapping(map, {
			
 
				+  generated: { line: 1, column: 9 },
			
 
				+  source: 'input.js',
			
 
				+  original: { line: 1, column: 0 },
			
 
				+});
			
 
				+
			
 
				+assert.deepEqual(toEncodedMap(map), {
			
 
				+  version: 3,
			
 
				+  names: [],
			
 
				+  sources: ['input.js'],
			
 
				+  sourcesContent: [null],
			
 
				+  mappings: 'AAAA',
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+## Benchmarks
			
 
				+
			
 
				+```
			
 
				+node v18.0.0
			
 
				+
			
 
				+amp.js.map
			
 
				+Memory Usage:
			
 
				+gen-mapping: addSegment      5852872 bytes
			
 
				+gen-mapping: addMapping      7716042 bytes
			
 
				+source-map-js                6143250 bytes
			
 
				+source-map-0.6.1             6124102 bytes
			
 
				+source-map-0.8.0             6121173 bytes
			
 
				+Smallest memory usage is gen-mapping: addSegment
			
 
				+
			
 
				+Adding speed:
			
 
				+gen-mapping:      addSegment x 441 ops/sec ±2.07% (90 runs sampled)
			
 
				+gen-mapping:      addMapping x 350 ops/sec ±2.40% (86 runs sampled)
			
 
				+source-map-js:    addMapping x 169 ops/sec ±2.42% (80 runs sampled)
			
 
				+source-map-0.6.1: addMapping x 167 ops/sec ±2.56% (80 runs sampled)
			
 
				+source-map-0.8.0: addMapping x 168 ops/sec ±2.52% (80 runs sampled)
			
 
				+Fastest is gen-mapping:      addSegment
			
 
				+
			
 
				+Generate speed:
			
 
				+gen-mapping:      decoded output x 150,824,370 ops/sec ±0.07% (102 runs sampled)
			
 
				+gen-mapping:      encoded output x 663 ops/sec ±0.22% (98 runs sampled)
			
 
				+source-map-js:    encoded output x 197 ops/sec ±0.45% (84 runs sampled)
			
 
				+source-map-0.6.1: encoded output x 198 ops/sec ±0.33% (85 runs sampled)
			
 
				+source-map-0.8.0: encoded output x 197 ops/sec ±0.06% (93 runs sampled)
			
 
				+Fastest is gen-mapping:      decoded output
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+babel.min.js.map
			
 
				+Memory Usage:
			
 
				+gen-mapping: addSegment     37578063 bytes
			
 
				+gen-mapping: addMapping     37212897 bytes
			
 
				+source-map-js               47638527 bytes
			
 
				+source-map-0.6.1            47690503 bytes
			
 
				+source-map-0.8.0            47470188 bytes
			
 
				+Smallest memory usage is gen-mapping: addMapping
			
 
				+
			
 
				+Adding speed:
			
 
				+gen-mapping:      addSegment x 31.05 ops/sec ±8.31% (43 runs sampled)
			
 
				+gen-mapping:      addMapping x 29.83 ops/sec ±7.36% (51 runs sampled)
			
 
				+source-map-js:    addMapping x 20.73 ops/sec ±6.22% (38 runs sampled)
			
 
				+source-map-0.6.1: addMapping x 20.03 ops/sec ±10.51% (38 runs sampled)
			
 
				+source-map-0.8.0: addMapping x 19.30 ops/sec ±8.27% (37 runs sampled)
			
 
				+Fastest is gen-mapping:      addSegment
			
 
				+
			
 
				+Generate speed:
			
 
				+gen-mapping:      decoded output x 381,379,234 ops/sec ±0.29% (96 runs sampled)
			
 
				+gen-mapping:      encoded output x 95.15 ops/sec ±2.98% (72 runs sampled)
			
 
				+source-map-js:    encoded output x 15.20 ops/sec ±7.41% (33 runs sampled)
			
 
				+source-map-0.6.1: encoded output x 16.36 ops/sec ±10.46% (31 runs sampled)
			
 
				+source-map-0.8.0: encoded output x 16.06 ops/sec ±6.45% (31 runs sampled)
			
 
				+Fastest is gen-mapping:      decoded output
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+preact.js.map
			
 
				+Memory Usage:
			
 
				+gen-mapping: addSegment       416247 bytes
			
 
				+gen-mapping: addMapping       419824 bytes
			
 
				+source-map-js                1024619 bytes
			
 
				+source-map-0.6.1             1146004 bytes
			
 
				+source-map-0.8.0             1113250 bytes
			
 
				+Smallest memory usage is gen-mapping: addSegment
			
 
				+
			
 
				+Adding speed:
			
 
				+gen-mapping:      addSegment x 13,755 ops/sec ±0.15% (98 runs sampled)
			
 
				+gen-mapping:      addMapping x 13,013 ops/sec ±0.11% (101 runs sampled)
			
 
				+source-map-js:    addMapping x 4,564 ops/sec ±0.21% (98 runs sampled)
			
 
				+source-map-0.6.1: addMapping x 4,562 ops/sec ±0.11% (99 runs sampled)
			
 
				+source-map-0.8.0: addMapping x 4,593 ops/sec ±0.11% (100 runs sampled)
			
 
				+Fastest is gen-mapping:      addSegment
			
 
				+
			
 
				+Generate speed:
			
 
				+gen-mapping:      decoded output x 379,864,020 ops/sec ±0.23% (93 runs sampled)
			
 
				+gen-mapping:      encoded output x 14,368 ops/sec ±4.07% (82 runs sampled)
			
 
				+source-map-js:    encoded output x 5,261 ops/sec ±0.21% (99 runs sampled)
			
 
				+source-map-0.6.1: encoded output x 5,124 ops/sec ±0.58% (99 runs sampled)
			
 
				+source-map-0.8.0: encoded output x 5,434 ops/sec ±0.33% (96 runs sampled)
			
 
				+Fastest is gen-mapping:      decoded output
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+react.js.map
			
 
				+Memory Usage:
			
 
				+gen-mapping: addSegment       975096 bytes
			
 
				+gen-mapping: addMapping      1102981 bytes
			
 
				+source-map-js                2918836 bytes
			
 
				+source-map-0.6.1             2885435 bytes
			
 
				+source-map-0.8.0             2874336 bytes
			
 
				+Smallest memory usage is gen-mapping: addSegment
			
 
				+
			
 
				+Adding speed:
			
 
				+gen-mapping:      addSegment x 4,772 ops/sec ±0.15% (100 runs sampled)
			
 
				+gen-mapping:      addMapping x 4,456 ops/sec ±0.13% (97 runs sampled)
			
 
				+source-map-js:    addMapping x 1,618 ops/sec ±0.24% (97 runs sampled)
			
 
				+source-map-0.6.1: addMapping x 1,622 ops/sec ±0.12% (99 runs sampled)
			
 
				+source-map-0.8.0: addMapping x 1,631 ops/sec ±0.12% (100 runs sampled)
			
 
				+Fastest is gen-mapping:      addSegment
			
 
				+
			
 
				+Generate speed:
			
 
				+gen-mapping:      decoded output x 379,107,695 ops/sec ±0.07% (99 runs sampled)
			
 
				+gen-mapping:      encoded output x 5,421 ops/sec ±1.60% (89 runs sampled)
			
 
				+source-map-js:    encoded output x 2,113 ops/sec ±1.81% (98 runs sampled)
			
 
				+source-map-0.6.1: encoded output x 2,126 ops/sec ±0.10% (100 runs sampled)
			
 
				+source-map-0.8.0: encoded output x 2,176 ops/sec ±0.39% (98 runs sampled)
			
 
				+Fastest is gen-mapping:      decoded output
			
 
				+```
			
 
				+
			
 
				+[source-map]: https://www.npmjs.com/package/source-map
			
 
				+[trace-mapping]: https://github.com/jridgewell/trace-mapping
			
--- a/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
+++ b/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs
@@ -0,0 +1,230 @@
 
				+import { SetArray, put } from '@jridgewell/set-array';
			
 
				+import { encode } from '@jridgewell/sourcemap-codec';
			
 
				+import { TraceMap, decodedMappings } from '@jridgewell/trace-mapping';
			
 
				+
			
 
				+const COLUMN = 0;
			
 
				+const SOURCES_INDEX = 1;
			
 
				+const SOURCE_LINE = 2;
			
 
				+const SOURCE_COLUMN = 3;
			
 
				+const NAMES_INDEX = 4;
			
 
				+
			
 
				+const NO_NAME = -1;
			
 
				+/**
			
 
				+ * A low-level API to associate a generated position with an original source position. Line and
			
 
				+ * column here are 0-based, unlike `addMapping`.
			
 
				+ */
			
 
				+let addSegment;
			
 
				+/**
			
 
				+ * A high-level API to associate a generated position with an original source position. Line is
			
 
				+ * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
			
 
				+ */
			
 
				+let addMapping;
			
 
				+/**
			
 
				+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
			
 
				+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
			
 
				+ * not add a segment with a lower generated line/column than one that came before.
			
 
				+ */
			
 
				+let maybeAddSegment;
			
 
				+/**
			
 
				+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
			
 
				+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
			
 
				+ * not add a mapping with a lower generated line/column than one that came before.
			
 
				+ */
			
 
				+let maybeAddMapping;
			
 
				+/**
			
 
				+ * Adds/removes the content of the source file to the source map.
			
 
				+ */
			
 
				+let setSourceContent;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+let toDecodedMap;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+let toEncodedMap;
			
 
				+/**
			
 
				+ * Constructs a new GenMapping, using the already present mappings of the input.
			
 
				+ */
			
 
				+let fromMap;
			
 
				+/**
			
 
				+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
			
 
				+ * passed to the `source-map` library.
			
 
				+ */
			
 
				+let allMappings;
			
 
				+// This split declaration is only so that terser can elminiate the static initialization block.
			
 
				+let addSegmentInternal;
			
 
				+/**
			
 
				+ * Provides the state to generate a sourcemap.
			
 
				+ */
			
 
				+class GenMapping {
			
 
				+    constructor({ file, sourceRoot } = {}) {
			
 
				+        this._names = new SetArray();
			
 
				+        this._sources = new SetArray();
			
 
				+        this._sourcesContent = [];
			
 
				+        this._mappings = [];
			
 
				+        this.file = file;
			
 
				+        this.sourceRoot = sourceRoot;
			
 
				+    }
			
 
				+}
			
 
				+(() => {
			
 
				+    addSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
			
 
				+        return addSegmentInternal(false, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
			
 
				+    };
			
 
				+    maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
			
 
				+        return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
			
 
				+    };
			
 
				+    addMapping = (map, mapping) => {
			
 
				+        return addMappingInternal(false, map, mapping);
			
 
				+    };
			
 
				+    maybeAddMapping = (map, mapping) => {
			
 
				+        return addMappingInternal(true, map, mapping);
			
 
				+    };
			
 
				+    setSourceContent = (map, source, content) => {
			
 
				+        const { _sources: sources, _sourcesContent: sourcesContent } = map;
			
 
				+        sourcesContent[put(sources, source)] = content;
			
 
				+    };
			
 
				+    toDecodedMap = (map) => {
			
 
				+        const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+        removeEmptyFinalLines(mappings);
			
 
				+        return {
			
 
				+            version: 3,
			
 
				+            file: file || undefined,
			
 
				+            names: names.array,
			
 
				+            sourceRoot: sourceRoot || undefined,
			
 
				+            sources: sources.array,
			
 
				+            sourcesContent,
			
 
				+            mappings,
			
 
				+        };
			
 
				+    };
			
 
				+    toEncodedMap = (map) => {
			
 
				+        const decoded = toDecodedMap(map);
			
 
				+        return Object.assign(Object.assign({}, decoded), { mappings: encode(decoded.mappings) });
			
 
				+    };
			
 
				+    allMappings = (map) => {
			
 
				+        const out = [];
			
 
				+        const { _mappings: mappings, _sources: sources, _names: names } = map;
			
 
				+        for (let i = 0; i < mappings.length; i++) {
			
 
				+            const line = mappings[i];
			
 
				+            for (let j = 0; j < line.length; j++) {
			
 
				+                const seg = line[j];
			
 
				+                const generated = { line: i + 1, column: seg[COLUMN] };
			
 
				+                let source = undefined;
			
 
				+                let original = undefined;
			
 
				+                let name = undefined;
			
 
				+                if (seg.length !== 1) {
			
 
				+                    source = sources.array[seg[SOURCES_INDEX]];
			
 
				+                    original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
			
 
				+                    if (seg.length === 5)
			
 
				+                        name = names.array[seg[NAMES_INDEX]];
			
 
				+                }
			
 
				+                out.push({ generated, source, original, name });
			
 
				+            }
			
 
				+        }
			
 
				+        return out;
			
 
				+    };
			
 
				+    fromMap = (input) => {
			
 
				+        const map = new TraceMap(input);
			
 
				+        const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
			
 
				+        putAll(gen._names, map.names);
			
 
				+        putAll(gen._sources, map.sources);
			
 
				+        gen._sourcesContent = map.sourcesContent || map.sources.map(() => null);
			
 
				+        gen._mappings = decodedMappings(map);
			
 
				+        return gen;
			
 
				+    };
			
 
				+    // Internal helpers
			
 
				+    addSegmentInternal = (skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
			
 
				+        const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+        const line = getLine(mappings, genLine);
			
 
				+        const index = getColumnIndex(line, genColumn);
			
 
				+        if (!source) {
			
 
				+            if (skipable && skipSourceless(line, index))
			
 
				+                return;
			
 
				+            return insert(line, index, [genColumn]);
			
 
				+        }
			
 
				+        const sourcesIndex = put(sources, source);
			
 
				+        const namesIndex = name ? put(names, name) : NO_NAME;
			
 
				+        if (sourcesIndex === sourcesContent.length)
			
 
				+            sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
			
 
				+        if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
			
 
				+            return;
			
 
				+        }
			
 
				+        return insert(line, index, name
			
 
				+            ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
			
 
				+            : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
			
 
				+    };
			
 
				+})();
			
 
				+function getLine(mappings, index) {
			
 
				+    for (let i = mappings.length; i <= index; i++) {
			
 
				+        mappings[i] = [];
			
 
				+    }
			
 
				+    return mappings[index];
			
 
				+}
			
 
				+function getColumnIndex(line, genColumn) {
			
 
				+    let index = line.length;
			
 
				+    for (let i = index - 1; i >= 0; index = i--) {
			
 
				+        const current = line[i];
			
 
				+        if (genColumn >= current[COLUMN])
			
 
				+            break;
			
 
				+    }
			
 
				+    return index;
			
 
				+}
			
 
				+function insert(array, index, value) {
			
 
				+    for (let i = array.length; i > index; i--) {
			
 
				+        array[i] = array[i - 1];
			
 
				+    }
			
 
				+    array[index] = value;
			
 
				+}
			
 
				+function removeEmptyFinalLines(mappings) {
			
 
				+    const { length } = mappings;
			
 
				+    let len = length;
			
 
				+    for (let i = len - 1; i >= 0; len = i, i--) {
			
 
				+        if (mappings[i].length > 0)
			
 
				+            break;
			
 
				+    }
			
 
				+    if (len < length)
			
 
				+        mappings.length = len;
			
 
				+}
			
 
				+function putAll(strarr, array) {
			
 
				+    for (let i = 0; i < array.length; i++)
			
 
				+        put(strarr, array[i]);
			
 
				+}
			
 
				+function skipSourceless(line, index) {
			
 
				+    // The start of a line is already sourceless, so adding a sourceless segment to the beginning
			
 
				+    // doesn't generate any useful information.
			
 
				+    if (index === 0)
			
 
				+        return true;
			
 
				+    const prev = line[index - 1];
			
 
				+    // If the previous segment is also sourceless, then adding another sourceless segment doesn't
			
 
				+    // genrate any new information. Else, this segment will end the source/named segment and point to
			
 
				+    // a sourceless position, which is useful.
			
 
				+    return prev.length === 1;
			
 
				+}
			
 
				+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
			
 
				+    // A source/named segment at the start of a line gives position at that genColumn
			
 
				+    if (index === 0)
			
 
				+        return false;
			
 
				+    const prev = line[index - 1];
			
 
				+    // If the previous segment is sourceless, then we're transitioning to a source.
			
 
				+    if (prev.length === 1)
			
 
				+        return false;
			
 
				+    // If the previous segment maps to the exact same source position, then this segment doesn't
			
 
				+    // provide any new position information.
			
 
				+    return (sourcesIndex === prev[SOURCES_INDEX] &&
			
 
				+        sourceLine === prev[SOURCE_LINE] &&
			
 
				+        sourceColumn === prev[SOURCE_COLUMN] &&
			
 
				+        namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
			
 
				+}
			
 
				+function addMappingInternal(skipable, map, mapping) {
			
 
				+    const { generated, source, original, name, content } = mapping;
			
 
				+    if (!source) {
			
 
				+        return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
			
 
				+    }
			
 
				+    const s = source;
			
 
				+    return addSegmentInternal(skipable, map, generated.line - 1, generated.column, s, original.line - 1, original.column, name, content);
			
 
				+}
			
 
				+
			
 
				+export { GenMapping, addMapping, addSegment, allMappings, fromMap, maybeAddMapping, maybeAddSegment, setSourceContent, toDecodedMap, toEncodedMap };
			
 
				+//# sourceMappingURL=gen-mapping.mjs.map
			
--- a/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map
+++ b/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.mjs.map
--- a/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js
+++ b/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js
@@ -0,0 +1,236 @@
 
				+(function (global, factory) {
			
 
				+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jridgewell/set-array'), require('@jridgewell/sourcemap-codec'), require('@jridgewell/trace-mapping')) :
			
 
				+    typeof define === 'function' && define.amd ? define(['exports', '@jridgewell/set-array', '@jridgewell/sourcemap-codec', '@jridgewell/trace-mapping'], factory) :
			
 
				+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.genMapping = {}, global.setArray, global.sourcemapCodec, global.traceMapping));
			
 
				+})(this, (function (exports, setArray, sourcemapCodec, traceMapping) { 'use strict';
			
 
				+
			
 
				+    const COLUMN = 0;
			
 
				+    const SOURCES_INDEX = 1;
			
 
				+    const SOURCE_LINE = 2;
			
 
				+    const SOURCE_COLUMN = 3;
			
 
				+    const NAMES_INDEX = 4;
			
 
				+
			
 
				+    const NO_NAME = -1;
			
 
				+    /**
			
 
				+     * A low-level API to associate a generated position with an original source position. Line and
			
 
				+     * column here are 0-based, unlike `addMapping`.
			
 
				+     */
			
 
				+    exports.addSegment = void 0;
			
 
				+    /**
			
 
				+     * A high-level API to associate a generated position with an original source position. Line is
			
 
				+     * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
			
 
				+     */
			
 
				+    exports.addMapping = void 0;
			
 
				+    /**
			
 
				+     * Same as `addSegment`, but will only add the segment if it generates useful information in the
			
 
				+     * resulting map. This only works correctly if segments are added **in order**, meaning you should
			
 
				+     * not add a segment with a lower generated line/column than one that came before.
			
 
				+     */
			
 
				+    exports.maybeAddSegment = void 0;
			
 
				+    /**
			
 
				+     * Same as `addMapping`, but will only add the mapping if it generates useful information in the
			
 
				+     * resulting map. This only works correctly if mappings are added **in order**, meaning you should
			
 
				+     * not add a mapping with a lower generated line/column than one that came before.
			
 
				+     */
			
 
				+    exports.maybeAddMapping = void 0;
			
 
				+    /**
			
 
				+     * Adds/removes the content of the source file to the source map.
			
 
				+     */
			
 
				+    exports.setSourceContent = void 0;
			
 
				+    /**
			
 
				+     * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
			
 
				+     * a sourcemap, or to JSON.stringify.
			
 
				+     */
			
 
				+    exports.toDecodedMap = void 0;
			
 
				+    /**
			
 
				+     * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
			
 
				+     * a sourcemap, or to JSON.stringify.
			
 
				+     */
			
 
				+    exports.toEncodedMap = void 0;
			
 
				+    /**
			
 
				+     * Constructs a new GenMapping, using the already present mappings of the input.
			
 
				+     */
			
 
				+    exports.fromMap = void 0;
			
 
				+    /**
			
 
				+     * Returns an array of high-level mapping objects for every recorded segment, which could then be
			
 
				+     * passed to the `source-map` library.
			
 
				+     */
			
 
				+    exports.allMappings = void 0;
			
 
				+    // This split declaration is only so that terser can elminiate the static initialization block.
			
 
				+    let addSegmentInternal;
			
 
				+    /**
			
 
				+     * Provides the state to generate a sourcemap.
			
 
				+     */
			
 
				+    class GenMapping {
			
 
				+        constructor({ file, sourceRoot } = {}) {
			
 
				+            this._names = new setArray.SetArray();
			
 
				+            this._sources = new setArray.SetArray();
			
 
				+            this._sourcesContent = [];
			
 
				+            this._mappings = [];
			
 
				+            this.file = file;
			
 
				+            this.sourceRoot = sourceRoot;
			
 
				+        }
			
 
				+    }
			
 
				+    (() => {
			
 
				+        exports.addSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
			
 
				+            return addSegmentInternal(false, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
			
 
				+        };
			
 
				+        exports.maybeAddSegment = (map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
			
 
				+            return addSegmentInternal(true, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content);
			
 
				+        };
			
 
				+        exports.addMapping = (map, mapping) => {
			
 
				+            return addMappingInternal(false, map, mapping);
			
 
				+        };
			
 
				+        exports.maybeAddMapping = (map, mapping) => {
			
 
				+            return addMappingInternal(true, map, mapping);
			
 
				+        };
			
 
				+        exports.setSourceContent = (map, source, content) => {
			
 
				+            const { _sources: sources, _sourcesContent: sourcesContent } = map;
			
 
				+            sourcesContent[setArray.put(sources, source)] = content;
			
 
				+        };
			
 
				+        exports.toDecodedMap = (map) => {
			
 
				+            const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+            removeEmptyFinalLines(mappings);
			
 
				+            return {
			
 
				+                version: 3,
			
 
				+                file: file || undefined,
			
 
				+                names: names.array,
			
 
				+                sourceRoot: sourceRoot || undefined,
			
 
				+                sources: sources.array,
			
 
				+                sourcesContent,
			
 
				+                mappings,
			
 
				+            };
			
 
				+        };
			
 
				+        exports.toEncodedMap = (map) => {
			
 
				+            const decoded = exports.toDecodedMap(map);
			
 
				+            return Object.assign(Object.assign({}, decoded), { mappings: sourcemapCodec.encode(decoded.mappings) });
			
 
				+        };
			
 
				+        exports.allMappings = (map) => {
			
 
				+            const out = [];
			
 
				+            const { _mappings: mappings, _sources: sources, _names: names } = map;
			
 
				+            for (let i = 0; i < mappings.length; i++) {
			
 
				+                const line = mappings[i];
			
 
				+                for (let j = 0; j < line.length; j++) {
			
 
				+                    const seg = line[j];
			
 
				+                    const generated = { line: i + 1, column: seg[COLUMN] };
			
 
				+                    let source = undefined;
			
 
				+                    let original = undefined;
			
 
				+                    let name = undefined;
			
 
				+                    if (seg.length !== 1) {
			
 
				+                        source = sources.array[seg[SOURCES_INDEX]];
			
 
				+                        original = { line: seg[SOURCE_LINE] + 1, column: seg[SOURCE_COLUMN] };
			
 
				+                        if (seg.length === 5)
			
 
				+                            name = names.array[seg[NAMES_INDEX]];
			
 
				+                    }
			
 
				+                    out.push({ generated, source, original, name });
			
 
				+                }
			
 
				+            }
			
 
				+            return out;
			
 
				+        };
			
 
				+        exports.fromMap = (input) => {
			
 
				+            const map = new traceMapping.TraceMap(input);
			
 
				+            const gen = new GenMapping({ file: map.file, sourceRoot: map.sourceRoot });
			
 
				+            putAll(gen._names, map.names);
			
 
				+            putAll(gen._sources, map.sources);
			
 
				+            gen._sourcesContent = map.sourcesContent || map.sources.map(() => null);
			
 
				+            gen._mappings = traceMapping.decodedMappings(map);
			
 
				+            return gen;
			
 
				+        };
			
 
				+        // Internal helpers
			
 
				+        addSegmentInternal = (skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name, content) => {
			
 
				+            const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+            const line = getLine(mappings, genLine);
			
 
				+            const index = getColumnIndex(line, genColumn);
			
 
				+            if (!source) {
			
 
				+                if (skipable && skipSourceless(line, index))
			
 
				+                    return;
			
 
				+                return insert(line, index, [genColumn]);
			
 
				+            }
			
 
				+            const sourcesIndex = setArray.put(sources, source);
			
 
				+            const namesIndex = name ? setArray.put(names, name) : NO_NAME;
			
 
				+            if (sourcesIndex === sourcesContent.length)
			
 
				+                sourcesContent[sourcesIndex] = content !== null && content !== void 0 ? content : null;
			
 
				+            if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
			
 
				+                return;
			
 
				+            }
			
 
				+            return insert(line, index, name
			
 
				+                ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
			
 
				+                : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
			
 
				+        };
			
 
				+    })();
			
 
				+    function getLine(mappings, index) {
			
 
				+        for (let i = mappings.length; i <= index; i++) {
			
 
				+            mappings[i] = [];
			
 
				+        }
			
 
				+        return mappings[index];
			
 
				+    }
			
 
				+    function getColumnIndex(line, genColumn) {
			
 
				+        let index = line.length;
			
 
				+        for (let i = index - 1; i >= 0; index = i--) {
			
 
				+            const current = line[i];
			
 
				+            if (genColumn >= current[COLUMN])
			
 
				+                break;
			
 
				+        }
			
 
				+        return index;
			
 
				+    }
			
 
				+    function insert(array, index, value) {
			
 
				+        for (let i = array.length; i > index; i--) {
			
 
				+            array[i] = array[i - 1];
			
 
				+        }
			
 
				+        array[index] = value;
			
 
				+    }
			
 
				+    function removeEmptyFinalLines(mappings) {
			
 
				+        const { length } = mappings;
			
 
				+        let len = length;
			
 
				+        for (let i = len - 1; i >= 0; len = i, i--) {
			
 
				+            if (mappings[i].length > 0)
			
 
				+                break;
			
 
				+        }
			
 
				+        if (len < length)
			
 
				+            mappings.length = len;
			
 
				+    }
			
 
				+    function putAll(strarr, array) {
			
 
				+        for (let i = 0; i < array.length; i++)
			
 
				+            setArray.put(strarr, array[i]);
			
 
				+    }
			
 
				+    function skipSourceless(line, index) {
			
 
				+        // The start of a line is already sourceless, so adding a sourceless segment to the beginning
			
 
				+        // doesn't generate any useful information.
			
 
				+        if (index === 0)
			
 
				+            return true;
			
 
				+        const prev = line[index - 1];
			
 
				+        // If the previous segment is also sourceless, then adding another sourceless segment doesn't
			
 
				+        // genrate any new information. Else, this segment will end the source/named segment and point to
			
 
				+        // a sourceless position, which is useful.
			
 
				+        return prev.length === 1;
			
 
				+    }
			
 
				+    function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
			
 
				+        // A source/named segment at the start of a line gives position at that genColumn
			
 
				+        if (index === 0)
			
 
				+            return false;
			
 
				+        const prev = line[index - 1];
			
 
				+        // If the previous segment is sourceless, then we're transitioning to a source.
			
 
				+        if (prev.length === 1)
			
 
				+            return false;
			
 
				+        // If the previous segment maps to the exact same source position, then this segment doesn't
			
 
				+        // provide any new position information.
			
 
				+        return (sourcesIndex === prev[SOURCES_INDEX] &&
			
 
				+            sourceLine === prev[SOURCE_LINE] &&
			
 
				+            sourceColumn === prev[SOURCE_COLUMN] &&
			
 
				+            namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
			
 
				+    }
			
 
				+    function addMappingInternal(skipable, map, mapping) {
			
 
				+        const { generated, source, original, name, content } = mapping;
			
 
				+        if (!source) {
			
 
				+            return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null, null);
			
 
				+        }
			
 
				+        const s = source;
			
 
				+        return addSegmentInternal(skipable, map, generated.line - 1, generated.column, s, original.line - 1, original.column, name, content);
			
 
				+    }
			
 
				+
			
 
				+    exports.GenMapping = GenMapping;
			
 
				+
			
 
				+    Object.defineProperty(exports, '__esModule', { value: true });
			
 
				+
			
 
				+}));
			
 
				+//# sourceMappingURL=gen-mapping.umd.js.map
			
--- a/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map
+++ b/day37/node_modules/@jridgewell/gen-mapping/dist/gen-mapping.umd.js.map
--- a/day37/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts
+++ b/day37/node_modules/@jridgewell/gen-mapping/dist/types/gen-mapping.d.ts
@@ -0,0 +1,90 @@
 
				+import type { SourceMapInput } from '@jridgewell/trace-mapping';
			
 
				+import type { DecodedSourceMap, EncodedSourceMap, Pos, Mapping } from './types';
			
 
				+export type { DecodedSourceMap, EncodedSourceMap, Mapping };
			
 
				+export declare type Options = {
			
 
				+    file?: string | null;
			
 
				+    sourceRoot?: string | null;
			
 
				+};
			
 
				+/**
			
 
				+ * A low-level API to associate a generated position with an original source position. Line and
			
 
				+ * column here are 0-based, unlike `addMapping`.
			
 
				+ */
			
 
				+export declare let addSegment: {
			
 
				+    (map: GenMapping, genLine: number, genColumn: number, source?: null, sourceLine?: null, sourceColumn?: null, name?: null, content?: null): void;
			
 
				+    (map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name?: null, content?: string | null): void;
			
 
				+    (map: GenMapping, genLine: number, genColumn: number, source: string, sourceLine: number, sourceColumn: number, name: string, content?: string | null): void;
			
 
				+};
			
 
				+/**
			
 
				+ * A high-level API to associate a generated position with an original source position. Line is
			
 
				+ * 1-based, but column is 0-based, due to legacy behavior in `source-map` library.
			
 
				+ */
			
 
				+export declare let addMapping: {
			
 
				+    (map: GenMapping, mapping: {
			
 
				+        generated: Pos;
			
 
				+        source?: null;
			
 
				+        original?: null;
			
 
				+        name?: null;
			
 
				+        content?: null;
			
 
				+    }): void;
			
 
				+    (map: GenMapping, mapping: {
			
 
				+        generated: Pos;
			
 
				+        source: string;
			
 
				+        original: Pos;
			
 
				+        name?: null;
			
 
				+        content?: string | null;
			
 
				+    }): void;
			
 
				+    (map: GenMapping, mapping: {
			
 
				+        generated: Pos;
			
 
				+        source: string;
			
 
				+        original: Pos;
			
 
				+        name: string;
			
 
				+        content?: string | null;
			
 
				+    }): void;
			
 
				+};
			
 
				+/**
			
 
				+ * Same as `addSegment`, but will only add the segment if it generates useful information in the
			
 
				+ * resulting map. This only works correctly if segments are added **in order**, meaning you should
			
 
				+ * not add a segment with a lower generated line/column than one that came before.
			
 
				+ */
			
 
				+export declare let maybeAddSegment: typeof addSegment;
			
 
				+/**
			
 
				+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
			
 
				+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
			
 
				+ * not add a mapping with a lower generated line/column than one that came before.
			
 
				+ */
			
 
				+export declare let maybeAddMapping: typeof addMapping;
			
 
				+/**
			
 
				+ * Adds/removes the content of the source file to the source map.
			
 
				+ */
			
 
				+export declare let setSourceContent: (map: GenMapping, source: string, content: string | null) => void;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+export declare let toDecodedMap: (map: GenMapping) => DecodedSourceMap;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+export declare let toEncodedMap: (map: GenMapping) => EncodedSourceMap;
			
 
				+/**
			
 
				+ * Constructs a new GenMapping, using the already present mappings of the input.
			
 
				+ */
			
 
				+export declare let fromMap: (input: SourceMapInput) => GenMapping;
			
 
				+/**
			
 
				+ * Returns an array of high-level mapping objects for every recorded segment, which could then be
			
 
				+ * passed to the `source-map` library.
			
 
				+ */
			
 
				+export declare let allMappings: (map: GenMapping) => Mapping[];
			
 
				+/**
			
 
				+ * Provides the state to generate a sourcemap.
			
 
				+ */
			
 
				+export declare class GenMapping {
			
 
				+    private _names;
			
 
				+    private _sources;
			
 
				+    private _sourcesContent;
			
 
				+    private _mappings;
			
 
				+    file: string | null | undefined;
			
 
				+    sourceRoot: string | null | undefined;
			
 
				+    constructor({ file, sourceRoot }?: Options);
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts
+++ b/day37/node_modules/@jridgewell/gen-mapping/dist/types/sourcemap-segment.d.ts
@@ -0,0 +1,12 @@
 
				+declare type GeneratedColumn = number;
			
 
				+declare type SourcesIndex = number;
			
 
				+declare type SourceLine = number;
			
 
				+declare type SourceColumn = number;
			
 
				+declare type NamesIndex = number;
			
 
				+export declare type SourceMapSegment = [GeneratedColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn] | [GeneratedColumn, SourcesIndex, SourceLine, SourceColumn, NamesIndex];
			
 
				+export declare const COLUMN = 0;
			
 
				+export declare const SOURCES_INDEX = 1;
			
 
				+export declare const SOURCE_LINE = 2;
			
 
				+export declare const SOURCE_COLUMN = 3;
			
 
				+export declare const NAMES_INDEX = 4;
			
 
				+export {};
			
--- a/day37/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts
+++ b/day37/node_modules/@jridgewell/gen-mapping/dist/types/types.d.ts
@@ -0,0 +1,35 @@
 
				+import type { SourceMapSegment } from './sourcemap-segment';
			
 
				+export interface SourceMapV3 {
			
 
				+    file?: string | null;
			
 
				+    names: readonly string[];
			
 
				+    sourceRoot?: string;
			
 
				+    sources: readonly (string | null)[];
			
 
				+    sourcesContent?: readonly (string | null)[];
			
 
				+    version: 3;
			
 
				+}
			
 
				+export interface EncodedSourceMap extends SourceMapV3 {
			
 
				+    mappings: string;
			
 
				+}
			
 
				+export interface DecodedSourceMap extends SourceMapV3 {
			
 
				+    mappings: readonly SourceMapSegment[][];
			
 
				+}
			
 
				+export interface Pos {
			
 
				+    line: number;
			
 
				+    column: number;
			
 
				+}
			
 
				+export declare type Mapping = {
			
 
				+    generated: Pos;
			
 
				+    source: undefined;
			
 
				+    original: undefined;
			
 
				+    name: undefined;
			
 
				+} | {
			
 
				+    generated: Pos;
			
 
				+    source: string;
			
 
				+    original: Pos;
			
 
				+    name: string;
			
 
				+} | {
			
 
				+    generated: Pos;
			
 
				+    source: string;
			
 
				+    original: Pos;
			
 
				+    name: undefined;
			
 
				+};
			
--- a/day37/node_modules/@jridgewell/gen-mapping/package.json
+++ b/day37/node_modules/@jridgewell/gen-mapping/package.json
@@ -0,0 +1,77 @@
 
				+{
			
 
				+  "name": "@jridgewell/gen-mapping",
			
 
				+  "version": "0.3.3",
			
 
				+  "description": "Generate source maps",
			
 
				+  "keywords": [
			
 
				+    "source",
			
 
				+    "map"
			
 
				+  ],
			
 
				+  "author": "Justin Ridgewell <justin@ridgewell.name>",
			
 
				+  "license": "MIT",
			
 
				+  "repository": "https://github.com/jridgewell/gen-mapping",
			
 
				+  "main": "dist/gen-mapping.umd.js",
			
 
				+  "module": "dist/gen-mapping.mjs",
			
 
				+  "types": "dist/types/gen-mapping.d.ts",
			
 
				+  "exports": {
			
 
				+    ".": [
			
 
				+      {
			
 
				+        "types": "./dist/types/gen-mapping.d.ts",
			
 
				+        "browser": "./dist/gen-mapping.umd.js",
			
 
				+        "require": "./dist/gen-mapping.umd.js",
			
 
				+        "import": "./dist/gen-mapping.mjs"
			
 
				+      },
			
 
				+      "./dist/gen-mapping.umd.js"
			
 
				+    ],
			
 
				+    "./package.json": "./package.json"
			
 
				+  },
			
 
				+  "files": [
			
 
				+    "dist"
			
 
				+  ],
			
 
				+  "engines": {
			
 
				+    "node": ">=6.0.0"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "benchmark": "run-s build:rollup benchmark:*",
			
 
				+    "benchmark:install": "cd benchmark && npm install",
			
 
				+    "benchmark:only": "node benchmark/index.mjs",
			
 
				+    "prebuild": "rm -rf dist",
			
 
				+    "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",
			
 
				+    "pretest": "run-s build:rollup",
			
 
				+    "test": "run-s -n test:lint test:coverage",
			
 
				+    "test:debug": "mocha --inspect-brk",
			
 
				+    "test:lint": "run-s -n test:lint:*",
			
 
				+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
			
 
				+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
			
 
				+    "test:only": "mocha",
			
 
				+    "test:coverage": "c8 mocha",
			
 
				+    "test:watch": "run-p 'build:rollup -- --watch' 'test:only -- --watch'",
			
 
				+    "prepublishOnly": "npm run preversion",
			
 
				+    "preversion": "run-s test build"
			
 
				+  },
			
 
				+  "devDependencies": {
			
 
				+    "@rollup/plugin-typescript": "8.3.2",
			
 
				+    "@types/mocha": "9.1.1",
			
 
				+    "@types/node": "17.0.29",
			
 
				+    "@typescript-eslint/eslint-plugin": "5.21.0",
			
 
				+    "@typescript-eslint/parser": "5.21.0",
			
 
				+    "benchmark": "2.1.4",
			
 
				+    "c8": "7.11.2",
			
 
				+    "eslint": "8.14.0",
			
 
				+    "eslint-config-prettier": "8.5.0",
			
 
				+    "mocha": "9.2.2",
			
 
				+    "npm-run-all": "4.1.5",
			
 
				+    "prettier": "2.6.2",
			
 
				+    "rollup": "2.70.2",
			
 
				+    "typescript": "4.6.3"
			
 
				+  },
			
 
				+  "dependencies": {
			
 
				+    "@jridgewell/set-array": "^1.0.1",
			
 
				+    "@jridgewell/sourcemap-codec": "^1.4.10",
			
 
				+    "@jridgewell/trace-mapping": "^0.3.9"
			
 
				+  }
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/resolve-uri/LICENSE
+++ b/day37/node_modules/@jridgewell/resolve-uri/LICENSE
@@ -0,0 +1,19 @@
 
				+Copyright 2019 Justin Ridgewell <jridgewell@google.com>
			
 
				+
			
 
				+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/day37/node_modules/@jridgewell/resolve-uri/README.md
+++ b/day37/node_modules/@jridgewell/resolve-uri/README.md
@@ -0,0 +1,40 @@
 
				+# @jridgewell/resolve-uri
			
 
				+
			
 
				+> Resolve a URI relative to an optional base URI
			
 
				+
			
 
				+Resolve any combination of absolute URIs, protocol-realtive URIs, absolute paths, or relative paths.
			
 
				+
			
 
				+## Installation
			
 
				+
			
 
				+```sh
			
 
				+npm install @jridgewell/resolve-uri
			
 
				+```
			
 
				+
			
 
				+## Usage
			
 
				+
			
 
				+```typescript
			
 
				+function resolve(input: string, base?: string): string;
			
 
				+```
			
 
				+
			
 
				+```js
			
 
				+import resolve from '@jridgewell/resolve-uri';
			
 
				+
			
 
				+resolve('foo', 'https://example.com'); // => 'https://example.com/foo'
			
 
				+```
			
 
				+
			
 
				+| Input                 | Base                    | Resolution                     | Explanation                                                  |
			
 
				+|-----------------------|-------------------------|--------------------------------|--------------------------------------------------------------|
			
 
				+| `https://example.com` | _any_                   | `https://example.com/`         | Input is normalized only                                     |
			
 
				+| `//example.com`       | `https://base.com/`     | `https://example.com/`         | Input inherits the base's protocol                           |
			
 
				+| `//example.com`       | _rest_                  | `//example.com/`               | Input is normalized only                                     |
			
 
				+| `/example`            | `https://base.com/`     | `https://base.com/example`     | Input inherits the base's origin                             |
			
 
				+| `/example`            | `//base.com/`           | `//base.com/example`           | Input inherits the base's host and remains protocol relative |
			
 
				+| `/example`            | _rest_                  | `/example`                     | Input is normalized only                                     |
			
 
				+| `example`             | `https://base.com/dir/` | `https://base.com/dir/example` | Input is joined with the base                                |
			
 
				+| `example`             | `https://base.com/file` | `https://base.com/example`     | Input is joined with the base without its file               |
			
 
				+| `example`             | `//base.com/dir/`       | `//base.com/dir/example`       | Input is joined with the base's last directory               |
			
 
				+| `example`             | `//base.com/file`       | `//base.com/example`           | Input is joined with the base without its file               |
			
 
				+| `example`             | `/base/dir/`            | `/base/dir/example`            | Input is joined with the base's last directory               |
			
 
				+| `example`             | `/base/file`            | `/base/example`                | Input is joined with the base without its file               |
			
 
				+| `example`             | `base/dir/`             | `base/dir/example`             | Input is joined with the base's last directory               |
			
 
				+| `example`             | `base/file`             | `base/example`                 | Input is joined with the base without its file               |
			
--- a/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
+++ b/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs
@@ -0,0 +1,242 @@
 
				+// Matches the scheme of a URL, eg "http://"
			
 
				+const schemeRegex = /^[\w+.-]+:\/\//;
			
 
				+/**
			
 
				+ * Matches the parts of a URL:
			
 
				+ * 1. Scheme, including ":", guaranteed.
			
 
				+ * 2. User/password, including "@", optional.
			
 
				+ * 3. Host, guaranteed.
			
 
				+ * 4. Port, including ":", optional.
			
 
				+ * 5. Path, including "/", optional.
			
 
				+ * 6. Query, including "?", optional.
			
 
				+ * 7. Hash, including "#", optional.
			
 
				+ */
			
 
				+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
			
 
				+/**
			
 
				+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
			
 
				+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
			
 
				+ *
			
 
				+ * 1. Host, optional.
			
 
				+ * 2. Path, which may include "/", guaranteed.
			
 
				+ * 3. Query, including "?", optional.
			
 
				+ * 4. Hash, including "#", optional.
			
 
				+ */
			
 
				+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
			
 
				+var UrlType;
			
 
				+(function (UrlType) {
			
 
				+    UrlType[UrlType["Empty"] = 1] = "Empty";
			
 
				+    UrlType[UrlType["Hash"] = 2] = "Hash";
			
 
				+    UrlType[UrlType["Query"] = 3] = "Query";
			
 
				+    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
			
 
				+    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
			
 
				+    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
			
 
				+    UrlType[UrlType["Absolute"] = 7] = "Absolute";
			
 
				+})(UrlType || (UrlType = {}));
			
 
				+function isAbsoluteUrl(input) {
			
 
				+    return schemeRegex.test(input);
			
 
				+}
			
 
				+function isSchemeRelativeUrl(input) {
			
 
				+    return input.startsWith('//');
			
 
				+}
			
 
				+function isAbsolutePath(input) {
			
 
				+    return input.startsWith('/');
			
 
				+}
			
 
				+function isFileUrl(input) {
			
 
				+    return input.startsWith('file:');
			
 
				+}
			
 
				+function isRelative(input) {
			
 
				+    return /^[.?#]/.test(input);
			
 
				+}
			
 
				+function parseAbsoluteUrl(input) {
			
 
				+    const match = urlRegex.exec(input);
			
 
				+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
			
 
				+}
			
 
				+function parseFileUrl(input) {
			
 
				+    const match = fileRegex.exec(input);
			
 
				+    const path = match[2];
			
 
				+    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
			
 
				+}
			
 
				+function makeUrl(scheme, user, host, port, path, query, hash) {
			
 
				+    return {
			
 
				+        scheme,
			
 
				+        user,
			
 
				+        host,
			
 
				+        port,
			
 
				+        path,
			
 
				+        query,
			
 
				+        hash,
			
 
				+        type: UrlType.Absolute,
			
 
				+    };
			
 
				+}
			
 
				+function parseUrl(input) {
			
 
				+    if (isSchemeRelativeUrl(input)) {
			
 
				+        const url = parseAbsoluteUrl('http:' + input);
			
 
				+        url.scheme = '';
			
 
				+        url.type = UrlType.SchemeRelative;
			
 
				+        return url;
			
 
				+    }
			
 
				+    if (isAbsolutePath(input)) {
			
 
				+        const url = parseAbsoluteUrl('http://foo.com' + input);
			
 
				+        url.scheme = '';
			
 
				+        url.host = '';
			
 
				+        url.type = UrlType.AbsolutePath;
			
 
				+        return url;
			
 
				+    }
			
 
				+    if (isFileUrl(input))
			
 
				+        return parseFileUrl(input);
			
 
				+    if (isAbsoluteUrl(input))
			
 
				+        return parseAbsoluteUrl(input);
			
 
				+    const url = parseAbsoluteUrl('http://foo.com/' + input);
			
 
				+    url.scheme = '';
			
 
				+    url.host = '';
			
 
				+    url.type = input
			
 
				+        ? input.startsWith('?')
			
 
				+            ? UrlType.Query
			
 
				+            : input.startsWith('#')
			
 
				+                ? UrlType.Hash
			
 
				+                : UrlType.RelativePath
			
 
				+        : UrlType.Empty;
			
 
				+    return url;
			
 
				+}
			
 
				+function stripPathFilename(path) {
			
 
				+    // If a path ends with a parent directory "..", then it's a relative path with excess parent
			
 
				+    // paths. It's not a file, so we can't strip it.
			
 
				+    if (path.endsWith('/..'))
			
 
				+        return path;
			
 
				+    const index = path.lastIndexOf('/');
			
 
				+    return path.slice(0, index + 1);
			
 
				+}
			
 
				+function mergePaths(url, base) {
			
 
				+    normalizePath(base, base.type);
			
 
				+    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
			
 
				+    // path).
			
 
				+    if (url.path === '/') {
			
 
				+        url.path = base.path;
			
 
				+    }
			
 
				+    else {
			
 
				+        // Resolution happens relative to the base path's directory, not the file.
			
 
				+        url.path = stripPathFilename(base.path) + url.path;
			
 
				+    }
			
 
				+}
			
 
				+/**
			
 
				+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
			
 
				+ * "foo/.". We need to normalize to a standard representation.
			
 
				+ */
			
 
				+function normalizePath(url, type) {
			
 
				+    const rel = type <= UrlType.RelativePath;
			
 
				+    const pieces = url.path.split('/');
			
 
				+    // We need to preserve the first piece always, so that we output a leading slash. The item at
			
 
				+    // pieces[0] is an empty string.
			
 
				+    let pointer = 1;
			
 
				+    // Positive is the number of real directories we've output, used for popping a parent directory.
			
 
				+    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
			
 
				+    let positive = 0;
			
 
				+    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
			
 
				+    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
			
 
				+    // real directory, we won't need to append, unless the other conditions happen again.
			
 
				+    let addTrailingSlash = false;
			
 
				+    for (let i = 1; i < pieces.length; i++) {
			
 
				+        const piece = pieces[i];
			
 
				+        // An empty directory, could be a trailing slash, or just a double "//" in the path.
			
 
				+        if (!piece) {
			
 
				+            addTrailingSlash = true;
			
 
				+            continue;
			
 
				+        }
			
 
				+        // If we encounter a real directory, then we don't need to append anymore.
			
 
				+        addTrailingSlash = false;
			
 
				+        // A current directory, which we can always drop.
			
 
				+        if (piece === '.')
			
 
				+            continue;
			
 
				+        // A parent directory, we need to see if there are any real directories we can pop. Else, we
			
 
				+        // have an excess of parents, and we'll need to keep the "..".
			
 
				+        if (piece === '..') {
			
 
				+            if (positive) {
			
 
				+                addTrailingSlash = true;
			
 
				+                positive--;
			
 
				+                pointer--;
			
 
				+            }
			
 
				+            else if (rel) {
			
 
				+                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
			
 
				+                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
			
 
				+                pieces[pointer++] = piece;
			
 
				+            }
			
 
				+            continue;
			
 
				+        }
			
 
				+        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
			
 
				+        // any popped or dropped directories.
			
 
				+        pieces[pointer++] = piece;
			
 
				+        positive++;
			
 
				+    }
			
 
				+    let path = '';
			
 
				+    for (let i = 1; i < pointer; i++) {
			
 
				+        path += '/' + pieces[i];
			
 
				+    }
			
 
				+    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
			
 
				+        path += '/';
			
 
				+    }
			
 
				+    url.path = path;
			
 
				+}
			
 
				+/**
			
 
				+ * Attempts to resolve `input` URL/path relative to `base`.
			
 
				+ */
			
 
				+function resolve(input, base) {
			
 
				+    if (!input && !base)
			
 
				+        return '';
			
 
				+    const url = parseUrl(input);
			
 
				+    let inputType = url.type;
			
 
				+    if (base && inputType !== UrlType.Absolute) {
			
 
				+        const baseUrl = parseUrl(base);
			
 
				+        const baseType = baseUrl.type;
			
 
				+        switch (inputType) {
			
 
				+            case UrlType.Empty:
			
 
				+                url.hash = baseUrl.hash;
			
 
				+            // fall through
			
 
				+            case UrlType.Hash:
			
 
				+                url.query = baseUrl.query;
			
 
				+            // fall through
			
 
				+            case UrlType.Query:
			
 
				+            case UrlType.RelativePath:
			
 
				+                mergePaths(url, baseUrl);
			
 
				+            // fall through
			
 
				+            case UrlType.AbsolutePath:
			
 
				+                // The host, user, and port are joined, you can't copy one without the others.
			
 
				+                url.user = baseUrl.user;
			
 
				+                url.host = baseUrl.host;
			
 
				+                url.port = baseUrl.port;
			
 
				+            // fall through
			
 
				+            case UrlType.SchemeRelative:
			
 
				+                // The input doesn't have a schema at least, so we need to copy at least that over.
			
 
				+                url.scheme = baseUrl.scheme;
			
 
				+        }
			
 
				+        if (baseType > inputType)
			
 
				+            inputType = baseType;
			
 
				+    }
			
 
				+    normalizePath(url, inputType);
			
 
				+    const queryHash = url.query + url.hash;
			
 
				+    switch (inputType) {
			
 
				+        // This is impossible, because of the empty checks at the start of the function.
			
 
				+        // case UrlType.Empty:
			
 
				+        case UrlType.Hash:
			
 
				+        case UrlType.Query:
			
 
				+            return queryHash;
			
 
				+        case UrlType.RelativePath: {
			
 
				+            // The first char is always a "/", and we need it to be relative.
			
 
				+            const path = url.path.slice(1);
			
 
				+            if (!path)
			
 
				+                return queryHash || '.';
			
 
				+            if (isRelative(base || input) && !isRelative(path)) {
			
 
				+                // If base started with a leading ".", or there is no base and input started with a ".",
			
 
				+                // then we need to ensure that the relative path starts with a ".". We don't know if
			
 
				+                // relative starts with a "..", though, so check before prepending.
			
 
				+                return './' + path + queryHash;
			
 
				+            }
			
 
				+            return path + queryHash;
			
 
				+        }
			
 
				+        case UrlType.AbsolutePath:
			
 
				+            return url.path + queryHash;
			
 
				+        default:
			
 
				+            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+export { resolve as default };
			
 
				+//# sourceMappingURL=resolve-uri.mjs.map
			
--- a/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map
+++ b/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.mjs.map
--- a/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
+++ b/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
@@ -0,0 +1,250 @@
 
				+(function (global, factory) {
			
 
				+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
			
 
				+    typeof define === 'function' && define.amd ? define(factory) :
			
 
				+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.resolveURI = factory());
			
 
				+})(this, (function () { 'use strict';
			
 
				+
			
 
				+    // Matches the scheme of a URL, eg "http://"
			
 
				+    const schemeRegex = /^[\w+.-]+:\/\//;
			
 
				+    /**
			
 
				+     * Matches the parts of a URL:
			
 
				+     * 1. Scheme, including ":", guaranteed.
			
 
				+     * 2. User/password, including "@", optional.
			
 
				+     * 3. Host, guaranteed.
			
 
				+     * 4. Port, including ":", optional.
			
 
				+     * 5. Path, including "/", optional.
			
 
				+     * 6. Query, including "?", optional.
			
 
				+     * 7. Hash, including "#", optional.
			
 
				+     */
			
 
				+    const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
			
 
				+    /**
			
 
				+     * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
			
 
				+     * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
			
 
				+     *
			
 
				+     * 1. Host, optional.
			
 
				+     * 2. Path, which may include "/", guaranteed.
			
 
				+     * 3. Query, including "?", optional.
			
 
				+     * 4. Hash, including "#", optional.
			
 
				+     */
			
 
				+    const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
			
 
				+    var UrlType;
			
 
				+    (function (UrlType) {
			
 
				+        UrlType[UrlType["Empty"] = 1] = "Empty";
			
 
				+        UrlType[UrlType["Hash"] = 2] = "Hash";
			
 
				+        UrlType[UrlType["Query"] = 3] = "Query";
			
 
				+        UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
			
 
				+        UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
			
 
				+        UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
			
 
				+        UrlType[UrlType["Absolute"] = 7] = "Absolute";
			
 
				+    })(UrlType || (UrlType = {}));
			
 
				+    function isAbsoluteUrl(input) {
			
 
				+        return schemeRegex.test(input);
			
 
				+    }
			
 
				+    function isSchemeRelativeUrl(input) {
			
 
				+        return input.startsWith('//');
			
 
				+    }
			
 
				+    function isAbsolutePath(input) {
			
 
				+        return input.startsWith('/');
			
 
				+    }
			
 
				+    function isFileUrl(input) {
			
 
				+        return input.startsWith('file:');
			
 
				+    }
			
 
				+    function isRelative(input) {
			
 
				+        return /^[.?#]/.test(input);
			
 
				+    }
			
 
				+    function parseAbsoluteUrl(input) {
			
 
				+        const match = urlRegex.exec(input);
			
 
				+        return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
			
 
				+    }
			
 
				+    function parseFileUrl(input) {
			
 
				+        const match = fileRegex.exec(input);
			
 
				+        const path = match[2];
			
 
				+        return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
			
 
				+    }
			
 
				+    function makeUrl(scheme, user, host, port, path, query, hash) {
			
 
				+        return {
			
 
				+            scheme,
			
 
				+            user,
			
 
				+            host,
			
 
				+            port,
			
 
				+            path,
			
 
				+            query,
			
 
				+            hash,
			
 
				+            type: UrlType.Absolute,
			
 
				+        };
			
 
				+    }
			
 
				+    function parseUrl(input) {
			
 
				+        if (isSchemeRelativeUrl(input)) {
			
 
				+            const url = parseAbsoluteUrl('http:' + input);
			
 
				+            url.scheme = '';
			
 
				+            url.type = UrlType.SchemeRelative;
			
 
				+            return url;
			
 
				+        }
			
 
				+        if (isAbsolutePath(input)) {
			
 
				+            const url = parseAbsoluteUrl('http://foo.com' + input);
			
 
				+            url.scheme = '';
			
 
				+            url.host = '';
			
 
				+            url.type = UrlType.AbsolutePath;
			
 
				+            return url;
			
 
				+        }
			
 
				+        if (isFileUrl(input))
			
 
				+            return parseFileUrl(input);
			
 
				+        if (isAbsoluteUrl(input))
			
 
				+            return parseAbsoluteUrl(input);
			
 
				+        const url = parseAbsoluteUrl('http://foo.com/' + input);
			
 
				+        url.scheme = '';
			
 
				+        url.host = '';
			
 
				+        url.type = input
			
 
				+            ? input.startsWith('?')
			
 
				+                ? UrlType.Query
			
 
				+                : input.startsWith('#')
			
 
				+                    ? UrlType.Hash
			
 
				+                    : UrlType.RelativePath
			
 
				+            : UrlType.Empty;
			
 
				+        return url;
			
 
				+    }
			
 
				+    function stripPathFilename(path) {
			
 
				+        // If a path ends with a parent directory "..", then it's a relative path with excess parent
			
 
				+        // paths. It's not a file, so we can't strip it.
			
 
				+        if (path.endsWith('/..'))
			
 
				+            return path;
			
 
				+        const index = path.lastIndexOf('/');
			
 
				+        return path.slice(0, index + 1);
			
 
				+    }
			
 
				+    function mergePaths(url, base) {
			
 
				+        normalizePath(base, base.type);
			
 
				+        // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
			
 
				+        // path).
			
 
				+        if (url.path === '/') {
			
 
				+            url.path = base.path;
			
 
				+        }
			
 
				+        else {
			
 
				+            // Resolution happens relative to the base path's directory, not the file.
			
 
				+            url.path = stripPathFilename(base.path) + url.path;
			
 
				+        }
			
 
				+    }
			
 
				+    /**
			
 
				+     * The path can have empty directories "//", unneeded parents "foo/..", or current directory
			
 
				+     * "foo/.". We need to normalize to a standard representation.
			
 
				+     */
			
 
				+    function normalizePath(url, type) {
			
 
				+        const rel = type <= UrlType.RelativePath;
			
 
				+        const pieces = url.path.split('/');
			
 
				+        // We need to preserve the first piece always, so that we output a leading slash. The item at
			
 
				+        // pieces[0] is an empty string.
			
 
				+        let pointer = 1;
			
 
				+        // Positive is the number of real directories we've output, used for popping a parent directory.
			
 
				+        // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
			
 
				+        let positive = 0;
			
 
				+        // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
			
 
				+        // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
			
 
				+        // real directory, we won't need to append, unless the other conditions happen again.
			
 
				+        let addTrailingSlash = false;
			
 
				+        for (let i = 1; i < pieces.length; i++) {
			
 
				+            const piece = pieces[i];
			
 
				+            // An empty directory, could be a trailing slash, or just a double "//" in the path.
			
 
				+            if (!piece) {
			
 
				+                addTrailingSlash = true;
			
 
				+                continue;
			
 
				+            }
			
 
				+            // If we encounter a real directory, then we don't need to append anymore.
			
 
				+            addTrailingSlash = false;
			
 
				+            // A current directory, which we can always drop.
			
 
				+            if (piece === '.')
			
 
				+                continue;
			
 
				+            // A parent directory, we need to see if there are any real directories we can pop. Else, we
			
 
				+            // have an excess of parents, and we'll need to keep the "..".
			
 
				+            if (piece === '..') {
			
 
				+                if (positive) {
			
 
				+                    addTrailingSlash = true;
			
 
				+                    positive--;
			
 
				+                    pointer--;
			
 
				+                }
			
 
				+                else if (rel) {
			
 
				+                    // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
			
 
				+                    // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
			
 
				+                    pieces[pointer++] = piece;
			
 
				+                }
			
 
				+                continue;
			
 
				+            }
			
 
				+            // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
			
 
				+            // any popped or dropped directories.
			
 
				+            pieces[pointer++] = piece;
			
 
				+            positive++;
			
 
				+        }
			
 
				+        let path = '';
			
 
				+        for (let i = 1; i < pointer; i++) {
			
 
				+            path += '/' + pieces[i];
			
 
				+        }
			
 
				+        if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
			
 
				+            path += '/';
			
 
				+        }
			
 
				+        url.path = path;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Attempts to resolve `input` URL/path relative to `base`.
			
 
				+     */
			
 
				+    function resolve(input, base) {
			
 
				+        if (!input && !base)
			
 
				+            return '';
			
 
				+        const url = parseUrl(input);
			
 
				+        let inputType = url.type;
			
 
				+        if (base && inputType !== UrlType.Absolute) {
			
 
				+            const baseUrl = parseUrl(base);
			
 
				+            const baseType = baseUrl.type;
			
 
				+            switch (inputType) {
			
 
				+                case UrlType.Empty:
			
 
				+                    url.hash = baseUrl.hash;
			
 
				+                // fall through
			
 
				+                case UrlType.Hash:
			
 
				+                    url.query = baseUrl.query;
			
 
				+                // fall through
			
 
				+                case UrlType.Query:
			
 
				+                case UrlType.RelativePath:
			
 
				+                    mergePaths(url, baseUrl);
			
 
				+                // fall through
			
 
				+                case UrlType.AbsolutePath:
			
 
				+                    // The host, user, and port are joined, you can't copy one without the others.
			
 
				+                    url.user = baseUrl.user;
			
 
				+                    url.host = baseUrl.host;
			
 
				+                    url.port = baseUrl.port;
			
 
				+                // fall through
			
 
				+                case UrlType.SchemeRelative:
			
 
				+                    // The input doesn't have a schema at least, so we need to copy at least that over.
			
 
				+                    url.scheme = baseUrl.scheme;
			
 
				+            }
			
 
				+            if (baseType > inputType)
			
 
				+                inputType = baseType;
			
 
				+        }
			
 
				+        normalizePath(url, inputType);
			
 
				+        const queryHash = url.query + url.hash;
			
 
				+        switch (inputType) {
			
 
				+            // This is impossible, because of the empty checks at the start of the function.
			
 
				+            // case UrlType.Empty:
			
 
				+            case UrlType.Hash:
			
 
				+            case UrlType.Query:
			
 
				+                return queryHash;
			
 
				+            case UrlType.RelativePath: {
			
 
				+                // The first char is always a "/", and we need it to be relative.
			
 
				+                const path = url.path.slice(1);
			
 
				+                if (!path)
			
 
				+                    return queryHash || '.';
			
 
				+                if (isRelative(base || input) && !isRelative(path)) {
			
 
				+                    // If base started with a leading ".", or there is no base and input started with a ".",
			
 
				+                    // then we need to ensure that the relative path starts with a ".". We don't know if
			
 
				+                    // relative starts with a "..", though, so check before prepending.
			
 
				+                    return './' + path + queryHash;
			
 
				+                }
			
 
				+                return path + queryHash;
			
 
				+            }
			
 
				+            case UrlType.AbsolutePath:
			
 
				+                return url.path + queryHash;
			
 
				+            default:
			
 
				+                return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    return resolve;
			
 
				+
			
 
				+}));
			
 
				+//# sourceMappingURL=resolve-uri.umd.js.map
			
--- a/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map
+++ b/day37/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js.map
--- a/day37/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts
+++ b/day37/node_modules/@jridgewell/resolve-uri/dist/types/resolve-uri.d.ts
@@ -0,0 +1,4 @@
 
				+/**
			
 
				+ * Attempts to resolve `input` URL/path relative to `base`.
			
 
				+ */
			
 
				+export default function resolve(input: string, base: string | undefined): string;
			
--- a/day37/node_modules/@jridgewell/resolve-uri/package.json
+++ b/day37/node_modules/@jridgewell/resolve-uri/package.json
@@ -0,0 +1,69 @@
 
				+{
			
 
				+  "name": "@jridgewell/resolve-uri",
			
 
				+  "version": "3.1.1",
			
 
				+  "description": "Resolve a URI relative to an optional base URI",
			
 
				+  "keywords": [
			
 
				+    "resolve",
			
 
				+    "uri",
			
 
				+    "url",
			
 
				+    "path"
			
 
				+  ],
			
 
				+  "author": "Justin Ridgewell <justin@ridgewell.name>",
			
 
				+  "license": "MIT",
			
 
				+  "repository": "https://github.com/jridgewell/resolve-uri",
			
 
				+  "main": "dist/resolve-uri.umd.js",
			
 
				+  "module": "dist/resolve-uri.mjs",
			
 
				+  "types": "dist/types/resolve-uri.d.ts",
			
 
				+  "exports": {
			
 
				+    ".": [
			
 
				+      {
			
 
				+        "types": "./dist/types/resolve-uri.d.ts",
			
 
				+        "browser": "./dist/resolve-uri.umd.js",
			
 
				+        "require": "./dist/resolve-uri.umd.js",
			
 
				+        "import": "./dist/resolve-uri.mjs"
			
 
				+      },
			
 
				+      "./dist/resolve-uri.umd.js"
			
 
				+    ],
			
 
				+    "./package.json": "./package.json"
			
 
				+  },
			
 
				+  "files": [
			
 
				+    "dist"
			
 
				+  ],
			
 
				+  "engines": {
			
 
				+    "node": ">=6.0.0"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "prebuild": "rm -rf dist",
			
 
				+    "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",
			
 
				+    "pretest": "run-s build:rollup",
			
 
				+    "test": "run-s -n test:lint test:only",
			
 
				+    "test:debug": "mocha --inspect-brk",
			
 
				+    "test:lint": "run-s -n test:lint:*",
			
 
				+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
			
 
				+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
			
 
				+    "test:only": "mocha",
			
 
				+    "test:coverage": "c8 mocha",
			
 
				+    "test:watch": "mocha --watch",
			
 
				+    "prepublishOnly": "npm run preversion",
			
 
				+    "preversion": "run-s test build"
			
 
				+  },
			
 
				+  "devDependencies": {
			
 
				+    "@jridgewell/resolve-uri-latest": "npm:@jridgewell/resolve-uri@*",
			
 
				+    "@rollup/plugin-typescript": "8.3.0",
			
 
				+    "@typescript-eslint/eslint-plugin": "5.10.0",
			
 
				+    "@typescript-eslint/parser": "5.10.0",
			
 
				+    "c8": "7.11.0",
			
 
				+    "eslint": "8.7.0",
			
 
				+    "eslint-config-prettier": "8.3.0",
			
 
				+    "mocha": "9.2.0",
			
 
				+    "npm-run-all": "4.1.5",
			
 
				+    "prettier": "2.5.1",
			
 
				+    "rollup": "2.66.0",
			
 
				+    "typescript": "4.5.5"
			
 
				+  }
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/set-array/LICENSE
+++ b/day37/node_modules/@jridgewell/set-array/LICENSE
@@ -0,0 +1,19 @@
 
				+Copyright 2022 Justin Ridgewell <jridgewell@google.com>
			
 
				+
			
 
				+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/day37/node_modules/@jridgewell/set-array/README.md
+++ b/day37/node_modules/@jridgewell/set-array/README.md
@@ -0,0 +1,37 @@
 
				+# @jridgewell/set-array
			
 
				+
			
 
				+> Like a Set, but provides the index of the `key` in the backing array
			
 
				+
			
 
				+This is designed to allow synchronizing a second array with the contents of the backing array, like
			
 
				+how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`, and there
			
 
				+are never duplicates.
			
 
				+
			
 
				+## Installation
			
 
				+
			
 
				+```sh
			
 
				+npm install @jridgewell/set-array
			
 
				+```
			
 
				+
			
 
				+## Usage
			
 
				+
			
 
				+```js
			
 
				+import { SetArray, get, put, pop } from '@jridgewell/set-array';
			
 
				+
			
 
				+const sa = new SetArray();
			
 
				+
			
 
				+let index = put(sa, 'first');
			
 
				+assert.strictEqual(index, 0);
			
 
				+
			
 
				+index = put(sa, 'second');
			
 
				+assert.strictEqual(index, 1);
			
 
				+
			
 
				+assert.deepEqual(sa.array, [ 'first', 'second' ]);
			
 
				+
			
 
				+index = get(sa, 'first');
			
 
				+assert.strictEqual(index, 0);
			
 
				+
			
 
				+pop(sa);
			
 
				+index = get(sa, 'second');
			
 
				+assert.strictEqual(index, undefined);
			
 
				+assert.deepEqual(sa.array, [ 'first' ]);
			
 
				+```
			
--- a/day37/node_modules/@jridgewell/set-array/dist/set-array.mjs
+++ b/day37/node_modules/@jridgewell/set-array/dist/set-array.mjs
@@ -0,0 +1,48 @@
 
				+/**
			
 
				+ * Gets the index associated with `key` in the backing array, if it is already present.
			
 
				+ */
			
 
				+let get;
			
 
				+/**
			
 
				+ * Puts `key` into the backing array, if it is not already present. Returns
			
 
				+ * the index of the `key` in the backing array.
			
 
				+ */
			
 
				+let put;
			
 
				+/**
			
 
				+ * Pops the last added item out of the SetArray.
			
 
				+ */
			
 
				+let pop;
			
 
				+/**
			
 
				+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
			
 
				+ * index of the `key` in the backing array.
			
 
				+ *
			
 
				+ * This is designed to allow synchronizing a second array with the contents of the backing array,
			
 
				+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
			
 
				+ * and there are never duplicates.
			
 
				+ */
			
 
				+class SetArray {
			
 
				+    constructor() {
			
 
				+        this._indexes = { __proto__: null };
			
 
				+        this.array = [];
			
 
				+    }
			
 
				+}
			
 
				+(() => {
			
 
				+    get = (strarr, key) => strarr._indexes[key];
			
 
				+    put = (strarr, key) => {
			
 
				+        // The key may or may not be present. If it is present, it's a number.
			
 
				+        const index = get(strarr, key);
			
 
				+        if (index !== undefined)
			
 
				+            return index;
			
 
				+        const { array, _indexes: indexes } = strarr;
			
 
				+        return (indexes[key] = array.push(key) - 1);
			
 
				+    };
			
 
				+    pop = (strarr) => {
			
 
				+        const { array, _indexes: indexes } = strarr;
			
 
				+        if (array.length === 0)
			
 
				+            return;
			
 
				+        const last = array.pop();
			
 
				+        indexes[last] = undefined;
			
 
				+    };
			
 
				+})();
			
 
				+
			
 
				+export { SetArray, get, pop, put };
			
 
				+//# sourceMappingURL=set-array.mjs.map
			
--- a/day37/node_modules/@jridgewell/set-array/dist/set-array.mjs.map
+++ b/day37/node_modules/@jridgewell/set-array/dist/set-array.mjs.map
--- a/day37/node_modules/@jridgewell/set-array/dist/set-array.umd.js
+++ b/day37/node_modules/@jridgewell/set-array/dist/set-array.umd.js
@@ -0,0 +1,58 @@
 
				+(function (global, factory) {
			
 
				+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
			
 
				+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
			
 
				+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.setArray = {}));
			
 
				+})(this, (function (exports) { 'use strict';
			
 
				+
			
 
				+    /**
			
 
				+     * Gets the index associated with `key` in the backing array, if it is already present.
			
 
				+     */
			
 
				+    exports.get = void 0;
			
 
				+    /**
			
 
				+     * Puts `key` into the backing array, if it is not already present. Returns
			
 
				+     * the index of the `key` in the backing array.
			
 
				+     */
			
 
				+    exports.put = void 0;
			
 
				+    /**
			
 
				+     * Pops the last added item out of the SetArray.
			
 
				+     */
			
 
				+    exports.pop = void 0;
			
 
				+    /**
			
 
				+     * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
			
 
				+     * index of the `key` in the backing array.
			
 
				+     *
			
 
				+     * This is designed to allow synchronizing a second array with the contents of the backing array,
			
 
				+     * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
			
 
				+     * and there are never duplicates.
			
 
				+     */
			
 
				+    class SetArray {
			
 
				+        constructor() {
			
 
				+            this._indexes = { __proto__: null };
			
 
				+            this.array = [];
			
 
				+        }
			
 
				+    }
			
 
				+    (() => {
			
 
				+        exports.get = (strarr, key) => strarr._indexes[key];
			
 
				+        exports.put = (strarr, key) => {
			
 
				+            // The key may or may not be present. If it is present, it's a number.
			
 
				+            const index = exports.get(strarr, key);
			
 
				+            if (index !== undefined)
			
 
				+                return index;
			
 
				+            const { array, _indexes: indexes } = strarr;
			
 
				+            return (indexes[key] = array.push(key) - 1);
			
 
				+        };
			
 
				+        exports.pop = (strarr) => {
			
 
				+            const { array, _indexes: indexes } = strarr;
			
 
				+            if (array.length === 0)
			
 
				+                return;
			
 
				+            const last = array.pop();
			
 
				+            indexes[last] = undefined;
			
 
				+        };
			
 
				+    })();
			
 
				+
			
 
				+    exports.SetArray = SetArray;
			
 
				+
			
 
				+    Object.defineProperty(exports, '__esModule', { value: true });
			
 
				+
			
 
				+}));
			
 
				+//# sourceMappingURL=set-array.umd.js.map
			
--- a/day37/node_modules/@jridgewell/set-array/dist/set-array.umd.js.map
+++ b/day37/node_modules/@jridgewell/set-array/dist/set-array.umd.js.map
--- a/day37/node_modules/@jridgewell/set-array/dist/types/set-array.d.ts
+++ b/day37/node_modules/@jridgewell/set-array/dist/types/set-array.d.ts
@@ -0,0 +1,26 @@
 
				+/**
			
 
				+ * Gets the index associated with `key` in the backing array, if it is already present.
			
 
				+ */
			
 
				+export declare let get: (strarr: SetArray, key: string) => number | undefined;
			
 
				+/**
			
 
				+ * Puts `key` into the backing array, if it is not already present. Returns
			
 
				+ * the index of the `key` in the backing array.
			
 
				+ */
			
 
				+export declare let put: (strarr: SetArray, key: string) => number;
			
 
				+/**
			
 
				+ * Pops the last added item out of the SetArray.
			
 
				+ */
			
 
				+export declare let pop: (strarr: SetArray) => void;
			
 
				+/**
			
 
				+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
			
 
				+ * index of the `key` in the backing array.
			
 
				+ *
			
 
				+ * This is designed to allow synchronizing a second array with the contents of the backing array,
			
 
				+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
			
 
				+ * and there are never duplicates.
			
 
				+ */
			
 
				+export declare class SetArray {
			
 
				+    private _indexes;
			
 
				+    array: readonly string[];
			
 
				+    constructor();
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/set-array/package.json
+++ b/day37/node_modules/@jridgewell/set-array/package.json
@@ -0,0 +1,66 @@
 
				+{
			
 
				+  "name": "@jridgewell/set-array",
			
 
				+  "version": "1.1.2",
			
 
				+  "description": "Like a Set, but provides the index of the `key` in the backing array",
			
 
				+  "keywords": [],
			
 
				+  "author": "Justin Ridgewell <justin@ridgewell.name>",
			
 
				+  "license": "MIT",
			
 
				+  "repository": "https://github.com/jridgewell/set-array",
			
 
				+  "main": "dist/set-array.umd.js",
			
 
				+  "module": "dist/set-array.mjs",
			
 
				+  "typings": "dist/types/set-array.d.ts",
			
 
				+  "exports": {
			
 
				+    ".": [
			
 
				+      {
			
 
				+        "types": "./dist/types/set-array.d.ts",
			
 
				+        "browser": "./dist/set-array.umd.js",
			
 
				+        "require": "./dist/set-array.umd.js",
			
 
				+        "import": "./dist/set-array.mjs"
			
 
				+      },
			
 
				+      "./dist/set-array.umd.js"
			
 
				+    ],
			
 
				+    "./package.json": "./package.json"
			
 
				+  },
			
 
				+  "files": [
			
 
				+    "dist",
			
 
				+    "src"
			
 
				+  ],
			
 
				+  "engines": {
			
 
				+    "node": ">=6.0.0"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "prebuild": "rm -rf dist",
			
 
				+    "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",
			
 
				+    "pretest": "run-s build:rollup",
			
 
				+    "test": "run-s -n test:lint test:only",
			
 
				+    "test:debug": "mocha --inspect-brk",
			
 
				+    "test:lint": "run-s -n test:lint:*",
			
 
				+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
			
 
				+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
			
 
				+    "test:only": "mocha",
			
 
				+    "test:coverage": "c8 mocha",
			
 
				+    "test:watch": "mocha --watch",
			
 
				+    "prepublishOnly": "npm run preversion",
			
 
				+    "preversion": "run-s test build"
			
 
				+  },
			
 
				+  "devDependencies": {
			
 
				+    "@rollup/plugin-typescript": "8.3.0",
			
 
				+    "@types/mocha": "9.1.1",
			
 
				+    "@types/node": "17.0.29",
			
 
				+    "@typescript-eslint/eslint-plugin": "5.10.0",
			
 
				+    "@typescript-eslint/parser": "5.10.0",
			
 
				+    "c8": "7.11.0",
			
 
				+    "eslint": "8.7.0",
			
 
				+    "eslint-config-prettier": "8.3.0",
			
 
				+    "mocha": "9.2.0",
			
 
				+    "npm-run-all": "4.1.5",
			
 
				+    "prettier": "2.5.1",
			
 
				+    "rollup": "2.66.0",
			
 
				+    "typescript": "4.5.5"
			
 
				+  }
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/set-array/src/set-array.ts
+++ b/day37/node_modules/@jridgewell/set-array/src/set-array.ts
@@ -0,0 +1,55 @@
 
				+/**
			
 
				+ * Gets the index associated with `key` in the backing array, if it is already present.
			
 
				+ */
			
 
				+export let get: (strarr: SetArray, key: string) => number | undefined;
			
 
				+
			
 
				+/**
			
 
				+ * Puts `key` into the backing array, if it is not already present. Returns
			
 
				+ * the index of the `key` in the backing array.
			
 
				+ */
			
 
				+export let put: (strarr: SetArray, key: string) => number;
			
 
				+
			
 
				+/**
			
 
				+ * Pops the last added item out of the SetArray.
			
 
				+ */
			
 
				+export let pop: (strarr: SetArray) => void;
			
 
				+
			
 
				+/**
			
 
				+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
			
 
				+ * index of the `key` in the backing array.
			
 
				+ *
			
 
				+ * This is designed to allow synchronizing a second array with the contents of the backing array,
			
 
				+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
			
 
				+ * and there are never duplicates.
			
 
				+ */
			
 
				+export class SetArray {
			
 
				+  private declare _indexes: { [key: string]: number | undefined };
			
 
				+  declare array: readonly string[];
			
 
				+
			
 
				+  constructor() {
			
 
				+    this._indexes = { __proto__: null } as any;
			
 
				+    this.array = [];
			
 
				+  }
			
 
				+
			
 
				+  static {
			
 
				+    get = (strarr, key) => strarr._indexes[key];
			
 
				+
			
 
				+    put = (strarr, key) => {
			
 
				+      // The key may or may not be present. If it is present, it's a number.
			
 
				+      const index = get(strarr, key);
			
 
				+      if (index !== undefined) return index;
			
 
				+
			
 
				+      const { array, _indexes: indexes } = strarr;
			
 
				+
			
 
				+      return (indexes[key] = (array as string[]).push(key) - 1);
			
 
				+    };
			
 
				+
			
 
				+    pop = (strarr) => {
			
 
				+      const { array, _indexes: indexes } = strarr;
			
 
				+      if (array.length === 0) return;
			
 
				+
			
 
				+      const last = (array as string[]).pop()!;
			
 
				+      indexes[last] = undefined;
			
 
				+    };
			
 
				+  }
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/source-map/LICENSE
+++ b/day37/node_modules/@jridgewell/source-map/LICENSE
@@ -0,0 +1,19 @@
 
				+Copyright 2019 Justin Ridgewell <jridgewell@google.com>
			
 
				+
			
 
				+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/day37/node_modules/@jridgewell/source-map/README.md
+++ b/day37/node_modules/@jridgewell/source-map/README.md
@@ -0,0 +1,82 @@
 
				+# @jridgewell/source-map
			
 
				+
			
 
				+> Packages `@jridgewell/trace-mapping` and `@jridgewell/gen-mapping` into the familiar source-map API
			
 
				+
			
 
				+This isn't the full API, but it's the core functionality. This wraps
			
 
				+[@jridgewell/trace-mapping][trace-mapping] and [@jridgewell/gen-mapping][gen-mapping]
			
 
				+implementations.
			
 
				+
			
 
				+## Installation
			
 
				+
			
 
				+```sh
			
 
				+npm install @jridgewell/source-map
			
 
				+```
			
 
				+
			
 
				+## Usage
			
 
				+
			
 
				+TODO
			
 
				+
			
 
				+### SourceMapConsumer
			
 
				+
			
 
				+```typescript
			
 
				+import { SourceMapConsumer } from '@jridgewell/source-map';
			
 
				+const smc = new SourceMapConsumer({
			
 
				+  version: 3,
			
 
				+  names: ['foo'],
			
 
				+  sources: ['input.js'],
			
 
				+  mappings: 'AAAAA',
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+#### SourceMapConsumer.prototype.originalPositionFor(generatedPosition)
			
 
				+
			
 
				+```typescript
			
 
				+const smc = new SourceMapConsumer(map);
			
 
				+smc.originalPositionFor({ line: 1, column: 0 });
			
 
				+```
			
 
				+
			
 
				+### SourceMapGenerator
			
 
				+
			
 
				+```typescript
			
 
				+import { SourceMapGenerator } from '@jridgewell/source-map';
			
 
				+const smg = new SourceMapGenerator({
			
 
				+  file: 'output.js',
			
 
				+  sourceRoot: 'https://example.com/',
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+#### SourceMapGenerator.prototype.addMapping(mapping)
			
 
				+
			
 
				+```typescript
			
 
				+const smg = new SourceMapGenerator();
			
 
				+smg.addMapping({
			
 
				+  generated: { line: 1, column: 0 },
			
 
				+  source: 'input.js',
			
 
				+  original: { line: 1, column: 0 },
			
 
				+  name: 'foo',
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+#### SourceMapGenerator.prototype.setSourceContent(sourceFile, sourceContent)
			
 
				+
			
 
				+```typescript
			
 
				+const smg = new SourceMapGenerator();
			
 
				+smg.setSourceContent('input.js', 'foobar');
			
 
				+```
			
 
				+
			
 
				+#### SourceMapGenerator.prototype.toJSON()
			
 
				+
			
 
				+```typescript
			
 
				+const smg = new SourceMapGenerator();
			
 
				+smg.toJSON(); // { version: 3, names: [], sources: [], mappings: '' }
			
 
				+```
			
 
				+
			
 
				+#### SourceMapGenerator.prototype.toDecodedMap()
			
 
				+
			
 
				+```typescript
			
 
				+const smg = new SourceMapGenerator();
			
 
				+smg.toDecodedMap(); // { version: 3, names: [], sources: [], mappings: [] }
			
 
				+```
			
 
				+
			
 
				+[trace-mapping]: https://github.com/jridgewell/trace-mapping/
			
 
				+[gen-mapping]: https://github.com/jridgewell/gen-mapping/
			
--- a/day37/node_modules/@jridgewell/source-map/dist/source-map.mjs
+++ b/day37/node_modules/@jridgewell/source-map/dist/source-map.mjs
@@ -0,0 +1,928 @@
 
				+const comma = ','.charCodeAt(0);
			
 
				+const semicolon = ';'.charCodeAt(0);
			
 
				+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
			
 
				+const intToChar = new Uint8Array(64); // 64 possible chars.
			
 
				+const charToInteger = new Uint8Array(128); // z is 122 in ASCII
			
 
				+for (let i = 0; i < chars.length; i++) {
			
 
				+    const c = chars.charCodeAt(i);
			
 
				+    charToInteger[c] = i;
			
 
				+    intToChar[i] = c;
			
 
				+}
			
 
				+// Provide a fallback for older environments.
			
 
				+const td = typeof TextDecoder !== 'undefined'
			
 
				+    ? new TextDecoder()
			
 
				+    : typeof Buffer !== 'undefined'
			
 
				+        ? {
			
 
				+            decode(buf) {
			
 
				+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
			
 
				+                return out.toString();
			
 
				+            },
			
 
				+        }
			
 
				+        : {
			
 
				+            decode(buf) {
			
 
				+                let out = '';
			
 
				+                for (let i = 0; i < buf.length; i++) {
			
 
				+                    out += String.fromCharCode(buf[i]);
			
 
				+                }
			
 
				+                return out;
			
 
				+            },
			
 
				+        };
			
 
				+function decode(mappings) {
			
 
				+    const state = new Int32Array(5);
			
 
				+    const decoded = [];
			
 
				+    let line = [];
			
 
				+    let sorted = true;
			
 
				+    let lastCol = 0;
			
 
				+    for (let i = 0; i < mappings.length;) {
			
 
				+        const c = mappings.charCodeAt(i);
			
 
				+        if (c === comma) {
			
 
				+            i++;
			
 
				+        }
			
 
				+        else if (c === semicolon) {
			
 
				+            state[0] = lastCol = 0;
			
 
				+            if (!sorted)
			
 
				+                sort(line);
			
 
				+            sorted = true;
			
 
				+            decoded.push(line);
			
 
				+            line = [];
			
 
				+            i++;
			
 
				+        }
			
 
				+        else {
			
 
				+            i = decodeInteger(mappings, i, state, 0); // generatedCodeColumn
			
 
				+            const col = state[0];
			
 
				+            if (col < lastCol)
			
 
				+                sorted = false;
			
 
				+            lastCol = col;
			
 
				+            if (!hasMoreSegments(mappings, i)) {
			
 
				+                line.push([col]);
			
 
				+                continue;
			
 
				+            }
			
 
				+            i = decodeInteger(mappings, i, state, 1); // sourceFileIndex
			
 
				+            i = decodeInteger(mappings, i, state, 2); // sourceCodeLine
			
 
				+            i = decodeInteger(mappings, i, state, 3); // sourceCodeColumn
			
 
				+            if (!hasMoreSegments(mappings, i)) {
			
 
				+                line.push([col, state[1], state[2], state[3]]);
			
 
				+                continue;
			
 
				+            }
			
 
				+            i = decodeInteger(mappings, i, state, 4); // nameIndex
			
 
				+            line.push([col, state[1], state[2], state[3], state[4]]);
			
 
				+        }
			
 
				+    }
			
 
				+    if (!sorted)
			
 
				+        sort(line);
			
 
				+    decoded.push(line);
			
 
				+    return decoded;
			
 
				+}
			
 
				+function decodeInteger(mappings, pos, state, j) {
			
 
				+    let value = 0;
			
 
				+    let shift = 0;
			
 
				+    let integer = 0;
			
 
				+    do {
			
 
				+        const c = mappings.charCodeAt(pos++);
			
 
				+        integer = charToInteger[c];
			
 
				+        value |= (integer & 31) << shift;
			
 
				+        shift += 5;
			
 
				+    } while (integer & 32);
			
 
				+    const shouldNegate = value & 1;
			
 
				+    value >>>= 1;
			
 
				+    if (shouldNegate) {
			
 
				+        value = -0x80000000 | -value;
			
 
				+    }
			
 
				+    state[j] += value;
			
 
				+    return pos;
			
 
				+}
			
 
				+function hasMoreSegments(mappings, i) {
			
 
				+    if (i >= mappings.length)
			
 
				+        return false;
			
 
				+    const c = mappings.charCodeAt(i);
			
 
				+    if (c === comma || c === semicolon)
			
 
				+        return false;
			
 
				+    return true;
			
 
				+}
			
 
				+function sort(line) {
			
 
				+    line.sort(sortComparator$1);
			
 
				+}
			
 
				+function sortComparator$1(a, b) {
			
 
				+    return a[0] - b[0];
			
 
				+}
			
 
				+function encode(decoded) {
			
 
				+    const state = new Int32Array(5);
			
 
				+    let buf = new Uint8Array(1024);
			
 
				+    let pos = 0;
			
 
				+    for (let i = 0; i < decoded.length; i++) {
			
 
				+        const line = decoded[i];
			
 
				+        if (i > 0) {
			
 
				+            buf = reserve(buf, pos, 1);
			
 
				+            buf[pos++] = semicolon;
			
 
				+        }
			
 
				+        if (line.length === 0)
			
 
				+            continue;
			
 
				+        state[0] = 0;
			
 
				+        for (let j = 0; j < line.length; j++) {
			
 
				+            const segment = line[j];
			
 
				+            // We can push up to 5 ints, each int can take at most 7 chars, and we
			
 
				+            // may push a comma.
			
 
				+            buf = reserve(buf, pos, 36);
			
 
				+            if (j > 0)
			
 
				+                buf[pos++] = comma;
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 0); // generatedCodeColumn
			
 
				+            if (segment.length === 1)
			
 
				+                continue;
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 1); // sourceFileIndex
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 2); // sourceCodeLine
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 3); // sourceCodeColumn
			
 
				+            if (segment.length === 4)
			
 
				+                continue;
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 4); // nameIndex
			
 
				+        }
			
 
				+    }
			
 
				+    return td.decode(buf.subarray(0, pos));
			
 
				+}
			
 
				+function reserve(buf, pos, count) {
			
 
				+    if (buf.length > pos + count)
			
 
				+        return buf;
			
 
				+    const swap = new Uint8Array(buf.length * 2);
			
 
				+    swap.set(buf);
			
 
				+    return swap;
			
 
				+}
			
 
				+function encodeInteger(buf, pos, state, segment, j) {
			
 
				+    const next = segment[j];
			
 
				+    let num = next - state[j];
			
 
				+    state[j] = next;
			
 
				+    num = num < 0 ? (-num << 1) | 1 : num << 1;
			
 
				+    do {
			
 
				+        let clamped = num & 0b011111;
			
 
				+        num >>>= 5;
			
 
				+        if (num > 0)
			
 
				+            clamped |= 0b100000;
			
 
				+        buf[pos++] = intToChar[clamped];
			
 
				+    } while (num > 0);
			
 
				+    return pos;
			
 
				+}
			
 
				+
			
 
				+// Matches the scheme of a URL, eg "http://"
			
 
				+const schemeRegex = /^[\w+.-]+:\/\//;
			
 
				+/**
			
 
				+ * Matches the parts of a URL:
			
 
				+ * 1. Scheme, including ":", guaranteed.
			
 
				+ * 2. User/password, including "@", optional.
			
 
				+ * 3. Host, guaranteed.
			
 
				+ * 4. Port, including ":", optional.
			
 
				+ * 5. Path, including "/", optional.
			
 
				+ */
			
 
				+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?/;
			
 
				+/**
			
 
				+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
			
 
				+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
			
 
				+ *
			
 
				+ * 1. Host, optional.
			
 
				+ * 2. Path, which may inclue "/", guaranteed.
			
 
				+ */
			
 
				+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/]*)?)?(\/?.*)/i;
			
 
				+function isAbsoluteUrl(input) {
			
 
				+    return schemeRegex.test(input);
			
 
				+}
			
 
				+function isSchemeRelativeUrl(input) {
			
 
				+    return input.startsWith('//');
			
 
				+}
			
 
				+function isAbsolutePath(input) {
			
 
				+    return input.startsWith('/');
			
 
				+}
			
 
				+function isFileUrl(input) {
			
 
				+    return input.startsWith('file:');
			
 
				+}
			
 
				+function parseAbsoluteUrl(input) {
			
 
				+    const match = urlRegex.exec(input);
			
 
				+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/');
			
 
				+}
			
 
				+function parseFileUrl(input) {
			
 
				+    const match = fileRegex.exec(input);
			
 
				+    const path = match[2];
			
 
				+    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path);
			
 
				+}
			
 
				+function makeUrl(scheme, user, host, port, path) {
			
 
				+    return {
			
 
				+        scheme,
			
 
				+        user,
			
 
				+        host,
			
 
				+        port,
			
 
				+        path,
			
 
				+        relativePath: false,
			
 
				+    };
			
 
				+}
			
 
				+function parseUrl(input) {
			
 
				+    if (isSchemeRelativeUrl(input)) {
			
 
				+        const url = parseAbsoluteUrl('http:' + input);
			
 
				+        url.scheme = '';
			
 
				+        return url;
			
 
				+    }
			
 
				+    if (isAbsolutePath(input)) {
			
 
				+        const url = parseAbsoluteUrl('http://foo.com' + input);
			
 
				+        url.scheme = '';
			
 
				+        url.host = '';
			
 
				+        return url;
			
 
				+    }
			
 
				+    if (isFileUrl(input))
			
 
				+        return parseFileUrl(input);
			
 
				+    if (isAbsoluteUrl(input))
			
 
				+        return parseAbsoluteUrl(input);
			
 
				+    const url = parseAbsoluteUrl('http://foo.com/' + input);
			
 
				+    url.scheme = '';
			
 
				+    url.host = '';
			
 
				+    url.relativePath = true;
			
 
				+    return url;
			
 
				+}
			
 
				+function stripPathFilename(path) {
			
 
				+    // If a path ends with a parent directory "..", then it's a relative path with excess parent
			
 
				+    // paths. It's not a file, so we can't strip it.
			
 
				+    if (path.endsWith('/..'))
			
 
				+        return path;
			
 
				+    const index = path.lastIndexOf('/');
			
 
				+    return path.slice(0, index + 1);
			
 
				+}
			
 
				+function mergePaths(url, base) {
			
 
				+    // If we're not a relative path, then we're an absolute path, and it doesn't matter what base is.
			
 
				+    if (!url.relativePath)
			
 
				+        return;
			
 
				+    normalizePath(base);
			
 
				+    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
			
 
				+    // path).
			
 
				+    if (url.path === '/') {
			
 
				+        url.path = base.path;
			
 
				+    }
			
 
				+    else {
			
 
				+        // Resolution happens relative to the base path's directory, not the file.
			
 
				+        url.path = stripPathFilename(base.path) + url.path;
			
 
				+    }
			
 
				+    // If the base path is absolute, then our path is now absolute too.
			
 
				+    url.relativePath = base.relativePath;
			
 
				+}
			
 
				+/**
			
 
				+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
			
 
				+ * "foo/.". We need to normalize to a standard representation.
			
 
				+ */
			
 
				+function normalizePath(url) {
			
 
				+    const { relativePath } = url;
			
 
				+    const pieces = url.path.split('/');
			
 
				+    // We need to preserve the first piece always, so that we output a leading slash. The item at
			
 
				+    // pieces[0] is an empty string.
			
 
				+    let pointer = 1;
			
 
				+    // Positive is the number of real directories we've output, used for popping a parent directory.
			
 
				+    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
			
 
				+    let positive = 0;
			
 
				+    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
			
 
				+    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
			
 
				+    // real directory, we won't need to append, unless the other conditions happen again.
			
 
				+    let addTrailingSlash = false;
			
 
				+    for (let i = 1; i < pieces.length; i++) {
			
 
				+        const piece = pieces[i];
			
 
				+        // An empty directory, could be a trailing slash, or just a double "//" in the path.
			
 
				+        if (!piece) {
			
 
				+            addTrailingSlash = true;
			
 
				+            continue;
			
 
				+        }
			
 
				+        // If we encounter a real directory, then we don't need to append anymore.
			
 
				+        addTrailingSlash = false;
			
 
				+        // A current directory, which we can always drop.
			
 
				+        if (piece === '.')
			
 
				+            continue;
			
 
				+        // A parent directory, we need to see if there are any real directories we can pop. Else, we
			
 
				+        // have an excess of parents, and we'll need to keep the "..".
			
 
				+        if (piece === '..') {
			
 
				+            if (positive) {
			
 
				+                addTrailingSlash = true;
			
 
				+                positive--;
			
 
				+                pointer--;
			
 
				+            }
			
 
				+            else if (relativePath) {
			
 
				+                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
			
 
				+                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
			
 
				+                pieces[pointer++] = piece;
			
 
				+            }
			
 
				+            continue;
			
 
				+        }
			
 
				+        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
			
 
				+        // any popped or dropped directories.
			
 
				+        pieces[pointer++] = piece;
			
 
				+        positive++;
			
 
				+    }
			
 
				+    let path = '';
			
 
				+    for (let i = 1; i < pointer; i++) {
			
 
				+        path += '/' + pieces[i];
			
 
				+    }
			
 
				+    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
			
 
				+        path += '/';
			
 
				+    }
			
 
				+    url.path = path;
			
 
				+}
			
 
				+/**
			
 
				+ * Attempts to resolve `input` URL/path relative to `base`.
			
 
				+ */
			
 
				+function resolve$1(input, base) {
			
 
				+    if (!input && !base)
			
 
				+        return '';
			
 
				+    const url = parseUrl(input);
			
 
				+    // If we have a base, and the input isn't already an absolute URL, then we need to merge.
			
 
				+    if (base && !url.scheme) {
			
 
				+        const baseUrl = parseUrl(base);
			
 
				+        url.scheme = baseUrl.scheme;
			
 
				+        // If there's no host, then we were just a path.
			
 
				+        if (!url.host) {
			
 
				+            // The host, user, and port are joined, you can't copy one without the others.
			
 
				+            url.user = baseUrl.user;
			
 
				+            url.host = baseUrl.host;
			
 
				+            url.port = baseUrl.port;
			
 
				+        }
			
 
				+        mergePaths(url, baseUrl);
			
 
				+    }
			
 
				+    normalizePath(url);
			
 
				+    // If the input (and base, if there was one) are both relative, then we need to output a relative.
			
 
				+    if (url.relativePath) {
			
 
				+        // The first char is always a "/".
			
 
				+        const path = url.path.slice(1);
			
 
				+        if (!path)
			
 
				+            return '.';
			
 
				+        // If base started with a leading ".", or there is no base and input started with a ".", then we
			
 
				+        // need to ensure that the relative path starts with a ".". We don't know if relative starts
			
 
				+        // with a "..", though, so check before prepending.
			
 
				+        const keepRelative = (base || input).startsWith('.');
			
 
				+        return !keepRelative || path.startsWith('.') ? path : './' + path;
			
 
				+    }
			
 
				+    // If there's no host (and no scheme/user/port), then we need to output an absolute path.
			
 
				+    if (!url.scheme && !url.host)
			
 
				+        return url.path;
			
 
				+    // We're outputting either an absolute URL, or a protocol relative one.
			
 
				+    return `${url.scheme}//${url.user}${url.host}${url.port}${url.path}`;
			
 
				+}
			
 
				+
			
 
				+function resolve(input, base) {
			
 
				+    // The base is always treated as a directory, if it's not empty.
			
 
				+    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
			
 
				+    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
			
 
				+    if (base && !base.endsWith('/'))
			
 
				+        base += '/';
			
 
				+    return resolve$1(input, base);
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Removes everything after the last "/", but leaves the slash.
			
 
				+ */
			
 
				+function stripFilename(path) {
			
 
				+    if (!path)
			
 
				+        return '';
			
 
				+    const index = path.lastIndexOf('/');
			
 
				+    return path.slice(0, index + 1);
			
 
				+}
			
 
				+
			
 
				+const COLUMN$1 = 0;
			
 
				+const SOURCES_INDEX$1 = 1;
			
 
				+const SOURCE_LINE$1 = 2;
			
 
				+const SOURCE_COLUMN$1 = 3;
			
 
				+const NAMES_INDEX$1 = 4;
			
 
				+
			
 
				+function maybeSort(mappings, owned) {
			
 
				+    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
			
 
				+    if (unsortedIndex === mappings.length)
			
 
				+        return mappings;
			
 
				+    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
			
 
				+    // not, we do not want to modify the consumer's input array.
			
 
				+    if (!owned)
			
 
				+        mappings = mappings.slice();
			
 
				+    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
			
 
				+        mappings[i] = sortSegments(mappings[i], owned);
			
 
				+    }
			
 
				+    return mappings;
			
 
				+}
			
 
				+function nextUnsortedSegmentLine(mappings, start) {
			
 
				+    for (let i = start; i < mappings.length; i++) {
			
 
				+        if (!isSorted(mappings[i]))
			
 
				+            return i;
			
 
				+    }
			
 
				+    return mappings.length;
			
 
				+}
			
 
				+function isSorted(line) {
			
 
				+    for (let j = 1; j < line.length; j++) {
			
 
				+        if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) {
			
 
				+            return false;
			
 
				+        }
			
 
				+    }
			
 
				+    return true;
			
 
				+}
			
 
				+function sortSegments(line, owned) {
			
 
				+    if (!owned)
			
 
				+        line = line.slice();
			
 
				+    return line.sort(sortComparator);
			
 
				+}
			
 
				+function sortComparator(a, b) {
			
 
				+    return a[COLUMN$1] - b[COLUMN$1];
			
 
				+}
			
 
				+
			
 
				+let found = false;
			
 
				+/**
			
 
				+ * A binary search implementation that returns the index if a match is found.
			
 
				+ * If no match is found, then the left-index (the index associated with the item that comes just
			
 
				+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
			
 
				+ * the next index:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const array = [1, 3];
			
 
				+ * const needle = 2;
			
 
				+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
			
 
				+ *
			
 
				+ * assert.equal(index, 0);
			
 
				+ * array.splice(index + 1, 0, needle);
			
 
				+ * assert.deepEqual(array, [1, 2, 3]);
			
 
				+ * ```
			
 
				+ */
			
 
				+function binarySearch(haystack, needle, low, high) {
			
 
				+    while (low <= high) {
			
 
				+        const mid = low + ((high - low) >> 1);
			
 
				+        const cmp = haystack[mid][COLUMN$1] - needle;
			
 
				+        if (cmp === 0) {
			
 
				+            found = true;
			
 
				+            return mid;
			
 
				+        }
			
 
				+        if (cmp < 0) {
			
 
				+            low = mid + 1;
			
 
				+        }
			
 
				+        else {
			
 
				+            high = mid - 1;
			
 
				+        }
			
 
				+    }
			
 
				+    found = false;
			
 
				+    return low - 1;
			
 
				+}
			
 
				+function upperBound(haystack, needle, index) {
			
 
				+    for (let i = index + 1; i < haystack.length; i++, index++) {
			
 
				+        if (haystack[i][COLUMN$1] !== needle)
			
 
				+            break;
			
 
				+    }
			
 
				+    return index;
			
 
				+}
			
 
				+function lowerBound(haystack, needle, index) {
			
 
				+    for (let i = index - 1; i >= 0; i--, index--) {
			
 
				+        if (haystack[i][COLUMN$1] !== needle)
			
 
				+            break;
			
 
				+    }
			
 
				+    return index;
			
 
				+}
			
 
				+function memoizedState() {
			
 
				+    return {
			
 
				+        lastKey: -1,
			
 
				+        lastNeedle: -1,
			
 
				+        lastIndex: -1,
			
 
				+    };
			
 
				+}
			
 
				+/**
			
 
				+ * This overly complicated beast is just to record the last tested line/column and the resulting
			
 
				+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
			
 
				+ */
			
 
				+function memoizedBinarySearch(haystack, needle, state, key) {
			
 
				+    const { lastKey, lastNeedle, lastIndex } = state;
			
 
				+    let low = 0;
			
 
				+    let high = haystack.length - 1;
			
 
				+    if (key === lastKey) {
			
 
				+        if (needle === lastNeedle) {
			
 
				+            found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
			
 
				+            return lastIndex;
			
 
				+        }
			
 
				+        if (needle >= lastNeedle) {
			
 
				+            // lastIndex may be -1 if the previous needle was not found.
			
 
				+            low = lastIndex === -1 ? 0 : lastIndex;
			
 
				+        }
			
 
				+        else {
			
 
				+            high = lastIndex;
			
 
				+        }
			
 
				+    }
			
 
				+    state.lastKey = key;
			
 
				+    state.lastNeedle = needle;
			
 
				+    return (state.lastIndex = binarySearch(haystack, needle, low, high));
			
 
				+}
			
 
				+
			
 
				+const AnyMap = function (map, mapUrl) {
			
 
				+    const parsed = typeof map === 'string' ? JSON.parse(map) : map;
			
 
				+    if (!('sections' in parsed))
			
 
				+        return new TraceMap(parsed, mapUrl);
			
 
				+    const mappings = [];
			
 
				+    const sources = [];
			
 
				+    const sourcesContent = [];
			
 
				+    const names = [];
			
 
				+    const { sections } = parsed;
			
 
				+    let i = 0;
			
 
				+    for (; i < sections.length - 1; i++) {
			
 
				+        const no = sections[i + 1].offset;
			
 
				+        addSection(sections[i], mapUrl, mappings, sources, sourcesContent, names, no.line, no.column);
			
 
				+    }
			
 
				+    if (sections.length > 0) {
			
 
				+        addSection(sections[i], mapUrl, mappings, sources, sourcesContent, names, Infinity, Infinity);
			
 
				+    }
			
 
				+    const joined = {
			
 
				+        version: 3,
			
 
				+        file: parsed.file,
			
 
				+        names,
			
 
				+        sources,
			
 
				+        sourcesContent,
			
 
				+        mappings,
			
 
				+    };
			
 
				+    return presortedDecodedMap(joined);
			
 
				+};
			
 
				+function addSection(section, mapUrl, mappings, sources, sourcesContent, names, stopLine, stopColumn) {
			
 
				+    const map = AnyMap(section.map, mapUrl);
			
 
				+    const { line: lineOffset, column: columnOffset } = section.offset;
			
 
				+    const sourcesOffset = sources.length;
			
 
				+    const namesOffset = names.length;
			
 
				+    const decoded = decodedMappings(map);
			
 
				+    const { resolvedSources } = map;
			
 
				+    append(sources, resolvedSources);
			
 
				+    append(sourcesContent, map.sourcesContent || fillSourcesContent(resolvedSources.length));
			
 
				+    append(names, map.names);
			
 
				+    // If this section jumps forwards several lines, we need to add lines to the output mappings catch up.
			
 
				+    for (let i = mappings.length; i <= lineOffset; i++)
			
 
				+        mappings.push([]);
			
 
				+    // We can only add so many lines before we step into the range that the next section's map
			
 
				+    // controls. When we get to the last line, then we'll start checking the segments to see if
			
 
				+    // they've crossed into the column range.
			
 
				+    const stopI = stopLine - lineOffset;
			
 
				+    const len = Math.min(decoded.length, stopI + 1);
			
 
				+    for (let i = 0; i < len; i++) {
			
 
				+        const line = decoded[i];
			
 
				+        // On the 0th loop, the line will already exist due to a previous section, or the line catch up
			
 
				+        // loop above.
			
 
				+        const out = i === 0 ? mappings[lineOffset] : (mappings[lineOffset + i] = []);
			
 
				+        // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
			
 
				+        // map can be multiple lines), it doesn't.
			
 
				+        const cOffset = i === 0 ? columnOffset : 0;
			
 
				+        for (let j = 0; j < line.length; j++) {
			
 
				+            const seg = line[j];
			
 
				+            const column = cOffset + seg[COLUMN$1];
			
 
				+            // If this segment steps into the column range that the next section's map controls, we need
			
 
				+            // to stop early.
			
 
				+            if (i === stopI && column >= stopColumn)
			
 
				+                break;
			
 
				+            if (seg.length === 1) {
			
 
				+                out.push([column]);
			
 
				+                continue;
			
 
				+            }
			
 
				+            const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX$1];
			
 
				+            const sourceLine = seg[SOURCE_LINE$1];
			
 
				+            const sourceColumn = seg[SOURCE_COLUMN$1];
			
 
				+            if (seg.length === 4) {
			
 
				+                out.push([column, sourcesIndex, sourceLine, sourceColumn]);
			
 
				+                continue;
			
 
				+            }
			
 
				+            out.push([column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX$1]]);
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+function append(arr, other) {
			
 
				+    for (let i = 0; i < other.length; i++)
			
 
				+        arr.push(other[i]);
			
 
				+}
			
 
				+// Sourcemaps don't need to have sourcesContent, and if they don't, we need to create an array of
			
 
				+// equal length to the sources. This is because the sources and sourcesContent are paired arrays,
			
 
				+// where `sourcesContent[i]` is the content of the `sources[i]` file. If we didn't, then joined
			
 
				+// sourcemap would desynchronize the sources/contents.
			
 
				+function fillSourcesContent(len) {
			
 
				+    const sourcesContent = [];
			
 
				+    for (let i = 0; i < len; i++)
			
 
				+        sourcesContent[i] = null;
			
 
				+    return sourcesContent;
			
 
				+}
			
 
				+
			
 
				+const INVALID_ORIGINAL_MAPPING = Object.freeze({
			
 
				+    source: null,
			
 
				+    line: null,
			
 
				+    column: null,
			
 
				+    name: null,
			
 
				+});
			
 
				+Object.freeze({
			
 
				+    line: null,
			
 
				+    column: null,
			
 
				+});
			
 
				+const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
			
 
				+const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
			
 
				+const LEAST_UPPER_BOUND = -1;
			
 
				+const GREATEST_LOWER_BOUND = 1;
			
 
				+/**
			
 
				+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
			
 
				+ */
			
 
				+let decodedMappings;
			
 
				+/**
			
 
				+ * A higher-level API to find the source/line/column associated with a generated line/column
			
 
				+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
			
 
				+ * `source-map` library.
			
 
				+ */
			
 
				+let originalPositionFor;
			
 
				+/**
			
 
				+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
			
 
				+ * maps.
			
 
				+ */
			
 
				+let presortedDecodedMap;
			
 
				+class TraceMap {
			
 
				+    constructor(map, mapUrl) {
			
 
				+        this._decodedMemo = memoizedState();
			
 
				+        this._bySources = undefined;
			
 
				+        this._bySourceMemos = undefined;
			
 
				+        const isString = typeof map === 'string';
			
 
				+        if (!isString && map.constructor === TraceMap)
			
 
				+            return map;
			
 
				+        const parsed = (isString ? JSON.parse(map) : map);
			
 
				+        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
			
 
				+        this.version = version;
			
 
				+        this.file = file;
			
 
				+        this.names = names;
			
 
				+        this.sourceRoot = sourceRoot;
			
 
				+        this.sources = sources;
			
 
				+        this.sourcesContent = sourcesContent;
			
 
				+        if (sourceRoot || mapUrl) {
			
 
				+            const from = resolve(sourceRoot || '', stripFilename(mapUrl));
			
 
				+            this.resolvedSources = sources.map((s) => resolve(s || '', from));
			
 
				+        }
			
 
				+        else {
			
 
				+            this.resolvedSources = sources.map((s) => s || '');
			
 
				+        }
			
 
				+        const { mappings } = parsed;
			
 
				+        if (typeof mappings === 'string') {
			
 
				+            this._encoded = mappings;
			
 
				+            this._decoded = undefined;
			
 
				+        }
			
 
				+        else {
			
 
				+            this._encoded = undefined;
			
 
				+            this._decoded = maybeSort(mappings, isString);
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+(() => {
			
 
				+    decodedMappings = (map) => {
			
 
				+        return (map._decoded || (map._decoded = decode(map._encoded)));
			
 
				+    };
			
 
				+    originalPositionFor = (map, { line, column, bias }) => {
			
 
				+        line--;
			
 
				+        if (line < 0)
			
 
				+            throw new Error(LINE_GTR_ZERO);
			
 
				+        if (column < 0)
			
 
				+            throw new Error(COL_GTR_EQ_ZERO);
			
 
				+        const decoded = decodedMappings(map);
			
 
				+        // It's common for parent source maps to have pointers to lines that have no
			
 
				+        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
			
 
				+        if (line >= decoded.length)
			
 
				+            return INVALID_ORIGINAL_MAPPING;
			
 
				+        const segment = traceSegmentInternal(decoded[line], map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
			
 
				+        if (segment == null)
			
 
				+            return INVALID_ORIGINAL_MAPPING;
			
 
				+        if (segment.length == 1)
			
 
				+            return INVALID_ORIGINAL_MAPPING;
			
 
				+        const { names, resolvedSources } = map;
			
 
				+        return {
			
 
				+            source: resolvedSources[segment[SOURCES_INDEX$1]],
			
 
				+            line: segment[SOURCE_LINE$1] + 1,
			
 
				+            column: segment[SOURCE_COLUMN$1],
			
 
				+            name: segment.length === 5 ? names[segment[NAMES_INDEX$1]] : null,
			
 
				+        };
			
 
				+    };
			
 
				+    presortedDecodedMap = (map, mapUrl) => {
			
 
				+        const clone = Object.assign({}, map);
			
 
				+        clone.mappings = [];
			
 
				+        const tracer = new TraceMap(clone, mapUrl);
			
 
				+        tracer._decoded = map.mappings;
			
 
				+        return tracer;
			
 
				+    };
			
 
				+})();
			
 
				+function traceSegmentInternal(segments, memo, line, column, bias) {
			
 
				+    let index = memoizedBinarySearch(segments, column, memo, line);
			
 
				+    if (found) {
			
 
				+        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
			
 
				+    }
			
 
				+    else if (bias === LEAST_UPPER_BOUND)
			
 
				+        index++;
			
 
				+    if (index === -1 || index === segments.length)
			
 
				+        return null;
			
 
				+    return segments[index];
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Gets the index associated with `key` in the backing array, if it is already present.
			
 
				+ */
			
 
				+let get;
			
 
				+/**
			
 
				+ * Puts `key` into the backing array, if it is not already present. Returns
			
 
				+ * the index of the `key` in the backing array.
			
 
				+ */
			
 
				+let put;
			
 
				+/**
			
 
				+ * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
			
 
				+ * index of the `key` in the backing array.
			
 
				+ *
			
 
				+ * This is designed to allow synchronizing a second array with the contents of the backing array,
			
 
				+ * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
			
 
				+ * and there are never duplicates.
			
 
				+ */
			
 
				+class SetArray {
			
 
				+    constructor() {
			
 
				+        this._indexes = { __proto__: null };
			
 
				+        this.array = [];
			
 
				+    }
			
 
				+}
			
 
				+(() => {
			
 
				+    get = (strarr, key) => strarr._indexes[key];
			
 
				+    put = (strarr, key) => {
			
 
				+        // The key may or may not be present. If it is present, it's a number.
			
 
				+        const index = get(strarr, key);
			
 
				+        if (index !== undefined)
			
 
				+            return index;
			
 
				+        const { array, _indexes: indexes } = strarr;
			
 
				+        return (indexes[key] = array.push(key) - 1);
			
 
				+    };
			
 
				+})();
			
 
				+
			
 
				+const COLUMN = 0;
			
 
				+const SOURCES_INDEX = 1;
			
 
				+const SOURCE_LINE = 2;
			
 
				+const SOURCE_COLUMN = 3;
			
 
				+const NAMES_INDEX = 4;
			
 
				+
			
 
				+const NO_NAME = -1;
			
 
				+/**
			
 
				+ * Same as `addMapping`, but will only add the mapping if it generates useful information in the
			
 
				+ * resulting map. This only works correctly if mappings are added **in order**, meaning you should
			
 
				+ * not add a mapping with a lower generated line/column than one that came before.
			
 
				+ */
			
 
				+let maybeAddMapping;
			
 
				+/**
			
 
				+ * Adds/removes the content of the source file to the source map.
			
 
				+ */
			
 
				+let setSourceContent;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+let toDecodedMap;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+let toEncodedMap;
			
 
				+// This split declaration is only so that terser can elminiate the static initialization block.
			
 
				+let addSegmentInternal;
			
 
				+/**
			
 
				+ * Provides the state to generate a sourcemap.
			
 
				+ */
			
 
				+class GenMapping {
			
 
				+    constructor({ file, sourceRoot } = {}) {
			
 
				+        this._names = new SetArray();
			
 
				+        this._sources = new SetArray();
			
 
				+        this._sourcesContent = [];
			
 
				+        this._mappings = [];
			
 
				+        this.file = file;
			
 
				+        this.sourceRoot = sourceRoot;
			
 
				+    }
			
 
				+}
			
 
				+(() => {
			
 
				+    maybeAddMapping = (map, mapping) => {
			
 
				+        return addMappingInternal(true, map, mapping);
			
 
				+    };
			
 
				+    setSourceContent = (map, source, content) => {
			
 
				+        const { _sources: sources, _sourcesContent: sourcesContent } = map;
			
 
				+        sourcesContent[put(sources, source)] = content;
			
 
				+    };
			
 
				+    toDecodedMap = (map) => {
			
 
				+        const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+        removeEmptyFinalLines(mappings);
			
 
				+        return {
			
 
				+            version: 3,
			
 
				+            file: file || undefined,
			
 
				+            names: names.array,
			
 
				+            sourceRoot: sourceRoot || undefined,
			
 
				+            sources: sources.array,
			
 
				+            sourcesContent,
			
 
				+            mappings,
			
 
				+        };
			
 
				+    };
			
 
				+    toEncodedMap = (map) => {
			
 
				+        const decoded = toDecodedMap(map);
			
 
				+        return Object.assign(Object.assign({}, decoded), { mappings: encode(decoded.mappings) });
			
 
				+    };
			
 
				+    // Internal helpers
			
 
				+    addSegmentInternal = (skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name) => {
			
 
				+        const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+        const line = getLine(mappings, genLine);
			
 
				+        const index = getColumnIndex(line, genColumn);
			
 
				+        if (!source) {
			
 
				+            if (skipable && skipSourceless(line, index))
			
 
				+                return;
			
 
				+            return insert(line, index, [genColumn]);
			
 
				+        }
			
 
				+        const sourcesIndex = put(sources, source);
			
 
				+        const namesIndex = name ? put(names, name) : NO_NAME;
			
 
				+        if (sourcesIndex === sourcesContent.length)
			
 
				+            sourcesContent[sourcesIndex] = null;
			
 
				+        if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
			
 
				+            return;
			
 
				+        }
			
 
				+        return insert(line, index, name
			
 
				+            ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
			
 
				+            : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
			
 
				+    };
			
 
				+})();
			
 
				+function getLine(mappings, index) {
			
 
				+    for (let i = mappings.length; i <= index; i++) {
			
 
				+        mappings[i] = [];
			
 
				+    }
			
 
				+    return mappings[index];
			
 
				+}
			
 
				+function getColumnIndex(line, genColumn) {
			
 
				+    let index = line.length;
			
 
				+    for (let i = index - 1; i >= 0; index = i--) {
			
 
				+        const current = line[i];
			
 
				+        if (genColumn >= current[COLUMN])
			
 
				+            break;
			
 
				+    }
			
 
				+    return index;
			
 
				+}
			
 
				+function insert(array, index, value) {
			
 
				+    for (let i = array.length; i > index; i--) {
			
 
				+        array[i] = array[i - 1];
			
 
				+    }
			
 
				+    array[index] = value;
			
 
				+}
			
 
				+function removeEmptyFinalLines(mappings) {
			
 
				+    const { length } = mappings;
			
 
				+    let len = length;
			
 
				+    for (let i = len - 1; i >= 0; len = i, i--) {
			
 
				+        if (mappings[i].length > 0)
			
 
				+            break;
			
 
				+    }
			
 
				+    if (len < length)
			
 
				+        mappings.length = len;
			
 
				+}
			
 
				+function skipSourceless(line, index) {
			
 
				+    // The start of a line is already sourceless, so adding a sourceless segment to the beginning
			
 
				+    // doesn't generate any useful information.
			
 
				+    if (index === 0)
			
 
				+        return true;
			
 
				+    const prev = line[index - 1];
			
 
				+    // If the previous segment is also sourceless, then adding another sourceless segment doesn't
			
 
				+    // genrate any new information. Else, this segment will end the source/named segment and point to
			
 
				+    // a sourceless position, which is useful.
			
 
				+    return prev.length === 1;
			
 
				+}
			
 
				+function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
			
 
				+    // A source/named segment at the start of a line gives position at that genColumn
			
 
				+    if (index === 0)
			
 
				+        return false;
			
 
				+    const prev = line[index - 1];
			
 
				+    // If the previous segment is sourceless, then we're transitioning to a source.
			
 
				+    if (prev.length === 1)
			
 
				+        return false;
			
 
				+    // If the previous segment maps to the exact same source position, then this segment doesn't
			
 
				+    // provide any new position information.
			
 
				+    return (sourcesIndex === prev[SOURCES_INDEX] &&
			
 
				+        sourceLine === prev[SOURCE_LINE] &&
			
 
				+        sourceColumn === prev[SOURCE_COLUMN] &&
			
 
				+        namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
			
 
				+}
			
 
				+function addMappingInternal(skipable, map, mapping) {
			
 
				+    const { generated, source, original, name } = mapping;
			
 
				+    if (!source) {
			
 
				+        return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null);
			
 
				+    }
			
 
				+    const s = source;
			
 
				+    return addSegmentInternal(skipable, map, generated.line - 1, generated.column, s, original.line - 1, original.column, name);
			
 
				+}
			
 
				+
			
 
				+class SourceMapConsumer {
			
 
				+    constructor(map, mapUrl) {
			
 
				+        const trace = (this._map = new AnyMap(map, mapUrl));
			
 
				+        this.file = trace.file;
			
 
				+        this.names = trace.names;
			
 
				+        this.sourceRoot = trace.sourceRoot;
			
 
				+        this.sources = trace.resolvedSources;
			
 
				+        this.sourcesContent = trace.sourcesContent;
			
 
				+    }
			
 
				+    originalPositionFor(needle) {
			
 
				+        return originalPositionFor(this._map, needle);
			
 
				+    }
			
 
				+    destroy() {
			
 
				+        // noop.
			
 
				+    }
			
 
				+}
			
 
				+class SourceMapGenerator {
			
 
				+    constructor(opts) {
			
 
				+        this._map = new GenMapping(opts);
			
 
				+    }
			
 
				+    addMapping(mapping) {
			
 
				+        maybeAddMapping(this._map, mapping);
			
 
				+    }
			
 
				+    setSourceContent(source, content) {
			
 
				+        setSourceContent(this._map, source, content);
			
 
				+    }
			
 
				+    toJSON() {
			
 
				+        return toEncodedMap(this._map);
			
 
				+    }
			
 
				+    toDecodedMap() {
			
 
				+        return toDecodedMap(this._map);
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+export { SourceMapConsumer, SourceMapGenerator };
			
 
				+//# sourceMappingURL=source-map.mjs.map
			
--- a/day37/node_modules/@jridgewell/source-map/dist/source-map.mjs.map
+++ b/day37/node_modules/@jridgewell/source-map/dist/source-map.mjs.map
--- a/day37/node_modules/@jridgewell/source-map/dist/source-map.umd.js
+++ b/day37/node_modules/@jridgewell/source-map/dist/source-map.umd.js
@@ -0,0 +1,939 @@
 
				+(function (global, factory) {
			
 
				+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
			
 
				+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
			
 
				+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sourceMap = {}));
			
 
				+})(this, (function (exports) { 'use strict';
			
 
				+
			
 
				+    const comma = ','.charCodeAt(0);
			
 
				+    const semicolon = ';'.charCodeAt(0);
			
 
				+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
			
 
				+    const intToChar = new Uint8Array(64); // 64 possible chars.
			
 
				+    const charToInteger = new Uint8Array(128); // z is 122 in ASCII
			
 
				+    for (let i = 0; i < chars.length; i++) {
			
 
				+        const c = chars.charCodeAt(i);
			
 
				+        charToInteger[c] = i;
			
 
				+        intToChar[i] = c;
			
 
				+    }
			
 
				+    // Provide a fallback for older environments.
			
 
				+    const td = typeof TextDecoder !== 'undefined'
			
 
				+        ? new TextDecoder()
			
 
				+        : typeof Buffer !== 'undefined'
			
 
				+            ? {
			
 
				+                decode(buf) {
			
 
				+                    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
			
 
				+                    return out.toString();
			
 
				+                },
			
 
				+            }
			
 
				+            : {
			
 
				+                decode(buf) {
			
 
				+                    let out = '';
			
 
				+                    for (let i = 0; i < buf.length; i++) {
			
 
				+                        out += String.fromCharCode(buf[i]);
			
 
				+                    }
			
 
				+                    return out;
			
 
				+                },
			
 
				+            };
			
 
				+    function decode(mappings) {
			
 
				+        const state = new Int32Array(5);
			
 
				+        const decoded = [];
			
 
				+        let line = [];
			
 
				+        let sorted = true;
			
 
				+        let lastCol = 0;
			
 
				+        for (let i = 0; i < mappings.length;) {
			
 
				+            const c = mappings.charCodeAt(i);
			
 
				+            if (c === comma) {
			
 
				+                i++;
			
 
				+            }
			
 
				+            else if (c === semicolon) {
			
 
				+                state[0] = lastCol = 0;
			
 
				+                if (!sorted)
			
 
				+                    sort(line);
			
 
				+                sorted = true;
			
 
				+                decoded.push(line);
			
 
				+                line = [];
			
 
				+                i++;
			
 
				+            }
			
 
				+            else {
			
 
				+                i = decodeInteger(mappings, i, state, 0); // generatedCodeColumn
			
 
				+                const col = state[0];
			
 
				+                if (col < lastCol)
			
 
				+                    sorted = false;
			
 
				+                lastCol = col;
			
 
				+                if (!hasMoreSegments(mappings, i)) {
			
 
				+                    line.push([col]);
			
 
				+                    continue;
			
 
				+                }
			
 
				+                i = decodeInteger(mappings, i, state, 1); // sourceFileIndex
			
 
				+                i = decodeInteger(mappings, i, state, 2); // sourceCodeLine
			
 
				+                i = decodeInteger(mappings, i, state, 3); // sourceCodeColumn
			
 
				+                if (!hasMoreSegments(mappings, i)) {
			
 
				+                    line.push([col, state[1], state[2], state[3]]);
			
 
				+                    continue;
			
 
				+                }
			
 
				+                i = decodeInteger(mappings, i, state, 4); // nameIndex
			
 
				+                line.push([col, state[1], state[2], state[3], state[4]]);
			
 
				+            }
			
 
				+        }
			
 
				+        if (!sorted)
			
 
				+            sort(line);
			
 
				+        decoded.push(line);
			
 
				+        return decoded;
			
 
				+    }
			
 
				+    function decodeInteger(mappings, pos, state, j) {
			
 
				+        let value = 0;
			
 
				+        let shift = 0;
			
 
				+        let integer = 0;
			
 
				+        do {
			
 
				+            const c = mappings.charCodeAt(pos++);
			
 
				+            integer = charToInteger[c];
			
 
				+            value |= (integer & 31) << shift;
			
 
				+            shift += 5;
			
 
				+        } while (integer & 32);
			
 
				+        const shouldNegate = value & 1;
			
 
				+        value >>>= 1;
			
 
				+        if (shouldNegate) {
			
 
				+            value = -0x80000000 | -value;
			
 
				+        }
			
 
				+        state[j] += value;
			
 
				+        return pos;
			
 
				+    }
			
 
				+    function hasMoreSegments(mappings, i) {
			
 
				+        if (i >= mappings.length)
			
 
				+            return false;
			
 
				+        const c = mappings.charCodeAt(i);
			
 
				+        if (c === comma || c === semicolon)
			
 
				+            return false;
			
 
				+        return true;
			
 
				+    }
			
 
				+    function sort(line) {
			
 
				+        line.sort(sortComparator$1);
			
 
				+    }
			
 
				+    function sortComparator$1(a, b) {
			
 
				+        return a[0] - b[0];
			
 
				+    }
			
 
				+    function encode(decoded) {
			
 
				+        const state = new Int32Array(5);
			
 
				+        let buf = new Uint8Array(1024);
			
 
				+        let pos = 0;
			
 
				+        for (let i = 0; i < decoded.length; i++) {
			
 
				+            const line = decoded[i];
			
 
				+            if (i > 0) {
			
 
				+                buf = reserve(buf, pos, 1);
			
 
				+                buf[pos++] = semicolon;
			
 
				+            }
			
 
				+            if (line.length === 0)
			
 
				+                continue;
			
 
				+            state[0] = 0;
			
 
				+            for (let j = 0; j < line.length; j++) {
			
 
				+                const segment = line[j];
			
 
				+                // We can push up to 5 ints, each int can take at most 7 chars, and we
			
 
				+                // may push a comma.
			
 
				+                buf = reserve(buf, pos, 36);
			
 
				+                if (j > 0)
			
 
				+                    buf[pos++] = comma;
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 0); // generatedCodeColumn
			
 
				+                if (segment.length === 1)
			
 
				+                    continue;
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 1); // sourceFileIndex
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 2); // sourceCodeLine
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 3); // sourceCodeColumn
			
 
				+                if (segment.length === 4)
			
 
				+                    continue;
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 4); // nameIndex
			
 
				+            }
			
 
				+        }
			
 
				+        return td.decode(buf.subarray(0, pos));
			
 
				+    }
			
 
				+    function reserve(buf, pos, count) {
			
 
				+        if (buf.length > pos + count)
			
 
				+            return buf;
			
 
				+        const swap = new Uint8Array(buf.length * 2);
			
 
				+        swap.set(buf);
			
 
				+        return swap;
			
 
				+    }
			
 
				+    function encodeInteger(buf, pos, state, segment, j) {
			
 
				+        const next = segment[j];
			
 
				+        let num = next - state[j];
			
 
				+        state[j] = next;
			
 
				+        num = num < 0 ? (-num << 1) | 1 : num << 1;
			
 
				+        do {
			
 
				+            let clamped = num & 0b011111;
			
 
				+            num >>>= 5;
			
 
				+            if (num > 0)
			
 
				+                clamped |= 0b100000;
			
 
				+            buf[pos++] = intToChar[clamped];
			
 
				+        } while (num > 0);
			
 
				+        return pos;
			
 
				+    }
			
 
				+
			
 
				+    // Matches the scheme of a URL, eg "http://"
			
 
				+    const schemeRegex = /^[\w+.-]+:\/\//;
			
 
				+    /**
			
 
				+     * Matches the parts of a URL:
			
 
				+     * 1. Scheme, including ":", guaranteed.
			
 
				+     * 2. User/password, including "@", optional.
			
 
				+     * 3. Host, guaranteed.
			
 
				+     * 4. Port, including ":", optional.
			
 
				+     * 5. Path, including "/", optional.
			
 
				+     */
			
 
				+    const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?/;
			
 
				+    /**
			
 
				+     * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
			
 
				+     * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
			
 
				+     *
			
 
				+     * 1. Host, optional.
			
 
				+     * 2. Path, which may inclue "/", guaranteed.
			
 
				+     */
			
 
				+    const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/]*)?)?(\/?.*)/i;
			
 
				+    function isAbsoluteUrl(input) {
			
 
				+        return schemeRegex.test(input);
			
 
				+    }
			
 
				+    function isSchemeRelativeUrl(input) {
			
 
				+        return input.startsWith('//');
			
 
				+    }
			
 
				+    function isAbsolutePath(input) {
			
 
				+        return input.startsWith('/');
			
 
				+    }
			
 
				+    function isFileUrl(input) {
			
 
				+        return input.startsWith('file:');
			
 
				+    }
			
 
				+    function parseAbsoluteUrl(input) {
			
 
				+        const match = urlRegex.exec(input);
			
 
				+        return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/');
			
 
				+    }
			
 
				+    function parseFileUrl(input) {
			
 
				+        const match = fileRegex.exec(input);
			
 
				+        const path = match[2];
			
 
				+        return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path);
			
 
				+    }
			
 
				+    function makeUrl(scheme, user, host, port, path) {
			
 
				+        return {
			
 
				+            scheme,
			
 
				+            user,
			
 
				+            host,
			
 
				+            port,
			
 
				+            path,
			
 
				+            relativePath: false,
			
 
				+        };
			
 
				+    }
			
 
				+    function parseUrl(input) {
			
 
				+        if (isSchemeRelativeUrl(input)) {
			
 
				+            const url = parseAbsoluteUrl('http:' + input);
			
 
				+            url.scheme = '';
			
 
				+            return url;
			
 
				+        }
			
 
				+        if (isAbsolutePath(input)) {
			
 
				+            const url = parseAbsoluteUrl('http://foo.com' + input);
			
 
				+            url.scheme = '';
			
 
				+            url.host = '';
			
 
				+            return url;
			
 
				+        }
			
 
				+        if (isFileUrl(input))
			
 
				+            return parseFileUrl(input);
			
 
				+        if (isAbsoluteUrl(input))
			
 
				+            return parseAbsoluteUrl(input);
			
 
				+        const url = parseAbsoluteUrl('http://foo.com/' + input);
			
 
				+        url.scheme = '';
			
 
				+        url.host = '';
			
 
				+        url.relativePath = true;
			
 
				+        return url;
			
 
				+    }
			
 
				+    function stripPathFilename(path) {
			
 
				+        // If a path ends with a parent directory "..", then it's a relative path with excess parent
			
 
				+        // paths. It's not a file, so we can't strip it.
			
 
				+        if (path.endsWith('/..'))
			
 
				+            return path;
			
 
				+        const index = path.lastIndexOf('/');
			
 
				+        return path.slice(0, index + 1);
			
 
				+    }
			
 
				+    function mergePaths(url, base) {
			
 
				+        // If we're not a relative path, then we're an absolute path, and it doesn't matter what base is.
			
 
				+        if (!url.relativePath)
			
 
				+            return;
			
 
				+        normalizePath(base);
			
 
				+        // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
			
 
				+        // path).
			
 
				+        if (url.path === '/') {
			
 
				+            url.path = base.path;
			
 
				+        }
			
 
				+        else {
			
 
				+            // Resolution happens relative to the base path's directory, not the file.
			
 
				+            url.path = stripPathFilename(base.path) + url.path;
			
 
				+        }
			
 
				+        // If the base path is absolute, then our path is now absolute too.
			
 
				+        url.relativePath = base.relativePath;
			
 
				+    }
			
 
				+    /**
			
 
				+     * The path can have empty directories "//", unneeded parents "foo/..", or current directory
			
 
				+     * "foo/.". We need to normalize to a standard representation.
			
 
				+     */
			
 
				+    function normalizePath(url) {
			
 
				+        const { relativePath } = url;
			
 
				+        const pieces = url.path.split('/');
			
 
				+        // We need to preserve the first piece always, so that we output a leading slash. The item at
			
 
				+        // pieces[0] is an empty string.
			
 
				+        let pointer = 1;
			
 
				+        // Positive is the number of real directories we've output, used for popping a parent directory.
			
 
				+        // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
			
 
				+        let positive = 0;
			
 
				+        // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
			
 
				+        // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
			
 
				+        // real directory, we won't need to append, unless the other conditions happen again.
			
 
				+        let addTrailingSlash = false;
			
 
				+        for (let i = 1; i < pieces.length; i++) {
			
 
				+            const piece = pieces[i];
			
 
				+            // An empty directory, could be a trailing slash, or just a double "//" in the path.
			
 
				+            if (!piece) {
			
 
				+                addTrailingSlash = true;
			
 
				+                continue;
			
 
				+            }
			
 
				+            // If we encounter a real directory, then we don't need to append anymore.
			
 
				+            addTrailingSlash = false;
			
 
				+            // A current directory, which we can always drop.
			
 
				+            if (piece === '.')
			
 
				+                continue;
			
 
				+            // A parent directory, we need to see if there are any real directories we can pop. Else, we
			
 
				+            // have an excess of parents, and we'll need to keep the "..".
			
 
				+            if (piece === '..') {
			
 
				+                if (positive) {
			
 
				+                    addTrailingSlash = true;
			
 
				+                    positive--;
			
 
				+                    pointer--;
			
 
				+                }
			
 
				+                else if (relativePath) {
			
 
				+                    // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
			
 
				+                    // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
			
 
				+                    pieces[pointer++] = piece;
			
 
				+                }
			
 
				+                continue;
			
 
				+            }
			
 
				+            // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
			
 
				+            // any popped or dropped directories.
			
 
				+            pieces[pointer++] = piece;
			
 
				+            positive++;
			
 
				+        }
			
 
				+        let path = '';
			
 
				+        for (let i = 1; i < pointer; i++) {
			
 
				+            path += '/' + pieces[i];
			
 
				+        }
			
 
				+        if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
			
 
				+            path += '/';
			
 
				+        }
			
 
				+        url.path = path;
			
 
				+    }
			
 
				+    /**
			
 
				+     * Attempts to resolve `input` URL/path relative to `base`.
			
 
				+     */
			
 
				+    function resolve$1(input, base) {
			
 
				+        if (!input && !base)
			
 
				+            return '';
			
 
				+        const url = parseUrl(input);
			
 
				+        // If we have a base, and the input isn't already an absolute URL, then we need to merge.
			
 
				+        if (base && !url.scheme) {
			
 
				+            const baseUrl = parseUrl(base);
			
 
				+            url.scheme = baseUrl.scheme;
			
 
				+            // If there's no host, then we were just a path.
			
 
				+            if (!url.host) {
			
 
				+                // The host, user, and port are joined, you can't copy one without the others.
			
 
				+                url.user = baseUrl.user;
			
 
				+                url.host = baseUrl.host;
			
 
				+                url.port = baseUrl.port;
			
 
				+            }
			
 
				+            mergePaths(url, baseUrl);
			
 
				+        }
			
 
				+        normalizePath(url);
			
 
				+        // If the input (and base, if there was one) are both relative, then we need to output a relative.
			
 
				+        if (url.relativePath) {
			
 
				+            // The first char is always a "/".
			
 
				+            const path = url.path.slice(1);
			
 
				+            if (!path)
			
 
				+                return '.';
			
 
				+            // If base started with a leading ".", or there is no base and input started with a ".", then we
			
 
				+            // need to ensure that the relative path starts with a ".". We don't know if relative starts
			
 
				+            // with a "..", though, so check before prepending.
			
 
				+            const keepRelative = (base || input).startsWith('.');
			
 
				+            return !keepRelative || path.startsWith('.') ? path : './' + path;
			
 
				+        }
			
 
				+        // If there's no host (and no scheme/user/port), then we need to output an absolute path.
			
 
				+        if (!url.scheme && !url.host)
			
 
				+            return url.path;
			
 
				+        // We're outputting either an absolute URL, or a protocol relative one.
			
 
				+        return `${url.scheme}//${url.user}${url.host}${url.port}${url.path}`;
			
 
				+    }
			
 
				+
			
 
				+    function resolve(input, base) {
			
 
				+        // The base is always treated as a directory, if it's not empty.
			
 
				+        // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
			
 
				+        // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
			
 
				+        if (base && !base.endsWith('/'))
			
 
				+            base += '/';
			
 
				+        return resolve$1(input, base);
			
 
				+    }
			
 
				+
			
 
				+    /**
			
 
				+     * Removes everything after the last "/", but leaves the slash.
			
 
				+     */
			
 
				+    function stripFilename(path) {
			
 
				+        if (!path)
			
 
				+            return '';
			
 
				+        const index = path.lastIndexOf('/');
			
 
				+        return path.slice(0, index + 1);
			
 
				+    }
			
 
				+
			
 
				+    const COLUMN$1 = 0;
			
 
				+    const SOURCES_INDEX$1 = 1;
			
 
				+    const SOURCE_LINE$1 = 2;
			
 
				+    const SOURCE_COLUMN$1 = 3;
			
 
				+    const NAMES_INDEX$1 = 4;
			
 
				+
			
 
				+    function maybeSort(mappings, owned) {
			
 
				+        const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
			
 
				+        if (unsortedIndex === mappings.length)
			
 
				+            return mappings;
			
 
				+        // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
			
 
				+        // not, we do not want to modify the consumer's input array.
			
 
				+        if (!owned)
			
 
				+            mappings = mappings.slice();
			
 
				+        for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
			
 
				+            mappings[i] = sortSegments(mappings[i], owned);
			
 
				+        }
			
 
				+        return mappings;
			
 
				+    }
			
 
				+    function nextUnsortedSegmentLine(mappings, start) {
			
 
				+        for (let i = start; i < mappings.length; i++) {
			
 
				+            if (!isSorted(mappings[i]))
			
 
				+                return i;
			
 
				+        }
			
 
				+        return mappings.length;
			
 
				+    }
			
 
				+    function isSorted(line) {
			
 
				+        for (let j = 1; j < line.length; j++) {
			
 
				+            if (line[j][COLUMN$1] < line[j - 1][COLUMN$1]) {
			
 
				+                return false;
			
 
				+            }
			
 
				+        }
			
 
				+        return true;
			
 
				+    }
			
 
				+    function sortSegments(line, owned) {
			
 
				+        if (!owned)
			
 
				+            line = line.slice();
			
 
				+        return line.sort(sortComparator);
			
 
				+    }
			
 
				+    function sortComparator(a, b) {
			
 
				+        return a[COLUMN$1] - b[COLUMN$1];
			
 
				+    }
			
 
				+
			
 
				+    let found = false;
			
 
				+    /**
			
 
				+     * A binary search implementation that returns the index if a match is found.
			
 
				+     * If no match is found, then the left-index (the index associated with the item that comes just
			
 
				+     * before the desired index) is returned. To maintain proper sort order, a splice would happen at
			
 
				+     * the next index:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const array = [1, 3];
			
 
				+     * const needle = 2;
			
 
				+     * const index = binarySearch(array, needle, (item, needle) => item - needle);
			
 
				+     *
			
 
				+     * assert.equal(index, 0);
			
 
				+     * array.splice(index + 1, 0, needle);
			
 
				+     * assert.deepEqual(array, [1, 2, 3]);
			
 
				+     * ```
			
 
				+     */
			
 
				+    function binarySearch(haystack, needle, low, high) {
			
 
				+        while (low <= high) {
			
 
				+            const mid = low + ((high - low) >> 1);
			
 
				+            const cmp = haystack[mid][COLUMN$1] - needle;
			
 
				+            if (cmp === 0) {
			
 
				+                found = true;
			
 
				+                return mid;
			
 
				+            }
			
 
				+            if (cmp < 0) {
			
 
				+                low = mid + 1;
			
 
				+            }
			
 
				+            else {
			
 
				+                high = mid - 1;
			
 
				+            }
			
 
				+        }
			
 
				+        found = false;
			
 
				+        return low - 1;
			
 
				+    }
			
 
				+    function upperBound(haystack, needle, index) {
			
 
				+        for (let i = index + 1; i < haystack.length; i++, index++) {
			
 
				+            if (haystack[i][COLUMN$1] !== needle)
			
 
				+                break;
			
 
				+        }
			
 
				+        return index;
			
 
				+    }
			
 
				+    function lowerBound(haystack, needle, index) {
			
 
				+        for (let i = index - 1; i >= 0; i--, index--) {
			
 
				+            if (haystack[i][COLUMN$1] !== needle)
			
 
				+                break;
			
 
				+        }
			
 
				+        return index;
			
 
				+    }
			
 
				+    function memoizedState() {
			
 
				+        return {
			
 
				+            lastKey: -1,
			
 
				+            lastNeedle: -1,
			
 
				+            lastIndex: -1,
			
 
				+        };
			
 
				+    }
			
 
				+    /**
			
 
				+     * This overly complicated beast is just to record the last tested line/column and the resulting
			
 
				+     * index, allowing us to skip a few tests if mappings are monotonically increasing.
			
 
				+     */
			
 
				+    function memoizedBinarySearch(haystack, needle, state, key) {
			
 
				+        const { lastKey, lastNeedle, lastIndex } = state;
			
 
				+        let low = 0;
			
 
				+        let high = haystack.length - 1;
			
 
				+        if (key === lastKey) {
			
 
				+            if (needle === lastNeedle) {
			
 
				+                found = lastIndex !== -1 && haystack[lastIndex][COLUMN$1] === needle;
			
 
				+                return lastIndex;
			
 
				+            }
			
 
				+            if (needle >= lastNeedle) {
			
 
				+                // lastIndex may be -1 if the previous needle was not found.
			
 
				+                low = lastIndex === -1 ? 0 : lastIndex;
			
 
				+            }
			
 
				+            else {
			
 
				+                high = lastIndex;
			
 
				+            }
			
 
				+        }
			
 
				+        state.lastKey = key;
			
 
				+        state.lastNeedle = needle;
			
 
				+        return (state.lastIndex = binarySearch(haystack, needle, low, high));
			
 
				+    }
			
 
				+
			
 
				+    const AnyMap = function (map, mapUrl) {
			
 
				+        const parsed = typeof map === 'string' ? JSON.parse(map) : map;
			
 
				+        if (!('sections' in parsed))
			
 
				+            return new TraceMap(parsed, mapUrl);
			
 
				+        const mappings = [];
			
 
				+        const sources = [];
			
 
				+        const sourcesContent = [];
			
 
				+        const names = [];
			
 
				+        const { sections } = parsed;
			
 
				+        let i = 0;
			
 
				+        for (; i < sections.length - 1; i++) {
			
 
				+            const no = sections[i + 1].offset;
			
 
				+            addSection(sections[i], mapUrl, mappings, sources, sourcesContent, names, no.line, no.column);
			
 
				+        }
			
 
				+        if (sections.length > 0) {
			
 
				+            addSection(sections[i], mapUrl, mappings, sources, sourcesContent, names, Infinity, Infinity);
			
 
				+        }
			
 
				+        const joined = {
			
 
				+            version: 3,
			
 
				+            file: parsed.file,
			
 
				+            names,
			
 
				+            sources,
			
 
				+            sourcesContent,
			
 
				+            mappings,
			
 
				+        };
			
 
				+        return presortedDecodedMap(joined);
			
 
				+    };
			
 
				+    function addSection(section, mapUrl, mappings, sources, sourcesContent, names, stopLine, stopColumn) {
			
 
				+        const map = AnyMap(section.map, mapUrl);
			
 
				+        const { line: lineOffset, column: columnOffset } = section.offset;
			
 
				+        const sourcesOffset = sources.length;
			
 
				+        const namesOffset = names.length;
			
 
				+        const decoded = decodedMappings(map);
			
 
				+        const { resolvedSources } = map;
			
 
				+        append(sources, resolvedSources);
			
 
				+        append(sourcesContent, map.sourcesContent || fillSourcesContent(resolvedSources.length));
			
 
				+        append(names, map.names);
			
 
				+        // If this section jumps forwards several lines, we need to add lines to the output mappings catch up.
			
 
				+        for (let i = mappings.length; i <= lineOffset; i++)
			
 
				+            mappings.push([]);
			
 
				+        // We can only add so many lines before we step into the range that the next section's map
			
 
				+        // controls. When we get to the last line, then we'll start checking the segments to see if
			
 
				+        // they've crossed into the column range.
			
 
				+        const stopI = stopLine - lineOffset;
			
 
				+        const len = Math.min(decoded.length, stopI + 1);
			
 
				+        for (let i = 0; i < len; i++) {
			
 
				+            const line = decoded[i];
			
 
				+            // On the 0th loop, the line will already exist due to a previous section, or the line catch up
			
 
				+            // loop above.
			
 
				+            const out = i === 0 ? mappings[lineOffset] : (mappings[lineOffset + i] = []);
			
 
				+            // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
			
 
				+            // map can be multiple lines), it doesn't.
			
 
				+            const cOffset = i === 0 ? columnOffset : 0;
			
 
				+            for (let j = 0; j < line.length; j++) {
			
 
				+                const seg = line[j];
			
 
				+                const column = cOffset + seg[COLUMN$1];
			
 
				+                // If this segment steps into the column range that the next section's map controls, we need
			
 
				+                // to stop early.
			
 
				+                if (i === stopI && column >= stopColumn)
			
 
				+                    break;
			
 
				+                if (seg.length === 1) {
			
 
				+                    out.push([column]);
			
 
				+                    continue;
			
 
				+                }
			
 
				+                const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX$1];
			
 
				+                const sourceLine = seg[SOURCE_LINE$1];
			
 
				+                const sourceColumn = seg[SOURCE_COLUMN$1];
			
 
				+                if (seg.length === 4) {
			
 
				+                    out.push([column, sourcesIndex, sourceLine, sourceColumn]);
			
 
				+                    continue;
			
 
				+                }
			
 
				+                out.push([column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX$1]]);
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    function append(arr, other) {
			
 
				+        for (let i = 0; i < other.length; i++)
			
 
				+            arr.push(other[i]);
			
 
				+    }
			
 
				+    // Sourcemaps don't need to have sourcesContent, and if they don't, we need to create an array of
			
 
				+    // equal length to the sources. This is because the sources and sourcesContent are paired arrays,
			
 
				+    // where `sourcesContent[i]` is the content of the `sources[i]` file. If we didn't, then joined
			
 
				+    // sourcemap would desynchronize the sources/contents.
			
 
				+    function fillSourcesContent(len) {
			
 
				+        const sourcesContent = [];
			
 
				+        for (let i = 0; i < len; i++)
			
 
				+            sourcesContent[i] = null;
			
 
				+        return sourcesContent;
			
 
				+    }
			
 
				+
			
 
				+    const INVALID_ORIGINAL_MAPPING = Object.freeze({
			
 
				+        source: null,
			
 
				+        line: null,
			
 
				+        column: null,
			
 
				+        name: null,
			
 
				+    });
			
 
				+    Object.freeze({
			
 
				+        line: null,
			
 
				+        column: null,
			
 
				+    });
			
 
				+    const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
			
 
				+    const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
			
 
				+    const LEAST_UPPER_BOUND = -1;
			
 
				+    const GREATEST_LOWER_BOUND = 1;
			
 
				+    /**
			
 
				+     * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
			
 
				+     */
			
 
				+    let decodedMappings;
			
 
				+    /**
			
 
				+     * A higher-level API to find the source/line/column associated with a generated line/column
			
 
				+     * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
			
 
				+     * `source-map` library.
			
 
				+     */
			
 
				+    let originalPositionFor;
			
 
				+    /**
			
 
				+     * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
			
 
				+     * maps.
			
 
				+     */
			
 
				+    let presortedDecodedMap;
			
 
				+    class TraceMap {
			
 
				+        constructor(map, mapUrl) {
			
 
				+            this._decodedMemo = memoizedState();
			
 
				+            this._bySources = undefined;
			
 
				+            this._bySourceMemos = undefined;
			
 
				+            const isString = typeof map === 'string';
			
 
				+            if (!isString && map.constructor === TraceMap)
			
 
				+                return map;
			
 
				+            const parsed = (isString ? JSON.parse(map) : map);
			
 
				+            const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
			
 
				+            this.version = version;
			
 
				+            this.file = file;
			
 
				+            this.names = names;
			
 
				+            this.sourceRoot = sourceRoot;
			
 
				+            this.sources = sources;
			
 
				+            this.sourcesContent = sourcesContent;
			
 
				+            if (sourceRoot || mapUrl) {
			
 
				+                const from = resolve(sourceRoot || '', stripFilename(mapUrl));
			
 
				+                this.resolvedSources = sources.map((s) => resolve(s || '', from));
			
 
				+            }
			
 
				+            else {
			
 
				+                this.resolvedSources = sources.map((s) => s || '');
			
 
				+            }
			
 
				+            const { mappings } = parsed;
			
 
				+            if (typeof mappings === 'string') {
			
 
				+                this._encoded = mappings;
			
 
				+                this._decoded = undefined;
			
 
				+            }
			
 
				+            else {
			
 
				+                this._encoded = undefined;
			
 
				+                this._decoded = maybeSort(mappings, isString);
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    (() => {
			
 
				+        decodedMappings = (map) => {
			
 
				+            return (map._decoded || (map._decoded = decode(map._encoded)));
			
 
				+        };
			
 
				+        originalPositionFor = (map, { line, column, bias }) => {
			
 
				+            line--;
			
 
				+            if (line < 0)
			
 
				+                throw new Error(LINE_GTR_ZERO);
			
 
				+            if (column < 0)
			
 
				+                throw new Error(COL_GTR_EQ_ZERO);
			
 
				+            const decoded = decodedMappings(map);
			
 
				+            // It's common for parent source maps to have pointers to lines that have no
			
 
				+            // mapping (like a "//# sourceMappingURL=") at the end of the child file.
			
 
				+            if (line >= decoded.length)
			
 
				+                return INVALID_ORIGINAL_MAPPING;
			
 
				+            const segment = traceSegmentInternal(decoded[line], map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
			
 
				+            if (segment == null)
			
 
				+                return INVALID_ORIGINAL_MAPPING;
			
 
				+            if (segment.length == 1)
			
 
				+                return INVALID_ORIGINAL_MAPPING;
			
 
				+            const { names, resolvedSources } = map;
			
 
				+            return {
			
 
				+                source: resolvedSources[segment[SOURCES_INDEX$1]],
			
 
				+                line: segment[SOURCE_LINE$1] + 1,
			
 
				+                column: segment[SOURCE_COLUMN$1],
			
 
				+                name: segment.length === 5 ? names[segment[NAMES_INDEX$1]] : null,
			
 
				+            };
			
 
				+        };
			
 
				+        presortedDecodedMap = (map, mapUrl) => {
			
 
				+            const clone = Object.assign({}, map);
			
 
				+            clone.mappings = [];
			
 
				+            const tracer = new TraceMap(clone, mapUrl);
			
 
				+            tracer._decoded = map.mappings;
			
 
				+            return tracer;
			
 
				+        };
			
 
				+    })();
			
 
				+    function traceSegmentInternal(segments, memo, line, column, bias) {
			
 
				+        let index = memoizedBinarySearch(segments, column, memo, line);
			
 
				+        if (found) {
			
 
				+            index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
			
 
				+        }
			
 
				+        else if (bias === LEAST_UPPER_BOUND)
			
 
				+            index++;
			
 
				+        if (index === -1 || index === segments.length)
			
 
				+            return null;
			
 
				+        return segments[index];
			
 
				+    }
			
 
				+
			
 
				+    /**
			
 
				+     * Gets the index associated with `key` in the backing array, if it is already present.
			
 
				+     */
			
 
				+    let get;
			
 
				+    /**
			
 
				+     * Puts `key` into the backing array, if it is not already present. Returns
			
 
				+     * the index of the `key` in the backing array.
			
 
				+     */
			
 
				+    let put;
			
 
				+    /**
			
 
				+     * SetArray acts like a `Set` (allowing only one occurrence of a string `key`), but provides the
			
 
				+     * index of the `key` in the backing array.
			
 
				+     *
			
 
				+     * This is designed to allow synchronizing a second array with the contents of the backing array,
			
 
				+     * like how in a sourcemap `sourcesContent[i]` is the source content associated with `source[i]`,
			
 
				+     * and there are never duplicates.
			
 
				+     */
			
 
				+    class SetArray {
			
 
				+        constructor() {
			
 
				+            this._indexes = { __proto__: null };
			
 
				+            this.array = [];
			
 
				+        }
			
 
				+    }
			
 
				+    (() => {
			
 
				+        get = (strarr, key) => strarr._indexes[key];
			
 
				+        put = (strarr, key) => {
			
 
				+            // The key may or may not be present. If it is present, it's a number.
			
 
				+            const index = get(strarr, key);
			
 
				+            if (index !== undefined)
			
 
				+                return index;
			
 
				+            const { array, _indexes: indexes } = strarr;
			
 
				+            return (indexes[key] = array.push(key) - 1);
			
 
				+        };
			
 
				+    })();
			
 
				+
			
 
				+    const COLUMN = 0;
			
 
				+    const SOURCES_INDEX = 1;
			
 
				+    const SOURCE_LINE = 2;
			
 
				+    const SOURCE_COLUMN = 3;
			
 
				+    const NAMES_INDEX = 4;
			
 
				+
			
 
				+    const NO_NAME = -1;
			
 
				+    /**
			
 
				+     * Same as `addMapping`, but will only add the mapping if it generates useful information in the
			
 
				+     * resulting map. This only works correctly if mappings are added **in order**, meaning you should
			
 
				+     * not add a mapping with a lower generated line/column than one that came before.
			
 
				+     */
			
 
				+    let maybeAddMapping;
			
 
				+    /**
			
 
				+     * Adds/removes the content of the source file to the source map.
			
 
				+     */
			
 
				+    let setSourceContent;
			
 
				+    /**
			
 
				+     * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
			
 
				+     * a sourcemap, or to JSON.stringify.
			
 
				+     */
			
 
				+    let toDecodedMap;
			
 
				+    /**
			
 
				+     * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
			
 
				+     * a sourcemap, or to JSON.stringify.
			
 
				+     */
			
 
				+    let toEncodedMap;
			
 
				+    // This split declaration is only so that terser can elminiate the static initialization block.
			
 
				+    let addSegmentInternal;
			
 
				+    /**
			
 
				+     * Provides the state to generate a sourcemap.
			
 
				+     */
			
 
				+    class GenMapping {
			
 
				+        constructor({ file, sourceRoot } = {}) {
			
 
				+            this._names = new SetArray();
			
 
				+            this._sources = new SetArray();
			
 
				+            this._sourcesContent = [];
			
 
				+            this._mappings = [];
			
 
				+            this.file = file;
			
 
				+            this.sourceRoot = sourceRoot;
			
 
				+        }
			
 
				+    }
			
 
				+    (() => {
			
 
				+        maybeAddMapping = (map, mapping) => {
			
 
				+            return addMappingInternal(true, map, mapping);
			
 
				+        };
			
 
				+        setSourceContent = (map, source, content) => {
			
 
				+            const { _sources: sources, _sourcesContent: sourcesContent } = map;
			
 
				+            sourcesContent[put(sources, source)] = content;
			
 
				+        };
			
 
				+        toDecodedMap = (map) => {
			
 
				+            const { file, sourceRoot, _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+            removeEmptyFinalLines(mappings);
			
 
				+            return {
			
 
				+                version: 3,
			
 
				+                file: file || undefined,
			
 
				+                names: names.array,
			
 
				+                sourceRoot: sourceRoot || undefined,
			
 
				+                sources: sources.array,
			
 
				+                sourcesContent,
			
 
				+                mappings,
			
 
				+            };
			
 
				+        };
			
 
				+        toEncodedMap = (map) => {
			
 
				+            const decoded = toDecodedMap(map);
			
 
				+            return Object.assign(Object.assign({}, decoded), { mappings: encode(decoded.mappings) });
			
 
				+        };
			
 
				+        // Internal helpers
			
 
				+        addSegmentInternal = (skipable, map, genLine, genColumn, source, sourceLine, sourceColumn, name) => {
			
 
				+            const { _mappings: mappings, _sources: sources, _sourcesContent: sourcesContent, _names: names, } = map;
			
 
				+            const line = getLine(mappings, genLine);
			
 
				+            const index = getColumnIndex(line, genColumn);
			
 
				+            if (!source) {
			
 
				+                if (skipable && skipSourceless(line, index))
			
 
				+                    return;
			
 
				+                return insert(line, index, [genColumn]);
			
 
				+            }
			
 
				+            const sourcesIndex = put(sources, source);
			
 
				+            const namesIndex = name ? put(names, name) : NO_NAME;
			
 
				+            if (sourcesIndex === sourcesContent.length)
			
 
				+                sourcesContent[sourcesIndex] = null;
			
 
				+            if (skipable && skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex)) {
			
 
				+                return;
			
 
				+            }
			
 
				+            return insert(line, index, name
			
 
				+                ? [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
			
 
				+                : [genColumn, sourcesIndex, sourceLine, sourceColumn]);
			
 
				+        };
			
 
				+    })();
			
 
				+    function getLine(mappings, index) {
			
 
				+        for (let i = mappings.length; i <= index; i++) {
			
 
				+            mappings[i] = [];
			
 
				+        }
			
 
				+        return mappings[index];
			
 
				+    }
			
 
				+    function getColumnIndex(line, genColumn) {
			
 
				+        let index = line.length;
			
 
				+        for (let i = index - 1; i >= 0; index = i--) {
			
 
				+            const current = line[i];
			
 
				+            if (genColumn >= current[COLUMN])
			
 
				+                break;
			
 
				+        }
			
 
				+        return index;
			
 
				+    }
			
 
				+    function insert(array, index, value) {
			
 
				+        for (let i = array.length; i > index; i--) {
			
 
				+            array[i] = array[i - 1];
			
 
				+        }
			
 
				+        array[index] = value;
			
 
				+    }
			
 
				+    function removeEmptyFinalLines(mappings) {
			
 
				+        const { length } = mappings;
			
 
				+        let len = length;
			
 
				+        for (let i = len - 1; i >= 0; len = i, i--) {
			
 
				+            if (mappings[i].length > 0)
			
 
				+                break;
			
 
				+        }
			
 
				+        if (len < length)
			
 
				+            mappings.length = len;
			
 
				+    }
			
 
				+    function skipSourceless(line, index) {
			
 
				+        // The start of a line is already sourceless, so adding a sourceless segment to the beginning
			
 
				+        // doesn't generate any useful information.
			
 
				+        if (index === 0)
			
 
				+            return true;
			
 
				+        const prev = line[index - 1];
			
 
				+        // If the previous segment is also sourceless, then adding another sourceless segment doesn't
			
 
				+        // genrate any new information. Else, this segment will end the source/named segment and point to
			
 
				+        // a sourceless position, which is useful.
			
 
				+        return prev.length === 1;
			
 
				+    }
			
 
				+    function skipSource(line, index, sourcesIndex, sourceLine, sourceColumn, namesIndex) {
			
 
				+        // A source/named segment at the start of a line gives position at that genColumn
			
 
				+        if (index === 0)
			
 
				+            return false;
			
 
				+        const prev = line[index - 1];
			
 
				+        // If the previous segment is sourceless, then we're transitioning to a source.
			
 
				+        if (prev.length === 1)
			
 
				+            return false;
			
 
				+        // If the previous segment maps to the exact same source position, then this segment doesn't
			
 
				+        // provide any new position information.
			
 
				+        return (sourcesIndex === prev[SOURCES_INDEX] &&
			
 
				+            sourceLine === prev[SOURCE_LINE] &&
			
 
				+            sourceColumn === prev[SOURCE_COLUMN] &&
			
 
				+            namesIndex === (prev.length === 5 ? prev[NAMES_INDEX] : NO_NAME));
			
 
				+    }
			
 
				+    function addMappingInternal(skipable, map, mapping) {
			
 
				+        const { generated, source, original, name } = mapping;
			
 
				+        if (!source) {
			
 
				+            return addSegmentInternal(skipable, map, generated.line - 1, generated.column, null, null, null, null);
			
 
				+        }
			
 
				+        const s = source;
			
 
				+        return addSegmentInternal(skipable, map, generated.line - 1, generated.column, s, original.line - 1, original.column, name);
			
 
				+    }
			
 
				+
			
 
				+    class SourceMapConsumer {
			
 
				+        constructor(map, mapUrl) {
			
 
				+            const trace = (this._map = new AnyMap(map, mapUrl));
			
 
				+            this.file = trace.file;
			
 
				+            this.names = trace.names;
			
 
				+            this.sourceRoot = trace.sourceRoot;
			
 
				+            this.sources = trace.resolvedSources;
			
 
				+            this.sourcesContent = trace.sourcesContent;
			
 
				+        }
			
 
				+        originalPositionFor(needle) {
			
 
				+            return originalPositionFor(this._map, needle);
			
 
				+        }
			
 
				+        destroy() {
			
 
				+            // noop.
			
 
				+        }
			
 
				+    }
			
 
				+    class SourceMapGenerator {
			
 
				+        constructor(opts) {
			
 
				+            this._map = new GenMapping(opts);
			
 
				+        }
			
 
				+        addMapping(mapping) {
			
 
				+            maybeAddMapping(this._map, mapping);
			
 
				+        }
			
 
				+        setSourceContent(source, content) {
			
 
				+            setSourceContent(this._map, source, content);
			
 
				+        }
			
 
				+        toJSON() {
			
 
				+            return toEncodedMap(this._map);
			
 
				+        }
			
 
				+        toDecodedMap() {
			
 
				+            return toDecodedMap(this._map);
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    exports.SourceMapConsumer = SourceMapConsumer;
			
 
				+    exports.SourceMapGenerator = SourceMapGenerator;
			
 
				+
			
 
				+    Object.defineProperty(exports, '__esModule', { value: true });
			
 
				+
			
 
				+}));
			
 
				+//# sourceMappingURL=source-map.umd.js.map
			
--- a/day37/node_modules/@jridgewell/source-map/dist/source-map.umd.js.map
+++ b/day37/node_modules/@jridgewell/source-map/dist/source-map.umd.js.map
--- a/day37/node_modules/@jridgewell/source-map/dist/types/source-map.d.ts
+++ b/day37/node_modules/@jridgewell/source-map/dist/types/source-map.d.ts
@@ -0,0 +1,25 @@
 
				+import { AnyMap, originalPositionFor } from '@jridgewell/trace-mapping';
			
 
				+import { GenMapping, maybeAddMapping, toDecodedMap, toEncodedMap, setSourceContent } from '@jridgewell/gen-mapping';
			
 
				+import type { TraceMap, SectionedSourceMapInput } from '@jridgewell/trace-mapping';
			
 
				+export type { TraceMap, SectionedSourceMapInput };
			
 
				+import type { Mapping, EncodedSourceMap, DecodedSourceMap } from '@jridgewell/gen-mapping';
			
 
				+export type { Mapping, EncodedSourceMap, DecodedSourceMap };
			
 
				+export declare class SourceMapConsumer {
			
 
				+    private _map;
			
 
				+    file: TraceMap['file'];
			
 
				+    names: TraceMap['names'];
			
 
				+    sourceRoot: TraceMap['sourceRoot'];
			
 
				+    sources: TraceMap['sources'];
			
 
				+    sourcesContent: TraceMap['sourcesContent'];
			
 
				+    constructor(map: ConstructorParameters<typeof AnyMap>[0], mapUrl: Parameters<typeof AnyMap>[1]);
			
 
				+    originalPositionFor(needle: Parameters<typeof originalPositionFor>[1]): ReturnType<typeof originalPositionFor>;
			
 
				+    destroy(): void;
			
 
				+}
			
 
				+export declare class SourceMapGenerator {
			
 
				+    private _map;
			
 
				+    constructor(opts: ConstructorParameters<typeof GenMapping>[0]);
			
 
				+    addMapping(mapping: Parameters<typeof maybeAddMapping>[1]): ReturnType<typeof maybeAddMapping>;
			
 
				+    setSourceContent(source: Parameters<typeof setSourceContent>[1], content: Parameters<typeof setSourceContent>[2]): ReturnType<typeof setSourceContent>;
			
 
				+    toJSON(): ReturnType<typeof toEncodedMap>;
			
 
				+    toDecodedMap(): ReturnType<typeof toDecodedMap>;
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/source-map/package.json
+++ b/day37/node_modules/@jridgewell/source-map/package.json
@@ -0,0 +1,71 @@
 
				+{
			
 
				+  "name": "@jridgewell/source-map",
			
 
				+  "version": "0.3.5",
			
 
				+  "description": "Packages @jridgewell/trace-mapping and @jridgewell/gen-mapping into the familiar source-map API",
			
 
				+  "keywords": [
			
 
				+    "sourcemap",
			
 
				+    "source",
			
 
				+    "map"
			
 
				+  ],
			
 
				+  "author": "Justin Ridgewell <justin@ridgewell.name>",
			
 
				+  "license": "MIT",
			
 
				+  "repository": "https://github.com/jridgewell/source-map",
			
 
				+  "main": "dist/source-map.umd.js",
			
 
				+  "module": "dist/source-map.mjs",
			
 
				+  "types": "dist/types/source-map.d.ts",
			
 
				+  "exports": {
			
 
				+    ".": [
			
 
				+      {
			
 
				+        "types": "./dist/types/source-map.d.ts",
			
 
				+        "browser": "./dist/source-map.umd.js",
			
 
				+        "require": "./dist/source-map.umd.js",
			
 
				+        "import": "./dist/source-map.mjs"
			
 
				+      },
			
 
				+      "./dist/source-map.umd.js"
			
 
				+    ],
			
 
				+    "./package.json": "./package.json"
			
 
				+  },
			
 
				+  "files": [
			
 
				+    "dist"
			
 
				+  ],
			
 
				+  "scripts": {
			
 
				+    "prebuild": "rm -rf dist",
			
 
				+    "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",
			
 
				+    "pretest": "run-s build:rollup",
			
 
				+    "test": "run-s -n test:lint test:only",
			
 
				+    "test:debug": "mocha --inspect-brk",
			
 
				+    "test:lint": "run-s -n test:lint:*",
			
 
				+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
			
 
				+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
			
 
				+    "test:only": "mocha",
			
 
				+    "test:coverage": "c8 mocha",
			
 
				+    "test:watch": "mocha --watch",
			
 
				+    "prepublishOnly": "npm run preversion",
			
 
				+    "preversion": "run-s test build"
			
 
				+  },
			
 
				+  "devDependencies": {
			
 
				+    "@rollup/plugin-node-resolve": "13.2.1",
			
 
				+    "@rollup/plugin-typescript": "8.3.0",
			
 
				+    "@types/mocha": "9.1.1",
			
 
				+    "@types/node": "17.0.30",
			
 
				+    "@typescript-eslint/eslint-plugin": "5.10.0",
			
 
				+    "@typescript-eslint/parser": "5.10.0",
			
 
				+    "c8": "7.11.0",
			
 
				+    "eslint": "8.7.0",
			
 
				+    "eslint-config-prettier": "8.3.0",
			
 
				+    "mocha": "9.2.0",
			
 
				+    "npm-run-all": "4.1.5",
			
 
				+    "prettier": "2.5.1",
			
 
				+    "rollup": "2.66.0",
			
 
				+    "typescript": "4.5.5"
			
 
				+  },
			
 
				+  "dependencies": {
			
 
				+    "@jridgewell/gen-mapping": "^0.3.0",
			
 
				+    "@jridgewell/trace-mapping": "^0.3.9"
			
 
				+  }
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/sourcemap-codec/LICENSE
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/LICENSE
@@ -0,0 +1,21 @@
 
				+The MIT License
			
 
				+
			
 
				+Copyright (c) 2015 Rich Harris
			
 
				+
			
 
				+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/day37/node_modules/@jridgewell/sourcemap-codec/README.md
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/README.md
@@ -0,0 +1,200 @@
 
				+# @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode/decode the `mappings` property of a [sourcemap](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit).
			
 
				+
			
 
				+
			
 
				+## Why?
			
 
				+
			
 
				+Sourcemaps are difficult to generate and manipulate, because the `mappings` property – the part that actually links the generated code back to the original source – is encoded using an obscure method called [Variable-length quantity](https://en.wikipedia.org/wiki/Variable-length_quantity). On top of that, each segment in the mapping contains offsets rather than absolute indices, which means that you can't look at a segment in isolation – you have to understand the whole sourcemap.
			
 
				+
			
 
				+This package makes the process slightly easier.
			
 
				+
			
 
				+
			
 
				+## Installation
			
 
				+
			
 
				+```bash
			
 
				+npm install @jridgewell/sourcemap-codec
			
 
				+```
			
 
				+
			
 
				+
			
 
				+## Usage
			
 
				+
			
 
				+```js
			
 
				+import { encode, decode } from '@jridgewell/sourcemap-codec';
			
 
				+
			
 
				+var decoded = decode( ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
			
 
				+
			
 
				+assert.deepEqual( decoded, [
			
 
				+	// the first line (of the generated code) has no mappings,
			
 
				+	// as shown by the starting semi-colon (which separates lines)
			
 
				+	[],
			
 
				+
			
 
				+	// the second line contains four (comma-separated) segments
			
 
				+	[
			
 
				+		// segments are encoded as you'd expect:
			
 
				+		// [ generatedCodeColumn, sourceIndex, sourceCodeLine, sourceCodeColumn, nameIndex ]
			
 
				+
			
 
				+		// i.e. the first segment begins at column 2, and maps back to the second column
			
 
				+		// of the second line (both zero-based) of the 0th source, and uses the 0th
			
 
				+		// name in the `map.names` array
			
 
				+		[ 2, 0, 2, 2, 0 ],
			
 
				+
			
 
				+		// the remaining segments are 4-length rather than 5-length,
			
 
				+		// because they don't map a name
			
 
				+		[ 4, 0, 2, 4 ],
			
 
				+		[ 6, 0, 2, 5 ],
			
 
				+		[ 7, 0, 2, 7 ]
			
 
				+	],
			
 
				+
			
 
				+	// the final line contains two segments
			
 
				+	[
			
 
				+		[ 2, 1, 10, 19 ],
			
 
				+		[ 12, 1, 11, 20 ]
			
 
				+	]
			
 
				+]);
			
 
				+
			
 
				+var encoded = encode( decoded );
			
 
				+assert.equal( encoded, ';EAEEA,EAAE,EAAC,CAAE;ECQY,UACC' );
			
 
				+```
			
 
				+
			
 
				+## Benchmarks
			
 
				+
			
 
				+```
			
 
				+node v18.0.0
			
 
				+
			
 
				+amp.js.map - 45120 segments
			
 
				+
			
 
				+Decode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec       5479160 bytes
			
 
				+sourcemap-codec                   5659336 bytes
			
 
				+source-map-0.6.1                 17144440 bytes
			
 
				+source-map-0.8.0                  6867424 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Decode speed:
			
 
				+decode: @jridgewell/sourcemap-codec x 502 ops/sec ±1.03% (90 runs sampled)
			
 
				+decode: sourcemap-codec x 445 ops/sec ±0.97% (92 runs sampled)
			
 
				+decode: source-map-0.6.1 x 36.01 ops/sec ±1.64% (49 runs sampled)
			
 
				+decode: source-map-0.8.0 x 367 ops/sec ±0.04% (95 runs sampled)
			
 
				+Fastest is decode: @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec       1261620 bytes
			
 
				+sourcemap-codec                   9119248 bytes
			
 
				+source-map-0.6.1                  8968560 bytes
			
 
				+source-map-0.8.0                  8952952 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode speed:
			
 
				+encode: @jridgewell/sourcemap-codec x 738 ops/sec ±0.42% (98 runs sampled)
			
 
				+encode: sourcemap-codec x 238 ops/sec ±0.73% (88 runs sampled)
			
 
				+encode: source-map-0.6.1 x 162 ops/sec ±0.43% (84 runs sampled)
			
 
				+encode: source-map-0.8.0 x 191 ops/sec ±0.34% (90 runs sampled)
			
 
				+Fastest is encode: @jridgewell/sourcemap-codec
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+babel.min.js.map - 347793 segments
			
 
				+
			
 
				+Decode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec      35338184 bytes
			
 
				+sourcemap-codec                  35922736 bytes
			
 
				+source-map-0.6.1                 62366360 bytes
			
 
				+source-map-0.8.0                 44337416 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Decode speed:
			
 
				+decode: @jridgewell/sourcemap-codec x 40.35 ops/sec ±4.47% (54 runs sampled)
			
 
				+decode: sourcemap-codec x 36.76 ops/sec ±3.67% (51 runs sampled)
			
 
				+decode: source-map-0.6.1 x 4.44 ops/sec ±2.15% (16 runs sampled)
			
 
				+decode: source-map-0.8.0 x 59.35 ops/sec ±0.05% (78 runs sampled)
			
 
				+Fastest is decode: source-map-0.8.0
			
 
				+
			
 
				+Encode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec       7212604 bytes
			
 
				+sourcemap-codec                  21421456 bytes
			
 
				+source-map-0.6.1                 25286888 bytes
			
 
				+source-map-0.8.0                 25498744 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode speed:
			
 
				+encode: @jridgewell/sourcemap-codec x 112 ops/sec ±0.13% (84 runs sampled)
			
 
				+encode: sourcemap-codec x 30.23 ops/sec ±2.76% (53 runs sampled)
			
 
				+encode: source-map-0.6.1 x 19.43 ops/sec ±3.70% (37 runs sampled)
			
 
				+encode: source-map-0.8.0 x 19.40 ops/sec ±3.26% (37 runs sampled)
			
 
				+Fastest is encode: @jridgewell/sourcemap-codec
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+preact.js.map - 1992 segments
			
 
				+
			
 
				+Decode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec        500272 bytes
			
 
				+sourcemap-codec                    516864 bytes
			
 
				+source-map-0.6.1                  1596672 bytes
			
 
				+source-map-0.8.0                   517272 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Decode speed:
			
 
				+decode: @jridgewell/sourcemap-codec x 16,137 ops/sec ±0.17% (99 runs sampled)
			
 
				+decode: sourcemap-codec x 12,139 ops/sec ±0.13% (99 runs sampled)
			
 
				+decode: source-map-0.6.1 x 1,264 ops/sec ±0.12% (100 runs sampled)
			
 
				+decode: source-map-0.8.0 x 9,894 ops/sec ±0.08% (101 runs sampled)
			
 
				+Fastest is decode: @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec        321026 bytes
			
 
				+sourcemap-codec                    830832 bytes
			
 
				+source-map-0.6.1                   586608 bytes
			
 
				+source-map-0.8.0                   586680 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode speed:
			
 
				+encode: @jridgewell/sourcemap-codec x 19,876 ops/sec ±0.78% (95 runs sampled)
			
 
				+encode: sourcemap-codec x 6,983 ops/sec ±0.15% (100 runs sampled)
			
 
				+encode: source-map-0.6.1 x 5,070 ops/sec ±0.12% (102 runs sampled)
			
 
				+encode: source-map-0.8.0 x 5,641 ops/sec ±0.17% (100 runs sampled)
			
 
				+Fastest is encode: @jridgewell/sourcemap-codec
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+react.js.map - 5726 segments
			
 
				+
			
 
				+Decode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec        734848 bytes
			
 
				+sourcemap-codec                    954200 bytes
			
 
				+source-map-0.6.1                  2276432 bytes
			
 
				+source-map-0.8.0                   955488 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Decode speed:
			
 
				+decode: @jridgewell/sourcemap-codec x 5,723 ops/sec ±0.12% (98 runs sampled)
			
 
				+decode: sourcemap-codec x 4,555 ops/sec ±0.09% (101 runs sampled)
			
 
				+decode: source-map-0.6.1 x 437 ops/sec ±0.11% (93 runs sampled)
			
 
				+decode: source-map-0.8.0 x 3,441 ops/sec ±0.15% (100 runs sampled)
			
 
				+Fastest is decode: @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode Memory Usage:
			
 
				+@jridgewell/sourcemap-codec        638672 bytes
			
 
				+sourcemap-codec                   1109840 bytes
			
 
				+source-map-0.6.1                  1321224 bytes
			
 
				+source-map-0.8.0                  1324448 bytes
			
 
				+Smallest memory usage is @jridgewell/sourcemap-codec
			
 
				+
			
 
				+Encode speed:
			
 
				+encode: @jridgewell/sourcemap-codec x 6,801 ops/sec ±0.48% (98 runs sampled)
			
 
				+encode: sourcemap-codec x 2,533 ops/sec ±0.13% (101 runs sampled)
			
 
				+encode: source-map-0.6.1 x 2,248 ops/sec ±0.08% (100 runs sampled)
			
 
				+encode: source-map-0.8.0 x 2,303 ops/sec ±0.15% (100 runs sampled)
			
 
				+Fastest is encode: @jridgewell/sourcemap-codec
			
 
				+```
			
 
				+
			
 
				+# License
			
 
				+
			
 
				+MIT
			
--- a/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -0,0 +1,164 @@
 
				+const comma = ','.charCodeAt(0);
			
 
				+const semicolon = ';'.charCodeAt(0);
			
 
				+const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
			
 
				+const intToChar = new Uint8Array(64); // 64 possible chars.
			
 
				+const charToInt = new Uint8Array(128); // z is 122 in ASCII
			
 
				+for (let i = 0; i < chars.length; i++) {
			
 
				+    const c = chars.charCodeAt(i);
			
 
				+    intToChar[i] = c;
			
 
				+    charToInt[c] = i;
			
 
				+}
			
 
				+// Provide a fallback for older environments.
			
 
				+const td = typeof TextDecoder !== 'undefined'
			
 
				+    ? /* #__PURE__ */ new TextDecoder()
			
 
				+    : typeof Buffer !== 'undefined'
			
 
				+        ? {
			
 
				+            decode(buf) {
			
 
				+                const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
			
 
				+                return out.toString();
			
 
				+            },
			
 
				+        }
			
 
				+        : {
			
 
				+            decode(buf) {
			
 
				+                let out = '';
			
 
				+                for (let i = 0; i < buf.length; i++) {
			
 
				+                    out += String.fromCharCode(buf[i]);
			
 
				+                }
			
 
				+                return out;
			
 
				+            },
			
 
				+        };
			
 
				+function decode(mappings) {
			
 
				+    const state = new Int32Array(5);
			
 
				+    const decoded = [];
			
 
				+    let index = 0;
			
 
				+    do {
			
 
				+        const semi = indexOf(mappings, index);
			
 
				+        const line = [];
			
 
				+        let sorted = true;
			
 
				+        let lastCol = 0;
			
 
				+        state[0] = 0;
			
 
				+        for (let i = index; i < semi; i++) {
			
 
				+            let seg;
			
 
				+            i = decodeInteger(mappings, i, state, 0); // genColumn
			
 
				+            const col = state[0];
			
 
				+            if (col < lastCol)
			
 
				+                sorted = false;
			
 
				+            lastCol = col;
			
 
				+            if (hasMoreVlq(mappings, i, semi)) {
			
 
				+                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
			
 
				+                i = decodeInteger(mappings, i, state, 2); // sourceLine
			
 
				+                i = decodeInteger(mappings, i, state, 3); // sourceColumn
			
 
				+                if (hasMoreVlq(mappings, i, semi)) {
			
 
				+                    i = decodeInteger(mappings, i, state, 4); // namesIndex
			
 
				+                    seg = [col, state[1], state[2], state[3], state[4]];
			
 
				+                }
			
 
				+                else {
			
 
				+                    seg = [col, state[1], state[2], state[3]];
			
 
				+                }
			
 
				+            }
			
 
				+            else {
			
 
				+                seg = [col];
			
 
				+            }
			
 
				+            line.push(seg);
			
 
				+        }
			
 
				+        if (!sorted)
			
 
				+            sort(line);
			
 
				+        decoded.push(line);
			
 
				+        index = semi + 1;
			
 
				+    } while (index <= mappings.length);
			
 
				+    return decoded;
			
 
				+}
			
 
				+function indexOf(mappings, index) {
			
 
				+    const idx = mappings.indexOf(';', index);
			
 
				+    return idx === -1 ? mappings.length : idx;
			
 
				+}
			
 
				+function decodeInteger(mappings, pos, state, j) {
			
 
				+    let value = 0;
			
 
				+    let shift = 0;
			
 
				+    let integer = 0;
			
 
				+    do {
			
 
				+        const c = mappings.charCodeAt(pos++);
			
 
				+        integer = charToInt[c];
			
 
				+        value |= (integer & 31) << shift;
			
 
				+        shift += 5;
			
 
				+    } while (integer & 32);
			
 
				+    const shouldNegate = value & 1;
			
 
				+    value >>>= 1;
			
 
				+    if (shouldNegate) {
			
 
				+        value = -0x80000000 | -value;
			
 
				+    }
			
 
				+    state[j] += value;
			
 
				+    return pos;
			
 
				+}
			
 
				+function hasMoreVlq(mappings, i, length) {
			
 
				+    if (i >= length)
			
 
				+        return false;
			
 
				+    return mappings.charCodeAt(i) !== comma;
			
 
				+}
			
 
				+function sort(line) {
			
 
				+    line.sort(sortComparator);
			
 
				+}
			
 
				+function sortComparator(a, b) {
			
 
				+    return a[0] - b[0];
			
 
				+}
			
 
				+function encode(decoded) {
			
 
				+    const state = new Int32Array(5);
			
 
				+    const bufLength = 1024 * 16;
			
 
				+    const subLength = bufLength - 36;
			
 
				+    const buf = new Uint8Array(bufLength);
			
 
				+    const sub = buf.subarray(0, subLength);
			
 
				+    let pos = 0;
			
 
				+    let out = '';
			
 
				+    for (let i = 0; i < decoded.length; i++) {
			
 
				+        const line = decoded[i];
			
 
				+        if (i > 0) {
			
 
				+            if (pos === bufLength) {
			
 
				+                out += td.decode(buf);
			
 
				+                pos = 0;
			
 
				+            }
			
 
				+            buf[pos++] = semicolon;
			
 
				+        }
			
 
				+        if (line.length === 0)
			
 
				+            continue;
			
 
				+        state[0] = 0;
			
 
				+        for (let j = 0; j < line.length; j++) {
			
 
				+            const segment = line[j];
			
 
				+            // We can push up to 5 ints, each int can take at most 7 chars, and we
			
 
				+            // may push a comma.
			
 
				+            if (pos > subLength) {
			
 
				+                out += td.decode(sub);
			
 
				+                buf.copyWithin(0, subLength, pos);
			
 
				+                pos -= subLength;
			
 
				+            }
			
 
				+            if (j > 0)
			
 
				+                buf[pos++] = comma;
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
			
 
				+            if (segment.length === 1)
			
 
				+                continue;
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
			
 
				+            if (segment.length === 4)
			
 
				+                continue;
			
 
				+            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
			
 
				+        }
			
 
				+    }
			
 
				+    return out + td.decode(buf.subarray(0, pos));
			
 
				+}
			
 
				+function encodeInteger(buf, pos, state, segment, j) {
			
 
				+    const next = segment[j];
			
 
				+    let num = next - state[j];
			
 
				+    state[j] = next;
			
 
				+    num = num < 0 ? (-num << 1) | 1 : num << 1;
			
 
				+    do {
			
 
				+        let clamped = num & 0b011111;
			
 
				+        num >>>= 5;
			
 
				+        if (num > 0)
			
 
				+            clamped |= 0b100000;
			
 
				+        buf[pos++] = intToChar[clamped];
			
 
				+    } while (num > 0);
			
 
				+    return pos;
			
 
				+}
			
 
				+
			
 
				+export { decode, encode };
			
 
				+//# sourceMappingURL=sourcemap-codec.mjs.map
			
--- a/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs.map
--- a/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js
@@ -0,0 +1,175 @@
 
				+(function (global, factory) {
			
 
				+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
			
 
				+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
			
 
				+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.sourcemapCodec = {}));
			
 
				+})(this, (function (exports) { 'use strict';
			
 
				+
			
 
				+    const comma = ','.charCodeAt(0);
			
 
				+    const semicolon = ';'.charCodeAt(0);
			
 
				+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
			
 
				+    const intToChar = new Uint8Array(64); // 64 possible chars.
			
 
				+    const charToInt = new Uint8Array(128); // z is 122 in ASCII
			
 
				+    for (let i = 0; i < chars.length; i++) {
			
 
				+        const c = chars.charCodeAt(i);
			
 
				+        intToChar[i] = c;
			
 
				+        charToInt[c] = i;
			
 
				+    }
			
 
				+    // Provide a fallback for older environments.
			
 
				+    const td = typeof TextDecoder !== 'undefined'
			
 
				+        ? /* #__PURE__ */ new TextDecoder()
			
 
				+        : typeof Buffer !== 'undefined'
			
 
				+            ? {
			
 
				+                decode(buf) {
			
 
				+                    const out = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
			
 
				+                    return out.toString();
			
 
				+                },
			
 
				+            }
			
 
				+            : {
			
 
				+                decode(buf) {
			
 
				+                    let out = '';
			
 
				+                    for (let i = 0; i < buf.length; i++) {
			
 
				+                        out += String.fromCharCode(buf[i]);
			
 
				+                    }
			
 
				+                    return out;
			
 
				+                },
			
 
				+            };
			
 
				+    function decode(mappings) {
			
 
				+        const state = new Int32Array(5);
			
 
				+        const decoded = [];
			
 
				+        let index = 0;
			
 
				+        do {
			
 
				+            const semi = indexOf(mappings, index);
			
 
				+            const line = [];
			
 
				+            let sorted = true;
			
 
				+            let lastCol = 0;
			
 
				+            state[0] = 0;
			
 
				+            for (let i = index; i < semi; i++) {
			
 
				+                let seg;
			
 
				+                i = decodeInteger(mappings, i, state, 0); // genColumn
			
 
				+                const col = state[0];
			
 
				+                if (col < lastCol)
			
 
				+                    sorted = false;
			
 
				+                lastCol = col;
			
 
				+                if (hasMoreVlq(mappings, i, semi)) {
			
 
				+                    i = decodeInteger(mappings, i, state, 1); // sourcesIndex
			
 
				+                    i = decodeInteger(mappings, i, state, 2); // sourceLine
			
 
				+                    i = decodeInteger(mappings, i, state, 3); // sourceColumn
			
 
				+                    if (hasMoreVlq(mappings, i, semi)) {
			
 
				+                        i = decodeInteger(mappings, i, state, 4); // namesIndex
			
 
				+                        seg = [col, state[1], state[2], state[3], state[4]];
			
 
				+                    }
			
 
				+                    else {
			
 
				+                        seg = [col, state[1], state[2], state[3]];
			
 
				+                    }
			
 
				+                }
			
 
				+                else {
			
 
				+                    seg = [col];
			
 
				+                }
			
 
				+                line.push(seg);
			
 
				+            }
			
 
				+            if (!sorted)
			
 
				+                sort(line);
			
 
				+            decoded.push(line);
			
 
				+            index = semi + 1;
			
 
				+        } while (index <= mappings.length);
			
 
				+        return decoded;
			
 
				+    }
			
 
				+    function indexOf(mappings, index) {
			
 
				+        const idx = mappings.indexOf(';', index);
			
 
				+        return idx === -1 ? mappings.length : idx;
			
 
				+    }
			
 
				+    function decodeInteger(mappings, pos, state, j) {
			
 
				+        let value = 0;
			
 
				+        let shift = 0;
			
 
				+        let integer = 0;
			
 
				+        do {
			
 
				+            const c = mappings.charCodeAt(pos++);
			
 
				+            integer = charToInt[c];
			
 
				+            value |= (integer & 31) << shift;
			
 
				+            shift += 5;
			
 
				+        } while (integer & 32);
			
 
				+        const shouldNegate = value & 1;
			
 
				+        value >>>= 1;
			
 
				+        if (shouldNegate) {
			
 
				+            value = -0x80000000 | -value;
			
 
				+        }
			
 
				+        state[j] += value;
			
 
				+        return pos;
			
 
				+    }
			
 
				+    function hasMoreVlq(mappings, i, length) {
			
 
				+        if (i >= length)
			
 
				+            return false;
			
 
				+        return mappings.charCodeAt(i) !== comma;
			
 
				+    }
			
 
				+    function sort(line) {
			
 
				+        line.sort(sortComparator);
			
 
				+    }
			
 
				+    function sortComparator(a, b) {
			
 
				+        return a[0] - b[0];
			
 
				+    }
			
 
				+    function encode(decoded) {
			
 
				+        const state = new Int32Array(5);
			
 
				+        const bufLength = 1024 * 16;
			
 
				+        const subLength = bufLength - 36;
			
 
				+        const buf = new Uint8Array(bufLength);
			
 
				+        const sub = buf.subarray(0, subLength);
			
 
				+        let pos = 0;
			
 
				+        let out = '';
			
 
				+        for (let i = 0; i < decoded.length; i++) {
			
 
				+            const line = decoded[i];
			
 
				+            if (i > 0) {
			
 
				+                if (pos === bufLength) {
			
 
				+                    out += td.decode(buf);
			
 
				+                    pos = 0;
			
 
				+                }
			
 
				+                buf[pos++] = semicolon;
			
 
				+            }
			
 
				+            if (line.length === 0)
			
 
				+                continue;
			
 
				+            state[0] = 0;
			
 
				+            for (let j = 0; j < line.length; j++) {
			
 
				+                const segment = line[j];
			
 
				+                // We can push up to 5 ints, each int can take at most 7 chars, and we
			
 
				+                // may push a comma.
			
 
				+                if (pos > subLength) {
			
 
				+                    out += td.decode(sub);
			
 
				+                    buf.copyWithin(0, subLength, pos);
			
 
				+                    pos -= subLength;
			
 
				+                }
			
 
				+                if (j > 0)
			
 
				+                    buf[pos++] = comma;
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
			
 
				+                if (segment.length === 1)
			
 
				+                    continue;
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
			
 
				+                if (segment.length === 4)
			
 
				+                    continue;
			
 
				+                pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
			
 
				+            }
			
 
				+        }
			
 
				+        return out + td.decode(buf.subarray(0, pos));
			
 
				+    }
			
 
				+    function encodeInteger(buf, pos, state, segment, j) {
			
 
				+        const next = segment[j];
			
 
				+        let num = next - state[j];
			
 
				+        state[j] = next;
			
 
				+        num = num < 0 ? (-num << 1) | 1 : num << 1;
			
 
				+        do {
			
 
				+            let clamped = num & 0b011111;
			
 
				+            num >>>= 5;
			
 
				+            if (num > 0)
			
 
				+                clamped |= 0b100000;
			
 
				+            buf[pos++] = intToChar[clamped];
			
 
				+        } while (num > 0);
			
 
				+        return pos;
			
 
				+    }
			
 
				+
			
 
				+    exports.decode = decode;
			
 
				+    exports.encode = encode;
			
 
				+
			
 
				+    Object.defineProperty(exports, '__esModule', { value: true });
			
 
				+
			
 
				+}));
			
 
				+//# sourceMappingURL=sourcemap-codec.umd.js.map
			
--- a/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.umd.js.map
--- a/day37/node_modules/@jridgewell/sourcemap-codec/dist/types/sourcemap-codec.d.ts
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/dist/types/sourcemap-codec.d.ts
@@ -0,0 +1,6 @@
 
				+export declare type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number];
			
 
				+export declare type SourceMapLine = SourceMapSegment[];
			
 
				+export declare type SourceMapMappings = SourceMapLine[];
			
 
				+export declare function decode(mappings: string): SourceMapMappings;
			
 
				+export declare function encode(decoded: SourceMapMappings): string;
			
 
				+export declare function encode(decoded: Readonly<SourceMapMappings>): string;
			
--- a/day37/node_modules/@jridgewell/sourcemap-codec/package.json
+++ b/day37/node_modules/@jridgewell/sourcemap-codec/package.json
@@ -0,0 +1,74 @@
 
				+{
			
 
				+  "name": "@jridgewell/sourcemap-codec",
			
 
				+  "version": "1.4.15",
			
 
				+  "description": "Encode/decode sourcemap mappings",
			
 
				+  "keywords": [
			
 
				+    "sourcemap",
			
 
				+    "vlq"
			
 
				+  ],
			
 
				+  "main": "dist/sourcemap-codec.umd.js",
			
 
				+  "module": "dist/sourcemap-codec.mjs",
			
 
				+  "types": "dist/types/sourcemap-codec.d.ts",
			
 
				+  "files": [
			
 
				+    "dist"
			
 
				+  ],
			
 
				+  "exports": {
			
 
				+    ".": [
			
 
				+      {
			
 
				+        "types": "./dist/types/sourcemap-codec.d.ts",
			
 
				+        "browser": "./dist/sourcemap-codec.umd.js",
			
 
				+        "require": "./dist/sourcemap-codec.umd.js",
			
 
				+        "import": "./dist/sourcemap-codec.mjs"
			
 
				+      },
			
 
				+      "./dist/sourcemap-codec.umd.js"
			
 
				+    ],
			
 
				+    "./package.json": "./package.json"
			
 
				+  },
			
 
				+  "scripts": {
			
 
				+    "benchmark": "run-s build:rollup benchmark:*",
			
 
				+    "benchmark:install": "cd benchmark && npm install",
			
 
				+    "benchmark:only": "node --expose-gc benchmark/index.js",
			
 
				+    "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",
			
 
				+    "pretest": "run-s build:rollup",
			
 
				+    "test": "run-s -n test:lint test:only",
			
 
				+    "test:debug": "mocha --inspect-brk",
			
 
				+    "test:lint": "run-s -n test:lint:*",
			
 
				+    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts'",
			
 
				+    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
			
 
				+    "test:only": "mocha",
			
 
				+    "test:coverage": "c8 mocha",
			
 
				+    "test:watch": "mocha --watch"
			
 
				+  },
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "git+https://github.com/jridgewell/sourcemap-codec.git"
			
 
				+  },
			
 
				+  "author": "Rich Harris",
			
 
				+  "license": "MIT",
			
 
				+  "devDependencies": {
			
 
				+    "@rollup/plugin-typescript": "8.3.0",
			
 
				+    "@types/node": "17.0.15",
			
 
				+    "@typescript-eslint/eslint-plugin": "5.10.0",
			
 
				+    "@typescript-eslint/parser": "5.10.0",
			
 
				+    "benchmark": "2.1.4",
			
 
				+    "c8": "7.11.2",
			
 
				+    "eslint": "8.7.0",
			
 
				+    "eslint-config-prettier": "8.3.0",
			
 
				+    "mocha": "9.2.0",
			
 
				+    "npm-run-all": "4.1.5",
			
 
				+    "prettier": "2.5.1",
			
 
				+    "rollup": "2.64.0",
			
 
				+    "source-map": "0.6.1",
			
 
				+    "source-map-js": "1.0.2",
			
 
				+    "sourcemap-codec": "1.4.8",
			
 
				+    "typescript": "4.5.4"
			
 
				+  }
			
 
				+}
			
--- a/day37/node_modules/@jridgewell/trace-mapping/LICENSE
+++ b/day37/node_modules/@jridgewell/trace-mapping/LICENSE
@@ -0,0 +1,19 @@
 
				+Copyright 2022 Justin Ridgewell <justin@ridgewell.name>
			
 
				+
			
 
				+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/day37/node_modules/@jridgewell/trace-mapping/README.md
+++ b/day37/node_modules/@jridgewell/trace-mapping/README.md
@@ -0,0 +1,252 @@
 
				+# @jridgewell/trace-mapping
			
 
				+
			
 
				+> Trace the original position through a source map
			
 
				+
			
 
				+`trace-mapping` allows you to take the line and column of an output file and trace it to the
			
 
				+original location in the source file through a source map.
			
 
				+
			
 
				+You may already be familiar with the [`source-map`][source-map] package's `SourceMapConsumer`. This
			
 
				+provides the same `originalPositionFor` and `generatedPositionFor` API, without requiring WASM.
			
 
				+
			
 
				+## Installation
			
 
				+
			
 
				+```sh
			
 
				+npm install @jridgewell/trace-mapping
			
 
				+```
			
 
				+
			
 
				+## Usage
			
 
				+
			
 
				+```typescript
			
 
				+import {
			
 
				+  TraceMap,
			
 
				+  originalPositionFor,
			
 
				+  generatedPositionFor,
			
 
				+  sourceContentFor,
			
 
				+} from '@jridgewell/trace-mapping';
			
 
				+
			
 
				+const tracer = new TraceMap({
			
 
				+  version: 3,
			
 
				+  sources: ['input.js'],
			
 
				+  sourcesContent: ['content of input.js'],
			
 
				+  names: ['foo'],
			
 
				+  mappings: 'KAyCIA',
			
 
				+});
			
 
				+
			
 
				+// Lines start at line 1, columns at column 0.
			
 
				+const traced = originalPositionFor(tracer, { line: 1, column: 5 });
			
 
				+assert.deepEqual(traced, {
			
 
				+  source: 'input.js',
			
 
				+  line: 42,
			
 
				+  column: 4,
			
 
				+  name: 'foo',
			
 
				+});
			
 
				+
			
 
				+const content = sourceContentFor(tracer, traced.source);
			
 
				+assert.strictEqual(content, 'content for input.js');
			
 
				+
			
 
				+const generated = generatedPositionFor(tracer, {
			
 
				+  source: 'input.js',
			
 
				+  line: 42,
			
 
				+  column: 4,
			
 
				+});
			
 
				+assert.deepEqual(generated, {
			
 
				+  line: 1,
			
 
				+  column: 5,
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+We also provide a lower level API to get the actual segment that matches our line and column. Unlike
			
 
				+`originalPositionFor`, `traceSegment` uses a 0-base for `line`:
			
 
				+
			
 
				+```typescript
			
 
				+import { traceSegment } from '@jridgewell/trace-mapping';
			
 
				+
			
 
				+// line is 0-base.
			
 
				+const traced = traceSegment(tracer, /* line */ 0, /* column */ 5);
			
 
				+
			
 
				+// Segments are [outputColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex]
			
 
				+// Again, line is 0-base and so is sourceLine
			
 
				+assert.deepEqual(traced, [5, 0, 41, 4, 0]);
			
 
				+```
			
 
				+
			
 
				+### SectionedSourceMaps
			
 
				+
			
 
				+The sourcemap spec defines a special `sections` field that's designed to handle concatenation of
			
 
				+output code with associated sourcemaps. This type of sourcemap is rarely used (no major build tool
			
 
				+produces it), but if you are hand coding a concatenation you may need it. We provide an `AnyMap`
			
 
				+helper that can receive either a regular sourcemap or a `SectionedSourceMap` and returns a
			
 
				+`TraceMap` instance:
			
 
				+
			
 
				+```typescript
			
 
				+import { AnyMap } from '@jridgewell/trace-mapping';
			
 
				+const fooOutput = 'foo';
			
 
				+const barOutput = 'bar';
			
 
				+const output = [fooOutput, barOutput].join('\n');
			
 
				+
			
 
				+const sectioned = new AnyMap({
			
 
				+  version: 3,
			
 
				+  sections: [
			
 
				+    {
			
 
				+      // 0-base line and column
			
 
				+      offset: { line: 0, column: 0 },
			
 
				+      // fooOutput's sourcemap
			
 
				+      map: {
			
 
				+        version: 3,
			
 
				+        sources: ['foo.js'],
			
 
				+        names: ['foo'],
			
 
				+        mappings: 'AAAAA',
			
 
				+      },
			
 
				+    },
			
 
				+    {
			
 
				+      // barOutput's sourcemap will not affect the first line, only the second
			
 
				+      offset: { line: 1, column: 0 },
			
 
				+      map: {
			
 
				+        version: 3,
			
 
				+        sources: ['bar.js'],
			
 
				+        names: ['bar'],
			
 
				+        mappings: 'AAAAA',
			
 
				+      },
			
 
				+    },
			
 
				+  ],
			
 
				+});
			
 
				+
			
 
				+const traced = originalPositionFor(sectioned, {
			
 
				+  line: 2,
			
 
				+  column: 0,
			
 
				+});
			
 
				+
			
 
				+assert.deepEqual(traced, {
			
 
				+  source: 'bar.js',
			
 
				+  line: 1,
			
 
				+  column: 0,
			
 
				+  name: 'bar',
			
 
				+});
			
 
				+```
			
 
				+
			
 
				+## Benchmarks
			
 
				+
			
 
				+```
			
 
				+node v18.0.0
			
 
				+
			
 
				+amp.js.map - 45120 segments
			
 
				+
			
 
				+Memory Usage:
			
 
				+trace-mapping decoded         562400 bytes
			
 
				+trace-mapping encoded        5706544 bytes
			
 
				+source-map-js               10717664 bytes
			
 
				+source-map-0.6.1            17446384 bytes
			
 
				+source-map-0.8.0             9701757 bytes
			
 
				+Smallest memory usage is trace-mapping decoded
			
 
				+
			
 
				+Init speed:
			
 
				+trace-mapping:    decoded JSON input x 180 ops/sec ±0.34% (85 runs sampled)
			
 
				+trace-mapping:    encoded JSON input x 364 ops/sec ±1.77% (89 runs sampled)
			
 
				+trace-mapping:    decoded Object input x 3,116 ops/sec ±0.50% (96 runs sampled)
			
 
				+trace-mapping:    encoded Object input x 410 ops/sec ±2.62% (85 runs sampled)
			
 
				+source-map-js:    encoded Object input x 84.23 ops/sec ±0.91% (73 runs sampled)
			
 
				+source-map-0.6.1: encoded Object input x 37.21 ops/sec ±2.08% (51 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded Object input
			
 
				+
			
 
				+Trace speed:
			
 
				+trace-mapping:    decoded originalPositionFor x 3,952,212 ops/sec ±0.17% (98 runs sampled)
			
 
				+trace-mapping:    encoded originalPositionFor x 3,487,468 ops/sec ±1.58% (90 runs sampled)
			
 
				+source-map-js:    encoded originalPositionFor x 827,730 ops/sec ±0.78% (97 runs sampled)
			
 
				+source-map-0.6.1: encoded originalPositionFor x 748,991 ops/sec ±0.53% (94 runs sampled)
			
 
				+source-map-0.8.0: encoded originalPositionFor x 2,532,894 ops/sec ±0.57% (95 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded originalPositionFor
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+babel.min.js.map - 347793 segments
			
 
				+
			
 
				+Memory Usage:
			
 
				+trace-mapping decoded          89832 bytes
			
 
				+trace-mapping encoded       35474640 bytes
			
 
				+source-map-js               51257176 bytes
			
 
				+source-map-0.6.1            63515664 bytes
			
 
				+source-map-0.8.0            42933752 bytes
			
 
				+Smallest memory usage is trace-mapping decoded
			
 
				+
			
 
				+Init speed:
			
 
				+trace-mapping:    decoded JSON input x 15.41 ops/sec ±8.65% (34 runs sampled)
			
 
				+trace-mapping:    encoded JSON input x 28.20 ops/sec ±12.87% (42 runs sampled)
			
 
				+trace-mapping:    decoded Object input x 964 ops/sec ±0.36% (99 runs sampled)
			
 
				+trace-mapping:    encoded Object input x 31.77 ops/sec ±13.79% (45 runs sampled)
			
 
				+source-map-js:    encoded Object input x 6.45 ops/sec ±5.16% (21 runs sampled)
			
 
				+source-map-0.6.1: encoded Object input x 4.07 ops/sec ±5.24% (15 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded Object input
			
 
				+
			
 
				+Trace speed:
			
 
				+trace-mapping:    decoded originalPositionFor x 7,183,038 ops/sec ±0.58% (95 runs sampled)
			
 
				+trace-mapping:    encoded originalPositionFor x 5,192,185 ops/sec ±0.41% (100 runs sampled)
			
 
				+source-map-js:    encoded originalPositionFor x 4,259,489 ops/sec ±0.79% (94 runs sampled)
			
 
				+source-map-0.6.1: encoded originalPositionFor x 3,742,629 ops/sec ±0.71% (95 runs sampled)
			
 
				+source-map-0.8.0: encoded originalPositionFor x 6,270,211 ops/sec ±0.64% (94 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded originalPositionFor
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+preact.js.map - 1992 segments
			
 
				+
			
 
				+Memory Usage:
			
 
				+trace-mapping decoded          37128 bytes
			
 
				+trace-mapping encoded         247280 bytes
			
 
				+source-map-js                1143536 bytes
			
 
				+source-map-0.6.1             1290992 bytes
			
 
				+source-map-0.8.0               96544 bytes
			
 
				+Smallest memory usage is trace-mapping decoded
			
 
				+
			
 
				+Init speed:
			
 
				+trace-mapping:    decoded JSON input x 3,483 ops/sec ±0.30% (98 runs sampled)
			
 
				+trace-mapping:    encoded JSON input x 6,092 ops/sec ±0.18% (97 runs sampled)
			
 
				+trace-mapping:    decoded Object input x 249,076 ops/sec ±0.24% (98 runs sampled)
			
 
				+trace-mapping:    encoded Object input x 14,555 ops/sec ±0.48% (100 runs sampled)
			
 
				+source-map-js:    encoded Object input x 2,447 ops/sec ±0.36% (99 runs sampled)
			
 
				+source-map-0.6.1: encoded Object input x 1,201 ops/sec ±0.57% (96 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded Object input
			
 
				+
			
 
				+Trace speed:
			
 
				+trace-mapping:    decoded originalPositionFor x 7,620,192 ops/sec ±0.09% (99 runs sampled)
			
 
				+trace-mapping:    encoded originalPositionFor x 6,872,554 ops/sec ±0.30% (97 runs sampled)
			
 
				+source-map-js:    encoded originalPositionFor x 2,489,570 ops/sec ±0.35% (94 runs sampled)
			
 
				+source-map-0.6.1: encoded originalPositionFor x 1,698,633 ops/sec ±0.28% (98 runs sampled)
			
 
				+source-map-0.8.0: encoded originalPositionFor x 4,015,644 ops/sec ±0.22% (98 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded originalPositionFor
			
 
				+
			
 
				+
			
 
				+***
			
 
				+
			
 
				+
			
 
				+react.js.map - 5726 segments
			
 
				+
			
 
				+Memory Usage:
			
 
				+trace-mapping decoded          16176 bytes
			
 
				+trace-mapping encoded         681552 bytes
			
 
				+source-map-js                2418352 bytes
			
 
				+source-map-0.6.1             2443672 bytes
			
 
				+source-map-0.8.0              111768 bytes
			
 
				+Smallest memory usage is trace-mapping decoded
			
 
				+
			
 
				+Init speed:
			
 
				+trace-mapping:    decoded JSON input x 1,720 ops/sec ±0.34% (98 runs sampled)
			
 
				+trace-mapping:    encoded JSON input x 4,406 ops/sec ±0.35% (100 runs sampled)
			
 
				+trace-mapping:    decoded Object input x 92,122 ops/sec ±0.10% (99 runs sampled)
			
 
				+trace-mapping:    encoded Object input x 5,385 ops/sec ±0.37% (99 runs sampled)
			
 
				+source-map-js:    encoded Object input x 794 ops/sec ±0.40% (98 runs sampled)
			
 
				+source-map-0.6.1: encoded Object input x 416 ops/sec ±0.54% (91 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded Object input
			
 
				+
			
 
				+Trace speed:
			
 
				+trace-mapping:    decoded originalPositionFor x 32,759,519 ops/sec ±0.33% (100 runs sampled)
			
 
				+trace-mapping:    encoded originalPositionFor x 31,116,306 ops/sec ±0.33% (97 runs sampled)
			
 
				+source-map-js:    encoded originalPositionFor x 17,458,435 ops/sec ±0.44% (97 runs sampled)
			
 
				+source-map-0.6.1: encoded originalPositionFor x 12,687,097 ops/sec ±0.43% (95 runs sampled)
			
 
				+source-map-0.8.0: encoded originalPositionFor x 23,538,275 ops/sec ±0.38% (95 runs sampled)
			
 
				+Fastest is trace-mapping:    decoded originalPositionFor
			
 
				+```
			
 
				+
			
 
				+[source-map]: https://www.npmjs.com/package/source-map
			
--- a/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+++ b/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
@@ -0,0 +1,552 @@
 
				+import { encode, decode } from '@jridgewell/sourcemap-codec';
			
 
				+import resolveUri from '@jridgewell/resolve-uri';
			
 
				+
			
 
				+function resolve(input, base) {
			
 
				+    // The base is always treated as a directory, if it's not empty.
			
 
				+    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
			
 
				+    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
			
 
				+    if (base && !base.endsWith('/'))
			
 
				+        base += '/';
			
 
				+    return resolveUri(input, base);
			
 
				+}
			
 
				+
			
 
				+/**
			
 
				+ * Removes everything after the last "/", but leaves the slash.
			
 
				+ */
			
 
				+function stripFilename(path) {
			
 
				+    if (!path)
			
 
				+        return '';
			
 
				+    const index = path.lastIndexOf('/');
			
 
				+    return path.slice(0, index + 1);
			
 
				+}
			
 
				+
			
 
				+const COLUMN = 0;
			
 
				+const SOURCES_INDEX = 1;
			
 
				+const SOURCE_LINE = 2;
			
 
				+const SOURCE_COLUMN = 3;
			
 
				+const NAMES_INDEX = 4;
			
 
				+const REV_GENERATED_LINE = 1;
			
 
				+const REV_GENERATED_COLUMN = 2;
			
 
				+
			
 
				+function maybeSort(mappings, owned) {
			
 
				+    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
			
 
				+    if (unsortedIndex === mappings.length)
			
 
				+        return mappings;
			
 
				+    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
			
 
				+    // not, we do not want to modify the consumer's input array.
			
 
				+    if (!owned)
			
 
				+        mappings = mappings.slice();
			
 
				+    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
			
 
				+        mappings[i] = sortSegments(mappings[i], owned);
			
 
				+    }
			
 
				+    return mappings;
			
 
				+}
			
 
				+function nextUnsortedSegmentLine(mappings, start) {
			
 
				+    for (let i = start; i < mappings.length; i++) {
			
 
				+        if (!isSorted(mappings[i]))
			
 
				+            return i;
			
 
				+    }
			
 
				+    return mappings.length;
			
 
				+}
			
 
				+function isSorted(line) {
			
 
				+    for (let j = 1; j < line.length; j++) {
			
 
				+        if (line[j][COLUMN] < line[j - 1][COLUMN]) {
			
 
				+            return false;
			
 
				+        }
			
 
				+    }
			
 
				+    return true;
			
 
				+}
			
 
				+function sortSegments(line, owned) {
			
 
				+    if (!owned)
			
 
				+        line = line.slice();
			
 
				+    return line.sort(sortComparator);
			
 
				+}
			
 
				+function sortComparator(a, b) {
			
 
				+    return a[COLUMN] - b[COLUMN];
			
 
				+}
			
 
				+
			
 
				+let found = false;
			
 
				+/**
			
 
				+ * A binary search implementation that returns the index if a match is found.
			
 
				+ * If no match is found, then the left-index (the index associated with the item that comes just
			
 
				+ * before the desired index) is returned. To maintain proper sort order, a splice would happen at
			
 
				+ * the next index:
			
 
				+ *
			
 
				+ * ```js
			
 
				+ * const array = [1, 3];
			
 
				+ * const needle = 2;
			
 
				+ * const index = binarySearch(array, needle, (item, needle) => item - needle);
			
 
				+ *
			
 
				+ * assert.equal(index, 0);
			
 
				+ * array.splice(index + 1, 0, needle);
			
 
				+ * assert.deepEqual(array, [1, 2, 3]);
			
 
				+ * ```
			
 
				+ */
			
 
				+function binarySearch(haystack, needle, low, high) {
			
 
				+    while (low <= high) {
			
 
				+        const mid = low + ((high - low) >> 1);
			
 
				+        const cmp = haystack[mid][COLUMN] - needle;
			
 
				+        if (cmp === 0) {
			
 
				+            found = true;
			
 
				+            return mid;
			
 
				+        }
			
 
				+        if (cmp < 0) {
			
 
				+            low = mid + 1;
			
 
				+        }
			
 
				+        else {
			
 
				+            high = mid - 1;
			
 
				+        }
			
 
				+    }
			
 
				+    found = false;
			
 
				+    return low - 1;
			
 
				+}
			
 
				+function upperBound(haystack, needle, index) {
			
 
				+    for (let i = index + 1; i < haystack.length; index = i++) {
			
 
				+        if (haystack[i][COLUMN] !== needle)
			
 
				+            break;
			
 
				+    }
			
 
				+    return index;
			
 
				+}
			
 
				+function lowerBound(haystack, needle, index) {
			
 
				+    for (let i = index - 1; i >= 0; index = i--) {
			
 
				+        if (haystack[i][COLUMN] !== needle)
			
 
				+            break;
			
 
				+    }
			
 
				+    return index;
			
 
				+}
			
 
				+function memoizedState() {
			
 
				+    return {
			
 
				+        lastKey: -1,
			
 
				+        lastNeedle: -1,
			
 
				+        lastIndex: -1,
			
 
				+    };
			
 
				+}
			
 
				+/**
			
 
				+ * This overly complicated beast is just to record the last tested line/column and the resulting
			
 
				+ * index, allowing us to skip a few tests if mappings are monotonically increasing.
			
 
				+ */
			
 
				+function memoizedBinarySearch(haystack, needle, state, key) {
			
 
				+    const { lastKey, lastNeedle, lastIndex } = state;
			
 
				+    let low = 0;
			
 
				+    let high = haystack.length - 1;
			
 
				+    if (key === lastKey) {
			
 
				+        if (needle === lastNeedle) {
			
 
				+            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
			
 
				+            return lastIndex;
			
 
				+        }
			
 
				+        if (needle >= lastNeedle) {
			
 
				+            // lastIndex may be -1 if the previous needle was not found.
			
 
				+            low = lastIndex === -1 ? 0 : lastIndex;
			
 
				+        }
			
 
				+        else {
			
 
				+            high = lastIndex;
			
 
				+        }
			
 
				+    }
			
 
				+    state.lastKey = key;
			
 
				+    state.lastNeedle = needle;
			
 
				+    return (state.lastIndex = binarySearch(haystack, needle, low, high));
			
 
				+}
			
 
				+
			
 
				+// Rebuilds the original source files, with mappings that are ordered by source line/column instead
			
 
				+// of generated line/column.
			
 
				+function buildBySources(decoded, memos) {
			
 
				+    const sources = memos.map(buildNullArray);
			
 
				+    for (let i = 0; i < decoded.length; i++) {
			
 
				+        const line = decoded[i];
			
 
				+        for (let j = 0; j < line.length; j++) {
			
 
				+            const seg = line[j];
			
 
				+            if (seg.length === 1)
			
 
				+                continue;
			
 
				+            const sourceIndex = seg[SOURCES_INDEX];
			
 
				+            const sourceLine = seg[SOURCE_LINE];
			
 
				+            const sourceColumn = seg[SOURCE_COLUMN];
			
 
				+            const originalSource = sources[sourceIndex];
			
 
				+            const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
			
 
				+            const memo = memos[sourceIndex];
			
 
				+            // The binary search either found a match, or it found the left-index just before where the
			
 
				+            // segment should go. Either way, we want to insert after that. And there may be multiple
			
 
				+            // generated segments associated with an original location, so there may need to move several
			
 
				+            // indexes before we find where we need to insert.
			
 
				+            const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
			
 
				+            insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
			
 
				+        }
			
 
				+    }
			
 
				+    return sources;
			
 
				+}
			
 
				+function insert(array, index, value) {
			
 
				+    for (let i = array.length; i > index; i--) {
			
 
				+        array[i] = array[i - 1];
			
 
				+    }
			
 
				+    array[index] = value;
			
 
				+}
			
 
				+// Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
			
 
				+// a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
			
 
				+// Numeric properties on objects are magically sorted in ascending order by the engine regardless of
			
 
				+// the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
			
 
				+// order when iterating with for-in.
			
 
				+function buildNullArray() {
			
 
				+    return { __proto__: null };
			
 
				+}
			
 
				+
			
 
				+const AnyMap = function (map, mapUrl) {
			
 
				+    const parsed = typeof map === 'string' ? JSON.parse(map) : map;
			
 
				+    if (!('sections' in parsed))
			
 
				+        return new TraceMap(parsed, mapUrl);
			
 
				+    const mappings = [];
			
 
				+    const sources = [];
			
 
				+    const sourcesContent = [];
			
 
				+    const names = [];
			
 
				+    recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
			
 
				+    const joined = {
			
 
				+        version: 3,
			
 
				+        file: parsed.file,
			
 
				+        names,
			
 
				+        sources,
			
 
				+        sourcesContent,
			
 
				+        mappings,
			
 
				+    };
			
 
				+    return presortedDecodedMap(joined);
			
 
				+};
			
 
				+function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
			
 
				+    const { sections } = input;
			
 
				+    for (let i = 0; i < sections.length; i++) {
			
 
				+        const { map, offset } = sections[i];
			
 
				+        let sl = stopLine;
			
 
				+        let sc = stopColumn;
			
 
				+        if (i + 1 < sections.length) {
			
 
				+            const nextOffset = sections[i + 1].offset;
			
 
				+            sl = Math.min(stopLine, lineOffset + nextOffset.line);
			
 
				+            if (sl === stopLine) {
			
 
				+                sc = Math.min(stopColumn, columnOffset + nextOffset.column);
			
 
				+            }
			
 
				+            else if (sl < stopLine) {
			
 
				+                sc = columnOffset + nextOffset.column;
			
 
				+            }
			
 
				+        }
			
 
				+        addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
			
 
				+    }
			
 
				+}
			
 
				+function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
			
 
				+    if ('sections' in input)
			
 
				+        return recurse(...arguments);
			
 
				+    const map = new TraceMap(input, mapUrl);
			
 
				+    const sourcesOffset = sources.length;
			
 
				+    const namesOffset = names.length;
			
 
				+    const decoded = decodedMappings(map);
			
 
				+    const { resolvedSources, sourcesContent: contents } = map;
			
 
				+    append(sources, resolvedSources);
			
 
				+    append(names, map.names);
			
 
				+    if (contents)
			
 
				+        append(sourcesContent, contents);
			
 
				+    else
			
 
				+        for (let i = 0; i < resolvedSources.length; i++)
			
 
				+            sourcesContent.push(null);
			
 
				+    for (let i = 0; i < decoded.length; i++) {
			
 
				+        const lineI = lineOffset + i;
			
 
				+        // We can only add so many lines before we step into the range that the next section's map
			
 
				+        // controls. When we get to the last line, then we'll start checking the segments to see if
			
 
				+        // they've crossed into the column range. But it may not have any columns that overstep, so we
			
 
				+        // still need to check that we don't overstep lines, too.
			
 
				+        if (lineI > stopLine)
			
 
				+            return;
			
 
				+        // The out line may already exist in mappings (if we're continuing the line started by a
			
 
				+        // previous section). Or, we may have jumped ahead several lines to start this section.
			
 
				+        const out = getLine(mappings, lineI);
			
 
				+        // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
			
 
				+        // map can be multiple lines), it doesn't.
			
 
				+        const cOffset = i === 0 ? columnOffset : 0;
			
 
				+        const line = decoded[i];
			
 
				+        for (let j = 0; j < line.length; j++) {
			
 
				+            const seg = line[j];
			
 
				+            const column = cOffset + seg[COLUMN];
			
 
				+            // If this segment steps into the column range that the next section's map controls, we need
			
 
				+            // to stop early.
			
 
				+            if (lineI === stopLine && column >= stopColumn)
			
 
				+                return;
			
 
				+            if (seg.length === 1) {
			
 
				+                out.push([column]);
			
 
				+                continue;
			
 
				+            }
			
 
				+            const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
			
 
				+            const sourceLine = seg[SOURCE_LINE];
			
 
				+            const sourceColumn = seg[SOURCE_COLUMN];
			
 
				+            out.push(seg.length === 4
			
 
				+                ? [column, sourcesIndex, sourceLine, sourceColumn]
			
 
				+                : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
			
 
				+        }
			
 
				+    }
			
 
				+}
			
 
				+function append(arr, other) {
			
 
				+    for (let i = 0; i < other.length; i++)
			
 
				+        arr.push(other[i]);
			
 
				+}
			
 
				+function getLine(arr, index) {
			
 
				+    for (let i = arr.length; i <= index; i++)
			
 
				+        arr[i] = [];
			
 
				+    return arr[index];
			
 
				+}
			
 
				+
			
 
				+const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
			
 
				+const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
			
 
				+const LEAST_UPPER_BOUND = -1;
			
 
				+const GREATEST_LOWER_BOUND = 1;
			
 
				+/**
			
 
				+ * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
			
 
				+ */
			
 
				+let encodedMappings;
			
 
				+/**
			
 
				+ * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
			
 
				+ */
			
 
				+let decodedMappings;
			
 
				+/**
			
 
				+ * A low-level API to find the segment associated with a generated line/column (think, from a
			
 
				+ * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
			
 
				+ */
			
 
				+let traceSegment;
			
 
				+/**
			
 
				+ * A higher-level API to find the source/line/column associated with a generated line/column
			
 
				+ * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
			
 
				+ * `source-map` library.
			
 
				+ */
			
 
				+let originalPositionFor;
			
 
				+/**
			
 
				+ * Finds the generated line/column position of the provided source/line/column source position.
			
 
				+ */
			
 
				+let generatedPositionFor;
			
 
				+/**
			
 
				+ * Finds all generated line/column positions of the provided source/line/column source position.
			
 
				+ */
			
 
				+let allGeneratedPositionsFor;
			
 
				+/**
			
 
				+ * Iterates each mapping in generated position order.
			
 
				+ */
			
 
				+let eachMapping;
			
 
				+/**
			
 
				+ * Retrieves the source content for a particular source, if its found. Returns null if not.
			
 
				+ */
			
 
				+let sourceContentFor;
			
 
				+/**
			
 
				+ * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
			
 
				+ * maps.
			
 
				+ */
			
 
				+let presortedDecodedMap;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+let decodedMap;
			
 
				+/**
			
 
				+ * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
			
 
				+ * a sourcemap, or to JSON.stringify.
			
 
				+ */
			
 
				+let encodedMap;
			
 
				+class TraceMap {
			
 
				+    constructor(map, mapUrl) {
			
 
				+        const isString = typeof map === 'string';
			
 
				+        if (!isString && map._decodedMemo)
			
 
				+            return map;
			
 
				+        const parsed = (isString ? JSON.parse(map) : map);
			
 
				+        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
			
 
				+        this.version = version;
			
 
				+        this.file = file;
			
 
				+        this.names = names || [];
			
 
				+        this.sourceRoot = sourceRoot;
			
 
				+        this.sources = sources;
			
 
				+        this.sourcesContent = sourcesContent;
			
 
				+        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
			
 
				+        this.resolvedSources = sources.map((s) => resolve(s || '', from));
			
 
				+        const { mappings } = parsed;
			
 
				+        if (typeof mappings === 'string') {
			
 
				+            this._encoded = mappings;
			
 
				+            this._decoded = undefined;
			
 
				+        }
			
 
				+        else {
			
 
				+            this._encoded = undefined;
			
 
				+            this._decoded = maybeSort(mappings, isString);
			
 
				+        }
			
 
				+        this._decodedMemo = memoizedState();
			
 
				+        this._bySources = undefined;
			
 
				+        this._bySourceMemos = undefined;
			
 
				+    }
			
 
				+}
			
 
				+(() => {
			
 
				+    encodedMappings = (map) => {
			
 
				+        var _a;
			
 
				+        return ((_a = map._encoded) !== null && _a !== void 0 ? _a : (map._encoded = encode(map._decoded)));
			
 
				+    };
			
 
				+    decodedMappings = (map) => {
			
 
				+        return (map._decoded || (map._decoded = decode(map._encoded)));
			
 
				+    };
			
 
				+    traceSegment = (map, line, column) => {
			
 
				+        const decoded = decodedMappings(map);
			
 
				+        // It's common for parent source maps to have pointers to lines that have no
			
 
				+        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
			
 
				+        if (line >= decoded.length)
			
 
				+            return null;
			
 
				+        const segments = decoded[line];
			
 
				+        const index = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
			
 
				+        return index === -1 ? null : segments[index];
			
 
				+    };
			
 
				+    originalPositionFor = (map, { line, column, bias }) => {
			
 
				+        line--;
			
 
				+        if (line < 0)
			
 
				+            throw new Error(LINE_GTR_ZERO);
			
 
				+        if (column < 0)
			
 
				+            throw new Error(COL_GTR_EQ_ZERO);
			
 
				+        const decoded = decodedMappings(map);
			
 
				+        // It's common for parent source maps to have pointers to lines that have no
			
 
				+        // mapping (like a "//# sourceMappingURL=") at the end of the child file.
			
 
				+        if (line >= decoded.length)
			
 
				+            return OMapping(null, null, null, null);
			
 
				+        const segments = decoded[line];
			
 
				+        const index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
			
 
				+        if (index === -1)
			
 
				+            return OMapping(null, null, null, null);
			
 
				+        const segment = segments[index];
			
 
				+        if (segment.length === 1)
			
 
				+            return OMapping(null, null, null, null);
			
 
				+        const { names, resolvedSources } = map;
			
 
				+        return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
			
 
				+    };
			
 
				+    allGeneratedPositionsFor = (map, { source, line, column, bias }) => {
			
 
				+        // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
			
 
				+        return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
			
 
				+    };
			
 
				+    generatedPositionFor = (map, { source, line, column, bias }) => {
			
 
				+        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
			
 
				+    };
			
 
				+    eachMapping = (map, cb) => {
			
 
				+        const decoded = decodedMappings(map);
			
 
				+        const { names, resolvedSources } = map;
			
 
				+        for (let i = 0; i < decoded.length; i++) {
			
 
				+            const line = decoded[i];
			
 
				+            for (let j = 0; j < line.length; j++) {
			
 
				+                const seg = line[j];
			
 
				+                const generatedLine = i + 1;
			
 
				+                const generatedColumn = seg[0];
			
 
				+                let source = null;
			
 
				+                let originalLine = null;
			
 
				+                let originalColumn = null;
			
 
				+                let name = null;
			
 
				+                if (seg.length !== 1) {
			
 
				+                    source = resolvedSources[seg[1]];
			
 
				+                    originalLine = seg[2] + 1;
			
 
				+                    originalColumn = seg[3];
			
 
				+                }
			
 
				+                if (seg.length === 5)
			
 
				+                    name = names[seg[4]];
			
 
				+                cb({
			
 
				+                    generatedLine,
			
 
				+                    generatedColumn,
			
 
				+                    source,
			
 
				+                    originalLine,
			
 
				+                    originalColumn,
			
 
				+                    name,
			
 
				+                });
			
 
				+            }
			
 
				+        }
			
 
				+    };
			
 
				+    sourceContentFor = (map, source) => {
			
 
				+        const { sources, resolvedSources, sourcesContent } = map;
			
 
				+        if (sourcesContent == null)
			
 
				+            return null;
			
 
				+        let index = sources.indexOf(source);
			
 
				+        if (index === -1)
			
 
				+            index = resolvedSources.indexOf(source);
			
 
				+        return index === -1 ? null : sourcesContent[index];
			
 
				+    };
			
 
				+    presortedDecodedMap = (map, mapUrl) => {
			
 
				+        const tracer = new TraceMap(clone(map, []), mapUrl);
			
 
				+        tracer._decoded = map.mappings;
			
 
				+        return tracer;
			
 
				+    };
			
 
				+    decodedMap = (map) => {
			
 
				+        return clone(map, decodedMappings(map));
			
 
				+    };
			
 
				+    encodedMap = (map) => {
			
 
				+        return clone(map, encodedMappings(map));
			
 
				+    };
			
 
				+    function generatedPosition(map, source, line, column, bias, all) {
			
 
				+        line--;
			
 
				+        if (line < 0)
			
 
				+            throw new Error(LINE_GTR_ZERO);
			
 
				+        if (column < 0)
			
 
				+            throw new Error(COL_GTR_EQ_ZERO);
			
 
				+        const { sources, resolvedSources } = map;
			
 
				+        let sourceIndex = sources.indexOf(source);
			
 
				+        if (sourceIndex === -1)
			
 
				+            sourceIndex = resolvedSources.indexOf(source);
			
 
				+        if (sourceIndex === -1)
			
 
				+            return all ? [] : GMapping(null, null);
			
 
				+        const generated = (map._bySources || (map._bySources = buildBySources(decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState)))));
			
 
				+        const segments = generated[sourceIndex][line];
			
 
				+        if (segments == null)
			
 
				+            return all ? [] : GMapping(null, null);
			
 
				+        const memo = map._bySourceMemos[sourceIndex];
			
 
				+        if (all)
			
 
				+            return sliceGeneratedPositions(segments, memo, line, column, bias);
			
 
				+        const index = traceSegmentInternal(segments, memo, line, column, bias);
			
 
				+        if (index === -1)
			
 
				+            return GMapping(null, null);
			
 
				+        const segment = segments[index];
			
 
				+        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
			
 
				+    }
			
 
				+})();
			
 
				+function clone(map, mappings) {
			
 
				+    return {
			
 
				+        version: map.version,
			
 
				+        file: map.file,
			
 
				+        names: map.names,
			
 
				+        sourceRoot: map.sourceRoot,
			
 
				+        sources: map.sources,
			
 
				+        sourcesContent: map.sourcesContent,
			
 
				+        mappings,
			
 
				+    };
			
 
				+}
			
 
				+function OMapping(source, line, column, name) {
			
 
				+    return { source, line, column, name };
			
 
				+}
			
 
				+function GMapping(line, column) {
			
 
				+    return { line, column };
			
 
				+}
			
 
				+function traceSegmentInternal(segments, memo, line, column, bias) {
			
 
				+    let index = memoizedBinarySearch(segments, column, memo, line);
			
 
				+    if (found) {
			
 
				+        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
			
 
				+    }
			
 
				+    else if (bias === LEAST_UPPER_BOUND)
			
 
				+        index++;
			
 
				+    if (index === -1 || index === segments.length)
			
 
				+        return -1;
			
 
				+    return index;
			
 
				+}
			
 
				+function sliceGeneratedPositions(segments, memo, line, column, bias) {
			
 
				+    let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
			
 
				+    // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
			
 
				+    // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
			
 
				+    // still need to call `lowerBound()` to find the first segment, which is slower than just looking
			
 
				+    // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
			
 
				+    // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
			
 
				+    // match LEAST_UPPER_BOUND.
			
 
				+    if (!found && bias === LEAST_UPPER_BOUND)
			
 
				+        min++;
			
 
				+    if (min === -1 || min === segments.length)
			
 
				+        return [];
			
 
				+    // We may have found the segment that started at an earlier column. If this is the case, then we
			
 
				+    // need to slice all generated segments that match _that_ column, because all such segments span
			
 
				+    // to our desired column.
			
 
				+    const matchedColumn = found ? column : segments[min][COLUMN];
			
 
				+    // The binary search is not guaranteed to find the lower bound when a match wasn't found.
			
 
				+    if (!found)
			
 
				+        min = lowerBound(segments, matchedColumn, min);
			
 
				+    const max = upperBound(segments, matchedColumn, min);
			
 
				+    const result = [];
			
 
				+    for (; min <= max; min++) {
			
 
				+        const segment = segments[min];
			
 
				+        result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
			
 
				+    }
			
 
				+    return result;
			
 
				+}
			
 
				+
			
 
				+export { AnyMap, GREATEST_LOWER_BOUND, LEAST_UPPER_BOUND, TraceMap, allGeneratedPositionsFor, decodedMap, decodedMappings, eachMapping, encodedMap, encodedMappings, generatedPositionFor, originalPositionFor, presortedDecodedMap, sourceContentFor, traceSegment };
			
 
				+//# sourceMappingURL=trace-mapping.mjs.map
			
--- a/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map
+++ b/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs.map
--- a/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
+++ b/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js
@@ -0,0 +1,566 @@
 
				+(function (global, factory) {
			
 
				+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@jridgewell/sourcemap-codec'), require('@jridgewell/resolve-uri')) :
			
 
				+    typeof define === 'function' && define.amd ? define(['exports', '@jridgewell/sourcemap-codec', '@jridgewell/resolve-uri'], factory) :
			
 
				+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.traceMapping = {}, global.sourcemapCodec, global.resolveURI));
			
 
				+})(this, (function (exports, sourcemapCodec, resolveUri) { 'use strict';
			
 
				+
			
 
				+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
			
 
				+
			
 
				+    var resolveUri__default = /*#__PURE__*/_interopDefaultLegacy(resolveUri);
			
 
				+
			
 
				+    function resolve(input, base) {
			
 
				+        // The base is always treated as a directory, if it's not empty.
			
 
				+        // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
			
 
				+        // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
			
 
				+        if (base && !base.endsWith('/'))
			
 
				+            base += '/';
			
 
				+        return resolveUri__default["default"](input, base);
			
 
				+    }
			
 
				+
			
 
				+    /**
			
 
				+     * Removes everything after the last "/", but leaves the slash.
			
 
				+     */
			
 
				+    function stripFilename(path) {
			
 
				+        if (!path)
			
 
				+            return '';
			
 
				+        const index = path.lastIndexOf('/');
			
 
				+        return path.slice(0, index + 1);
			
 
				+    }
			
 
				+
			
 
				+    const COLUMN = 0;
			
 
				+    const SOURCES_INDEX = 1;
			
 
				+    const SOURCE_LINE = 2;
			
 
				+    const SOURCE_COLUMN = 3;
			
 
				+    const NAMES_INDEX = 4;
			
 
				+    const REV_GENERATED_LINE = 1;
			
 
				+    const REV_GENERATED_COLUMN = 2;
			
 
				+
			
 
				+    function maybeSort(mappings, owned) {
			
 
				+        const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
			
 
				+        if (unsortedIndex === mappings.length)
			
 
				+            return mappings;
			
 
				+        // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
			
 
				+        // not, we do not want to modify the consumer's input array.
			
 
				+        if (!owned)
			
 
				+            mappings = mappings.slice();
			
 
				+        for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
			
 
				+            mappings[i] = sortSegments(mappings[i], owned);
			
 
				+        }
			
 
				+        return mappings;
			
 
				+    }
			
 
				+    function nextUnsortedSegmentLine(mappings, start) {
			
 
				+        for (let i = start; i < mappings.length; i++) {
			
 
				+            if (!isSorted(mappings[i]))
			
 
				+                return i;
			
 
				+        }
			
 
				+        return mappings.length;
			
 
				+    }
			
 
				+    function isSorted(line) {
			
 
				+        for (let j = 1; j < line.length; j++) {
			
 
				+            if (line[j][COLUMN] < line[j - 1][COLUMN]) {
			
 
				+                return false;
			
 
				+            }
			
 
				+        }
			
 
				+        return true;
			
 
				+    }
			
 
				+    function sortSegments(line, owned) {
			
 
				+        if (!owned)
			
 
				+            line = line.slice();
			
 
				+        return line.sort(sortComparator);
			
 
				+    }
			
 
				+    function sortComparator(a, b) {
			
 
				+        return a[COLUMN] - b[COLUMN];
			
 
				+    }
			
 
				+
			
 
				+    let found = false;
			
 
				+    /**
			
 
				+     * A binary search implementation that returns the index if a match is found.
			
 
				+     * If no match is found, then the left-index (the index associated with the item that comes just
			
 
				+     * before the desired index) is returned. To maintain proper sort order, a splice would happen at
			
 
				+     * the next index:
			
 
				+     *
			
 
				+     * ```js
			
 
				+     * const array = [1, 3];
			
 
				+     * const needle = 2;
			
 
				+     * const index = binarySearch(array, needle, (item, needle) => item - needle);
			
 
				+     *
			
 
				+     * assert.equal(index, 0);
			
 
				+     * array.splice(index + 1, 0, needle);
			
 
				+     * assert.deepEqual(array, [1, 2, 3]);
			
 
				+     * ```
			
 
				+     */
			
 
				+    function binarySearch(haystack, needle, low, high) {
			
 
				+        while (low <= high) {
			
 
				+            const mid = low + ((high - low) >> 1);
			
 
				+            const cmp = haystack[mid][COLUMN] - needle;
			
 
				+            if (cmp === 0) {
			
 
				+                found = true;
			
 
				+                return mid;
			
 
				+            }
			
 
				+            if (cmp < 0) {
			
 
				+                low = mid + 1;
			
 
				+            }
			
 
				+            else {
			
 
				+                high = mid - 1;
			
 
				+            }
			
 
				+        }
			
 
				+        found = false;
			
 
				+        return low - 1;
			
 
				+    }
			
 
				+    function upperBound(haystack, needle, index) {
			
 
				+        for (let i = index + 1; i < haystack.length; index = i++) {
			
 
				+            if (haystack[i][COLUMN] !== needle)
			
 
				+                break;
			
 
				+        }
			
 
				+        return index;
			
 
				+    }
			
 
				+    function lowerBound(haystack, needle, index) {
			
 
				+        for (let i = index - 1; i >= 0; index = i--) {
			
 
				+            if (haystack[i][COLUMN] !== needle)
			
 
				+                break;
			
 
				+        }
			
 
				+        return index;
			
 
				+    }
			
 
				+    function memoizedState() {
			
 
				+        return {
			
 
				+            lastKey: -1,
			
 
				+            lastNeedle: -1,
			
 
				+            lastIndex: -1,
			
 
				+        };
			
 
				+    }
			
 
				+    /**
			
 
				+     * This overly complicated beast is just to record the last tested line/column and the resulting
			
 
				+     * index, allowing us to skip a few tests if mappings are monotonically increasing.
			
 
				+     */
			
 
				+    function memoizedBinarySearch(haystack, needle, state, key) {
			
 
				+        const { lastKey, lastNeedle, lastIndex } = state;
			
 
				+        let low = 0;
			
 
				+        let high = haystack.length - 1;
			
 
				+        if (key === lastKey) {
			
 
				+            if (needle === lastNeedle) {
			
 
				+                found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
			
 
				+                return lastIndex;
			
 
				+            }
			
 
				+            if (needle >= lastNeedle) {
			
 
				+                // lastIndex may be -1 if the previous needle was not found.
			
 
				+                low = lastIndex === -1 ? 0 : lastIndex;
			
 
				+            }
			
 
				+            else {
			
 
				+                high = lastIndex;
			
 
				+            }
			
 
				+        }
			
 
				+        state.lastKey = key;
			
 
				+        state.lastNeedle = needle;
			
 
				+        return (state.lastIndex = binarySearch(haystack, needle, low, high));
			
 
				+    }
			
 
				+
			
 
				+    // Rebuilds the original source files, with mappings that are ordered by source line/column instead
			
 
				+    // of generated line/column.
			
 
				+    function buildBySources(decoded, memos) {
			
 
				+        const sources = memos.map(buildNullArray);
			
 
				+        for (let i = 0; i < decoded.length; i++) {
			
 
				+            const line = decoded[i];
			
 
				+            for (let j = 0; j < line.length; j++) {
			
 
				+                const seg = line[j];
			
 
				+                if (seg.length === 1)
			
 
				+                    continue;
			
 
				+                const sourceIndex = seg[SOURCES_INDEX];
			
 
				+                const sourceLine = seg[SOURCE_LINE];
			
 
				+                const sourceColumn = seg[SOURCE_COLUMN];
			
 
				+                const originalSource = sources[sourceIndex];
			
 
				+                const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
			
 
				+                const memo = memos[sourceIndex];
			
 
				+                // The binary search either found a match, or it found the left-index just before where the
			
 
				+                // segment should go. Either way, we want to insert after that. And there may be multiple
			
 
				+                // generated segments associated with an original location, so there may need to move several
			
 
				+                // indexes before we find where we need to insert.
			
 
				+                const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
			
 
				+                insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
			
 
				+            }
			
 
				+        }
			
 
				+        return sources;
			
 
				+    }
			
 
				+    function insert(array, index, value) {
			
 
				+        for (let i = array.length; i > index; i--) {
			
 
				+            array[i] = array[i - 1];
			
 
				+        }
			
 
				+        array[index] = value;
			
 
				+    }
			
 
				+    // Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
			
 
				+    // a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
			
 
				+    // Numeric properties on objects are magically sorted in ascending order by the engine regardless of
			
 
				+    // the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
			
 
				+    // order when iterating with for-in.
			
 
				+    function buildNullArray() {
			
 
				+        return { __proto__: null };
			
 
				+    }
			
 
				+
			
 
				+    const AnyMap = function (map, mapUrl) {
			
 
				+        const parsed = typeof map === 'string' ? JSON.parse(map) : map;
			
 
				+        if (!('sections' in parsed))
			
 
				+            return new TraceMap(parsed, mapUrl);
			
 
				+        const mappings = [];
			
 
				+        const sources = [];
			
 
				+        const sourcesContent = [];
			
 
				+        const names = [];
			
 
				+        recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
			
 
				+        const joined = {
			
 
				+            version: 3,
			
 
				+            file: parsed.file,
			
 
				+            names,
			
 
				+            sources,
			
 
				+            sourcesContent,
			
 
				+            mappings,
			
 
				+        };
			
 
				+        return exports.presortedDecodedMap(joined);
			
 
				+    };
			
 
				+    function recurse(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
			
 
				+        const { sections } = input;
			
 
				+        for (let i = 0; i < sections.length; i++) {
			
 
				+            const { map, offset } = sections[i];
			
 
				+            let sl = stopLine;
			
 
				+            let sc = stopColumn;
			
 
				+            if (i + 1 < sections.length) {
			
 
				+                const nextOffset = sections[i + 1].offset;
			
 
				+                sl = Math.min(stopLine, lineOffset + nextOffset.line);
			
 
				+                if (sl === stopLine) {
			
 
				+                    sc = Math.min(stopColumn, columnOffset + nextOffset.column);
			
 
				+                }
			
 
				+                else if (sl < stopLine) {
			
 
				+                    sc = columnOffset + nextOffset.column;
			
 
				+                }
			
 
				+            }
			
 
				+            addSection(map, mapUrl, mappings, sources, sourcesContent, names, lineOffset + offset.line, columnOffset + offset.column, sl, sc);
			
 
				+        }
			
 
				+    }
			
 
				+    function addSection(input, mapUrl, mappings, sources, sourcesContent, names, lineOffset, columnOffset, stopLine, stopColumn) {
			
 
				+        if ('sections' in input)
			
 
				+            return recurse(...arguments);
			
 
				+        const map = new TraceMap(input, mapUrl);
			
 
				+        const sourcesOffset = sources.length;
			
 
				+        const namesOffset = names.length;
			
 
				+        const decoded = exports.decodedMappings(map);
			
 
				+        const { resolvedSources, sourcesContent: contents } = map;
			
 
				+        append(sources, resolvedSources);
			
 
				+        append(names, map.names);
			
 
				+        if (contents)
			
 
				+            append(sourcesContent, contents);
			
 
				+        else
			
 
				+            for (let i = 0; i < resolvedSources.length; i++)
			
 
				+                sourcesContent.push(null);
			
 
				+        for (let i = 0; i < decoded.length; i++) {
			
 
				+            const lineI = lineOffset + i;
			
 
				+            // We can only add so many lines before we step into the range that the next section's map
			
 
				+            // controls. When we get to the last line, then we'll start checking the segments to see if
			
 
				+            // they've crossed into the column range. But it may not have any columns that overstep, so we
			
 
				+            // still need to check that we don't overstep lines, too.
			
 
				+            if (lineI > stopLine)
			
 
				+                return;
			
 
				+            // The out line may already exist in mappings (if we're continuing the line started by a
			
 
				+            // previous section). Or, we may have jumped ahead several lines to start this section.
			
 
				+            const out = getLine(mappings, lineI);
			
 
				+            // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
			
 
				+            // map can be multiple lines), it doesn't.
			
 
				+            const cOffset = i === 0 ? columnOffset : 0;
			
 
				+            const line = decoded[i];
			
 
				+            for (let j = 0; j < line.length; j++) {
			
 
				+                const seg = line[j];
			
 
				+                const column = cOffset + seg[COLUMN];
			
 
				+                // If this segment steps into the column range that the next section's map controls, we need
			
 
				+                // to stop early.
			
 
				+                if (lineI === stopLine && column >= stopColumn)
			
 
				+                    return;
			
 
				+                if (seg.length === 1) {
			
 
				+                    out.push([column]);
			
 
				+                    continue;
			
 
				+                }
			
 
				+                const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
			
 
				+                const sourceLine = seg[SOURCE_LINE];
			
 
				+                const sourceColumn = seg[SOURCE_COLUMN];
			
 
				+                out.push(seg.length === 4
			
 
				+                    ? [column, sourcesIndex, sourceLine, sourceColumn]
			
 
				+                    : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]]);
			
 
				+            }
			
 
				+        }
			
 
				+    }
			
 
				+    function append(arr, other) {
			
 
				+        for (let i = 0; i < other.length; i++)
			
 
				+            arr.push(other[i]);
			
 
				+    }
			
 
				+    function getLine(arr, index) {
			
 
				+        for (let i = arr.length; i <= index; i++)
			
 
				+            arr[i] = [];
			
 
				+        return arr[index];
			
 
				+    }
			
 
				+
			
 
				+    const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
			
 
				+    const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
			
 
				+    const LEAST_UPPER_BOUND = -1;
			
 
				+    const GREATEST_LOWER_BOUND = 1;
			
 
				+    /**
			
 
				+     * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
			
 
				+     */
			
 
				+    exports.encodedMappings = void 0;
			
 
				+    /**
			
 
				+     * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
			
 
				+     */
			
 
				+    exports.decodedMappings = void 0;
			
 
				+    /**
			
 
				+     * A low-level API to find the segment associated with a generated line/column (think, from a
			
 
				+     * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
			
 
				+     */
			
 
				+    exports.traceSegment = void 0;
			
 
				+    /**
			
 
				+     * A higher-level API to find the source/line/column associated with a generated line/column
			
 
				+     * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
			
 
				+     * `source-map` library.
			
 
				+     */
			
 
				+    exports.originalPositionFor = void 0;
			
 
				+    /**
			
 
				+     * Finds the generated line/column position of the provided source/line/column source position.
			
 
				+     */
			
 
				+    exports.generatedPositionFor = void 0;
			
 
				+    /**
			
 
				+     * Finds all generated line/column positions of the provided source/line/column source position.
			
 
				+     */
			
 
				+    exports.allGeneratedPositionsFor = void 0;
			
 
				+    /**
			
 
				+     * Iterates each mapping in generated position order.
			
 
				+     */
			
 
				+    exports.eachMapping = void 0;
			
 
				+    /**
			
 
				+     * Retrieves the source content for a particular source, if its found. Returns null if not.
			
 
				+     */
			
 
				+    exports.sourceContentFor = void 0;
			
 
				+    /**
			
 
				+     * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
			
 
				+     * maps.
			
 
				+     */
			
 
				+    exports.presortedDecodedMap = void 0;
			
 
				+    /**
			
 
				+     * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
			
 
				+     * a sourcemap, or to JSON.stringify.
			
 
				+     */
			
 
				+    exports.decodedMap = void 0;
			
 
				+    /**
			
 
				+     * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
			
 
				+     * a sourcemap, or to JSON.stringify.
			
 
				+     */
			
 
				+    exports.encodedMap = void 0;
			
 
				+    class TraceMap {
			
 
				+        constructor(map, mapUrl) {
			
 
				+            const isString = typeof map === 'string';
			
 
				+            if (!isString && map._decodedMemo)
			
 
				+                return map;
			
 
				+            const parsed = (isString ? JSON.parse(map) : map);
			
 
				+            const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
			
 
				+            this.version = version;
			
 
				+            this.file = file;
			
 
				+            this.names = names || [];
			
 
				+            this.sourceRoot = sourceRoot;
			
 
				+            this.sources = sources;
			
 
				+            this.sourcesContent = sourcesContent;
			
 
				+            const from = resolve(sourceRoot || '', stripFilename(mapUrl));
			
 
				+            this.resolvedSources = sources.map((s) => resolve(s || '', from));
			
 
				+            const { mappings } = parsed;
			
 
				+            if (typeof mappings === 'string') {
			
 
				+                this._encoded = mappings;
			
 
				+                this._decoded = undefined;
			
 
				+            }
			
 
				+            else {
			
 
				+                this._encoded = undefined;
			
 
				+                this._decoded = maybeSort(mappings, isString);
			
 
				+            }
			
 
				+            this._decodedMemo = memoizedState();
			
 
				+            this._bySources = undefined;
			
 
				+            this._bySourceMemos = undefined;
			
 
				+        }
			
 
				+    }
			
 
				+    (() => {
			
 
				+        exports.encodedMappings = (map) => {
			
 
				+            var _a;
			
 
				+            return ((_a = map._encoded) !== null && _a !== void 0 ? _a : (map._encoded = sourcemapCodec.encode(map._decoded)));
			
 
				+        };
			
 
				+        exports.decodedMappings = (map) => {
			
 
				+            return (map._decoded || (map._decoded = sourcemapCodec.decode(map._encoded)));
			
 
				+        };
			
 
				+        exports.traceSegment = (map, line, column) => {
			
 
				+            const decoded = exports.decodedMappings(map);
			
 
				+            // It's common for parent source maps to have pointers to lines that have no
			
 
				+            // mapping (like a "//# sourceMappingURL=") at the end of the child file.
			
 
				+            if (line >= decoded.length)
			
 
				+                return null;
			
 
				+            const segments = decoded[line];
			
 
				+            const index = traceSegmentInternal(segments, map._decodedMemo, line, column, GREATEST_LOWER_BOUND);
			
 
				+            return index === -1 ? null : segments[index];
			
 
				+        };
			
 
				+        exports.originalPositionFor = (map, { line, column, bias }) => {
			
 
				+            line--;
			
 
				+            if (line < 0)
			
 
				+                throw new Error(LINE_GTR_ZERO);
			
 
				+            if (column < 0)
			
 
				+                throw new Error(COL_GTR_EQ_ZERO);
			
 
				+            const decoded = exports.decodedMappings(map);
			
 
				+            // It's common for parent source maps to have pointers to lines that have no
			
 
				+            // mapping (like a "//# sourceMappingURL=") at the end of the child file.
			
 
				+            if (line >= decoded.length)
			
 
				+                return OMapping(null, null, null, null);
			
 
				+            const segments = decoded[line];
			
 
				+            const index = traceSegmentInternal(segments, map._decodedMemo, line, column, bias || GREATEST_LOWER_BOUND);
			
 
				+            if (index === -1)
			
 
				+                return OMapping(null, null, null, null);
			
 
				+            const segment = segments[index];
			
 
				+            if (segment.length === 1)
			
 
				+                return OMapping(null, null, null, null);
			
 
				+            const { names, resolvedSources } = map;
			
 
				+            return OMapping(resolvedSources[segment[SOURCES_INDEX]], segment[SOURCE_LINE] + 1, segment[SOURCE_COLUMN], segment.length === 5 ? names[segment[NAMES_INDEX]] : null);
			
 
				+        };
			
 
				+        exports.allGeneratedPositionsFor = (map, { source, line, column, bias }) => {
			
 
				+            // SourceMapConsumer uses LEAST_UPPER_BOUND for some reason, so we follow suit.
			
 
				+            return generatedPosition(map, source, line, column, bias || LEAST_UPPER_BOUND, true);
			
 
				+        };
			
 
				+        exports.generatedPositionFor = (map, { source, line, column, bias }) => {
			
 
				+            return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
			
 
				+        };
			
 
				+        exports.eachMapping = (map, cb) => {
			
 
				+            const decoded = exports.decodedMappings(map);
			
 
				+            const { names, resolvedSources } = map;
			
 
				+            for (let i = 0; i < decoded.length; i++) {
			
 
				+                const line = decoded[i];
			
 
				+                for (let j = 0; j < line.length; j++) {
			
 
				+                    const seg = line[j];
			
 
				+                    const generatedLine = i + 1;
			
 
				+                    const generatedColumn = seg[0];
			
 
				+                    let source = null;
			
 
				+                    let originalLine = null;
			
 
				+                    let originalColumn = null;
			
 
				+                    let name = null;
			
 
				+                    if (seg.length !== 1) {
			
 
				+                        source = resolvedSources[seg[1]];
			
 
				+                        originalLine = seg[2] + 1;
			
 
				+                        originalColumn = seg[3];
			
 
				+                    }
			
 
				+                    if (seg.length === 5)
			
 
				+                        name = names[seg[4]];
			
 
				+                    cb({
			
 
				+                        generatedLine,
			
 
				+                        generatedColumn,
			
 
				+                        source,
			
 
				+                        originalLine,
			
 
				+                        originalColumn,
			
 
				+                        name,
			
 
				+                    });
			
 
				+                }
			
 
				+            }
			
 
				+        };
			
 
				+        exports.sourceContentFor = (map, source) => {
			
 
				+            const { sources, resolvedSources, sourcesContent } = map;
			
 
				+            if (sourcesContent == null)
			
 
				+                return null;
			
 
				+            let index = sources.indexOf(source);
			
 
				+            if (index === -1)
			
 
				+                index = resolvedSources.indexOf(source);
			
 
				+            return index === -1 ? null : sourcesContent[index];
			
 
				+        };
			
 
				+        exports.presortedDecodedMap = (map, mapUrl) => {
			
 
				+            const tracer = new TraceMap(clone(map, []), mapUrl);
			
 
				+            tracer._decoded = map.mappings;
			
 
				+            return tracer;
			
 
				+        };
			
 
				+        exports.decodedMap = (map) => {
			
 
				+            return clone(map, exports.decodedMappings(map));
			
 
				+        };
			
 
				+        exports.encodedMap = (map) => {
			
 
				+            return clone(map, exports.encodedMappings(map));
			
 
				+        };
			
 
				+        function generatedPosition(map, source, line, column, bias, all) {
			
 
				+            line--;
			
 
				+            if (line < 0)
			
 
				+                throw new Error(LINE_GTR_ZERO);
			
 
				+            if (column < 0)
			
 
				+                throw new Error(COL_GTR_EQ_ZERO);
			
 
				+            const { sources, resolvedSources } = map;
			
 
				+            let sourceIndex = sources.indexOf(source);
			
 
				+            if (sourceIndex === -1)
			
 
				+                sourceIndex = resolvedSources.indexOf(source);
			
 
				+            if (sourceIndex === -1)
			
 
				+                return all ? [] : GMapping(null, null);
			
 
				+            const generated = (map._bySources || (map._bySources = buildBySources(exports.decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState)))));
			
 
				+            const segments = generated[sourceIndex][line];
			
 
				+            if (segments == null)
			
 
				+                return all ? [] : GMapping(null, null);
			
 
				+            const memo = map._bySourceMemos[sourceIndex];
			
 
				+            if (all)
			
 
				+                return sliceGeneratedPositions(segments, memo, line, column, bias);
			
 
				+            const index = traceSegmentInternal(segments, memo, line, column, bias);
			
 
				+            if (index === -1)
			
 
				+                return GMapping(null, null);
			
 
				+            const segment = segments[index];
			
 
				+            return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
			
 
				+        }
			
 
				+    })();
			
 
				+    function clone(map, mappings) {
			
 
				+        return {
			
 
				+            version: map.version,
			
 
				+            file: map.file,
			
 
				+            names: map.names,
			
 
				+            sourceRoot: map.sourceRoot,
			
 
				+            sources: map.sources,
			
 
				+            sourcesContent: map.sourcesContent,
			
 
				+            mappings,
			
 
				+        };
			
 
				+    }
			
 
				+    function OMapping(source, line, column, name) {
			
 
				+        return { source, line, column, name };
			
 
				+    }
			
 
				+    function GMapping(line, column) {
			
 
				+        return { line, column };
			
 
				+    }
			
 
				+    function traceSegmentInternal(segments, memo, line, column, bias) {
			
 
				+        let index = memoizedBinarySearch(segments, column, memo, line);
			
 
				+        if (found) {
			
 
				+            index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
			
 
				+        }
			
 
				+        else if (bias === LEAST_UPPER_BOUND)
			
 
				+            index++;
			
 
				+        if (index === -1 || index === segments.length)
			
 
				+            return -1;
			
 
				+        return index;
			
 
				+    }
			
 
				+    function sliceGeneratedPositions(segments, memo, line, column, bias) {
			
 
				+        let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
			
 
				+        // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
			
 
				+        // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
			
 
				+        // still need to call `lowerBound()` to find the first segment, which is slower than just looking
			
 
				+        // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
			
 
				+        // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
			
 
				+        // match LEAST_UPPER_BOUND.
			
 
				+        if (!found && bias === LEAST_UPPER_BOUND)
			
 
				+            min++;
			
 
				+        if (min === -1 || min === segments.length)
			
 
				+            return [];
			
 
				+        // We may have found the segment that started at an earlier column. If this is the case, then we
			
 
				+        // need to slice all generated segments that match _that_ column, because all such segments span
			
 
				+        // to our desired column.
			
 
				+        const matchedColumn = found ? column : segments[min][COLUMN];
			
 
				+        // The binary search is not guaranteed to find the lower bound when a match wasn't found.
			
 
				+        if (!found)
			
 
				+            min = lowerBound(segments, matchedColumn, min);
			
 
				+        const max = upperBound(segments, matchedColumn, min);
			
 
				+        const result = [];
			
 
				+        for (; min <= max; min++) {
			
 
				+            const segment = segments[min];
			
 
				+            result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
			
 
				+        }
			
 
				+        return result;
			
 
				+    }
			
 
				+
			
 
				+    exports.AnyMap = AnyMap;
			
 
				+    exports.GREATEST_LOWER_BOUND = GREATEST_LOWER_BOUND;
			
 
				+    exports.LEAST_UPPER_BOUND = LEAST_UPPER_BOUND;
			
 
				+    exports.TraceMap = TraceMap;
			
 
				+
			
 
				+    Object.defineProperty(exports, '__esModule', { value: true });
			
 
				+
			
 
				+}));
			
 
				+//# sourceMappingURL=trace-mapping.umd.js.map
			
--- a/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map
+++ b/day37/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.umd.js.map
--- a/day37/node_modules/@jridgewell/trace-mapping/dist/types/any-map.d.ts
+++ b/day37/node_modules/@jridgewell/trace-mapping/dist/types/any-map.d.ts
@@ -0,0 +1,8 @@
 
				+import { TraceMap } from './trace-mapping';
			
 
				+import type { SectionedSourceMapInput } from './types';
			
 
				+declare type AnyMap = {
			
 
				+    new (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
			
 
				+    (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
			
 
				+};
			
 
				+export declare const AnyMap: AnyMap;
			
 
				+export {};
		`@@ -0,0 +1 @@`
		`+console.log("a1页面"),(()=>{"use strict";sayHi()})();`
		`@@ -0,0 +1 @@`
		`+module.exports = require('util').TextDecoder;`
		`@@ -0,0 +1 @@`
		`+module.exports = require('../package.json').version;`