1 ヶ月前 · 9c8b71d9c0
--- a/ui/index.html
+++ b/ui/index.html
@@ -0,0 +1,14 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+  <head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <link rel="icon" type="image/svg+xml" href="/vite.svg">
			
 
				+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
			
 
				+    <title>领存智贸 AI - 外贸AI原生CRM</title>
			
 
				+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css">
			
 
				+  </head>
			
 
				+  <body>
			
 
				+    <div id="app"></div>
			
 
				+    <script type="module" src="/src/main.js"></script>
			
 
				+  </body>
			
 
				+</html>
			
--- a/ui/node_modules/.bin/esbuild
+++ b/ui/node_modules/.bin/esbuild
@@ -0,0 +1,16 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*|*MINGW*|*MSYS*)
			
 
				+        if command -v cygpath > /dev/null 2>&1; then
			
 
				+            basedir=`cygpath -w "$basedir"`
			
 
				+        fi
			
 
				+    ;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  exec "$basedir/node"  "$basedir/../esbuild/bin/esbuild" "$@"
			
 
				+else 
			
 
				+  exec node  "$basedir/../esbuild/bin/esbuild" "$@"
			
 
				+fi
			
--- a/ui/node_modules/.bin/esbuild.cmd
+++ b/ui/node_modules/.bin/esbuild.cmd
@@ -0,0 +1,17 @@
 
				+@ECHO off
			
 
				+GOTO start
			
 
				+:find_dp0
			
 
				+SET dp0=%~dp0
			
 
				+EXIT /b
			
 
				+:start
			
 
				+SETLOCAL
			
 
				+CALL :find_dp0
			
 
				+
			
 
				+IF EXIST "%dp0%\node.exe" (
			
 
				+  SET "_prog=%dp0%\node.exe"
			
 
				+) ELSE (
			
 
				+  SET "_prog=node"
			
 
				+  SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+)
			
 
				+
			
 
				+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\esbuild\bin\esbuild" %*
			
--- a/ui/node_modules/.bin/esbuild.ps1
+++ b/ui/node_modules/.bin/esbuild.ps1
@@ -0,0 +1,28 @@
 
				+#!/usr/bin/env pwsh
			
 
				+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
			
 
				+
			
 
				+$exe=""
			
 
				+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
			
 
				+  # Fix case when both the Windows and Linux builds of Node
			
 
				+  # are installed in the same directory
			
 
				+  $exe=".exe"
			
 
				+}
			
 
				+$ret=0
			
 
				+if (Test-Path "$basedir/node$exe") {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "$basedir/node$exe"  "$basedir/../esbuild/bin/esbuild" $args
			
 
				+  } else {
			
 
				+    & "$basedir/node$exe"  "$basedir/../esbuild/bin/esbuild" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+} else {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "node$exe"  "$basedir/../esbuild/bin/esbuild" $args
			
 
				+  } else {
			
 
				+    & "node$exe"  "$basedir/../esbuild/bin/esbuild" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+}
			
 
				+exit $ret
			
--- a/ui/node_modules/.bin/nanoid
+++ b/ui/node_modules/.bin/nanoid
@@ -0,0 +1,16 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*|*MINGW*|*MSYS*)
			
 
				+        if command -v cygpath > /dev/null 2>&1; then
			
 
				+            basedir=`cygpath -w "$basedir"`
			
 
				+        fi
			
 
				+    ;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  exec "$basedir/node"  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
			
 
				+else 
			
 
				+  exec node  "$basedir/../nanoid/bin/nanoid.cjs" "$@"
			
 
				+fi
			
--- a/ui/node_modules/.bin/nanoid.cmd
+++ b/ui/node_modules/.bin/nanoid.cmd
@@ -0,0 +1,17 @@
 
				+@ECHO off
			
 
				+GOTO start
			
 
				+:find_dp0
			
 
				+SET dp0=%~dp0
			
 
				+EXIT /b
			
 
				+:start
			
 
				+SETLOCAL
			
 
				+CALL :find_dp0
			
 
				+
			
 
				+IF EXIST "%dp0%\node.exe" (
			
 
				+  SET "_prog=%dp0%\node.exe"
			
 
				+) ELSE (
			
 
				+  SET "_prog=node"
			
 
				+  SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+)
			
 
				+
			
 
				+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\nanoid\bin\nanoid.cjs" %*
			
--- a/ui/node_modules/.bin/nanoid.ps1
+++ b/ui/node_modules/.bin/nanoid.ps1
@@ -0,0 +1,28 @@
 
				+#!/usr/bin/env pwsh
			
 
				+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
			
 
				+
			
 
				+$exe=""
			
 
				+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
			
 
				+  # Fix case when both the Windows and Linux builds of Node
			
 
				+  # are installed in the same directory
			
 
				+  $exe=".exe"
			
 
				+}
			
 
				+$ret=0
			
 
				+if (Test-Path "$basedir/node$exe") {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
			
 
				+  } else {
			
 
				+    & "$basedir/node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+} else {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
			
 
				+  } else {
			
 
				+    & "node$exe"  "$basedir/../nanoid/bin/nanoid.cjs" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+}
			
 
				+exit $ret
			
--- a/ui/node_modules/.bin/parser
+++ b/ui/node_modules/.bin/parser
@@ -0,0 +1,16 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*|*MINGW*|*MSYS*)
			
 
				+        if command -v cygpath > /dev/null 2>&1; then
			
 
				+            basedir=`cygpath -w "$basedir"`
			
 
				+        fi
			
 
				+    ;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  exec "$basedir/node"  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
			
 
				+else 
			
 
				+  exec node  "$basedir/../@babel/parser/bin/babel-parser.js" "$@"
			
 
				+fi
			
--- a/ui/node_modules/.bin/parser.cmd
+++ b/ui/node_modules/.bin/parser.cmd
@@ -0,0 +1,17 @@
 
				+@ECHO off
			
 
				+GOTO start
			
 
				+:find_dp0
			
 
				+SET dp0=%~dp0
			
 
				+EXIT /b
			
 
				+:start
			
 
				+SETLOCAL
			
 
				+CALL :find_dp0
			
 
				+
			
 
				+IF EXIST "%dp0%\node.exe" (
			
 
				+  SET "_prog=%dp0%\node.exe"
			
 
				+) ELSE (
			
 
				+  SET "_prog=node"
			
 
				+  SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+)
			
 
				+
			
 
				+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\@babel\parser\bin\babel-parser.js" %*
			
--- a/ui/node_modules/.bin/parser.ps1
+++ b/ui/node_modules/.bin/parser.ps1
@@ -0,0 +1,28 @@
 
				+#!/usr/bin/env pwsh
			
 
				+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
			
 
				+
			
 
				+$exe=""
			
 
				+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
			
 
				+  # Fix case when both the Windows and Linux builds of Node
			
 
				+  # are installed in the same directory
			
 
				+  $exe=".exe"
			
 
				+}
			
 
				+$ret=0
			
 
				+if (Test-Path "$basedir/node$exe") {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "$basedir/node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
			
 
				+  } else {
			
 
				+    & "$basedir/node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+} else {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
			
 
				+  } else {
			
 
				+    & "node$exe"  "$basedir/../@babel/parser/bin/babel-parser.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+}
			
 
				+exit $ret
			
--- a/ui/node_modules/.bin/rollup
+++ b/ui/node_modules/.bin/rollup
@@ -0,0 +1,16 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*|*MINGW*|*MSYS*)
			
 
				+        if command -v cygpath > /dev/null 2>&1; then
			
 
				+            basedir=`cygpath -w "$basedir"`
			
 
				+        fi
			
 
				+    ;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  exec "$basedir/node"  "$basedir/../rollup/dist/bin/rollup" "$@"
			
 
				+else 
			
 
				+  exec node  "$basedir/../rollup/dist/bin/rollup" "$@"
			
 
				+fi
			
--- a/ui/node_modules/.bin/rollup.cmd
+++ b/ui/node_modules/.bin/rollup.cmd
@@ -0,0 +1,17 @@
 
				+@ECHO off
			
 
				+GOTO start
			
 
				+:find_dp0
			
 
				+SET dp0=%~dp0
			
 
				+EXIT /b
			
 
				+:start
			
 
				+SETLOCAL
			
 
				+CALL :find_dp0
			
 
				+
			
 
				+IF EXIST "%dp0%\node.exe" (
			
 
				+  SET "_prog=%dp0%\node.exe"
			
 
				+) ELSE (
			
 
				+  SET "_prog=node"
			
 
				+  SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+)
			
 
				+
			
 
				+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\rollup\dist\bin\rollup" %*
			
--- a/ui/node_modules/.bin/rollup.ps1
+++ b/ui/node_modules/.bin/rollup.ps1
@@ -0,0 +1,28 @@
 
				+#!/usr/bin/env pwsh
			
 
				+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
			
 
				+
			
 
				+$exe=""
			
 
				+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
			
 
				+  # Fix case when both the Windows and Linux builds of Node
			
 
				+  # are installed in the same directory
			
 
				+  $exe=".exe"
			
 
				+}
			
 
				+$ret=0
			
 
				+if (Test-Path "$basedir/node$exe") {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "$basedir/node$exe"  "$basedir/../rollup/dist/bin/rollup" $args
			
 
				+  } else {
			
 
				+    & "$basedir/node$exe"  "$basedir/../rollup/dist/bin/rollup" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+} else {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "node$exe"  "$basedir/../rollup/dist/bin/rollup" $args
			
 
				+  } else {
			
 
				+    & "node$exe"  "$basedir/../rollup/dist/bin/rollup" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+}
			
 
				+exit $ret
			
--- a/ui/node_modules/.bin/vite
+++ b/ui/node_modules/.bin/vite
@@ -0,0 +1,16 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*|*MINGW*|*MSYS*)
			
 
				+        if command -v cygpath > /dev/null 2>&1; then
			
 
				+            basedir=`cygpath -w "$basedir"`
			
 
				+        fi
			
 
				+    ;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  exec "$basedir/node"  "$basedir/../vite/bin/vite.js" "$@"
			
 
				+else 
			
 
				+  exec node  "$basedir/../vite/bin/vite.js" "$@"
			
 
				+fi
			
--- a/ui/node_modules/.bin/vite.cmd
+++ b/ui/node_modules/.bin/vite.cmd
@@ -0,0 +1,17 @@
 
				+@ECHO off
			
 
				+GOTO start
			
 
				+:find_dp0
			
 
				+SET dp0=%~dp0
			
 
				+EXIT /b
			
 
				+:start
			
 
				+SETLOCAL
			
 
				+CALL :find_dp0
			
 
				+
			
 
				+IF EXIST "%dp0%\node.exe" (
			
 
				+  SET "_prog=%dp0%\node.exe"
			
 
				+) ELSE (
			
 
				+  SET "_prog=node"
			
 
				+  SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+)
			
 
				+
			
 
				+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\vite\bin\vite.js" %*
			
--- a/ui/node_modules/.bin/vite.ps1
+++ b/ui/node_modules/.bin/vite.ps1
@@ -0,0 +1,28 @@
 
				+#!/usr/bin/env pwsh
			
 
				+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
			
 
				+
			
 
				+$exe=""
			
 
				+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
			
 
				+  # Fix case when both the Windows and Linux builds of Node
			
 
				+  # are installed in the same directory
			
 
				+  $exe=".exe"
			
 
				+}
			
 
				+$ret=0
			
 
				+if (Test-Path "$basedir/node$exe") {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "$basedir/node$exe"  "$basedir/../vite/bin/vite.js" $args
			
 
				+  } else {
			
 
				+    & "$basedir/node$exe"  "$basedir/../vite/bin/vite.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+} else {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "node$exe"  "$basedir/../vite/bin/vite.js" $args
			
 
				+  } else {
			
 
				+    & "node$exe"  "$basedir/../vite/bin/vite.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+}
			
 
				+exit $ret
			
--- a/ui/node_modules/.bin/vue-demi-fix
+++ b/ui/node_modules/.bin/vue-demi-fix
@@ -0,0 +1,16 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*|*MINGW*|*MSYS*)
			
 
				+        if command -v cygpath > /dev/null 2>&1; then
			
 
				+            basedir=`cygpath -w "$basedir"`
			
 
				+        fi
			
 
				+    ;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  exec "$basedir/node"  "$basedir/../vue-demi/bin/vue-demi-fix.js" "$@"
			
 
				+else 
			
 
				+  exec node  "$basedir/../vue-demi/bin/vue-demi-fix.js" "$@"
			
 
				+fi
			
--- a/ui/node_modules/.bin/vue-demi-fix.cmd
+++ b/ui/node_modules/.bin/vue-demi-fix.cmd
@@ -0,0 +1,17 @@
 
				+@ECHO off
			
 
				+GOTO start
			
 
				+:find_dp0
			
 
				+SET dp0=%~dp0
			
 
				+EXIT /b
			
 
				+:start
			
 
				+SETLOCAL
			
 
				+CALL :find_dp0
			
 
				+
			
 
				+IF EXIST "%dp0%\node.exe" (
			
 
				+  SET "_prog=%dp0%\node.exe"
			
 
				+) ELSE (
			
 
				+  SET "_prog=node"
			
 
				+  SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+)
			
 
				+
			
 
				+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\vue-demi\bin\vue-demi-fix.js" %*
			
--- a/ui/node_modules/.bin/vue-demi-fix.ps1
+++ b/ui/node_modules/.bin/vue-demi-fix.ps1
@@ -0,0 +1,28 @@
 
				+#!/usr/bin/env pwsh
			
 
				+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
			
 
				+
			
 
				+$exe=""
			
 
				+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
			
 
				+  # Fix case when both the Windows and Linux builds of Node
			
 
				+  # are installed in the same directory
			
 
				+  $exe=".exe"
			
 
				+}
			
 
				+$ret=0
			
 
				+if (Test-Path "$basedir/node$exe") {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "$basedir/node$exe"  "$basedir/../vue-demi/bin/vue-demi-fix.js" $args
			
 
				+  } else {
			
 
				+    & "$basedir/node$exe"  "$basedir/../vue-demi/bin/vue-demi-fix.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+} else {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "node$exe"  "$basedir/../vue-demi/bin/vue-demi-fix.js" $args
			
 
				+  } else {
			
 
				+    & "node$exe"  "$basedir/../vue-demi/bin/vue-demi-fix.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+}
			
 
				+exit $ret
			
--- a/ui/node_modules/.bin/vue-demi-switch
+++ b/ui/node_modules/.bin/vue-demi-switch
@@ -0,0 +1,16 @@
 
				+#!/bin/sh
			
 
				+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
			
 
				+
			
 
				+case `uname` in
			
 
				+    *CYGWIN*|*MINGW*|*MSYS*)
			
 
				+        if command -v cygpath > /dev/null 2>&1; then
			
 
				+            basedir=`cygpath -w "$basedir"`
			
 
				+        fi
			
 
				+    ;;
			
 
				+esac
			
 
				+
			
 
				+if [ -x "$basedir/node" ]; then
			
 
				+  exec "$basedir/node"  "$basedir/../vue-demi/bin/vue-demi-switch.js" "$@"
			
 
				+else 
			
 
				+  exec node  "$basedir/../vue-demi/bin/vue-demi-switch.js" "$@"
			
 
				+fi
			
--- a/ui/node_modules/.bin/vue-demi-switch.cmd
+++ b/ui/node_modules/.bin/vue-demi-switch.cmd
@@ -0,0 +1,17 @@
 
				+@ECHO off
			
 
				+GOTO start
			
 
				+:find_dp0
			
 
				+SET dp0=%~dp0
			
 
				+EXIT /b
			
 
				+:start
			
 
				+SETLOCAL
			
 
				+CALL :find_dp0
			
 
				+
			
 
				+IF EXIST "%dp0%\node.exe" (
			
 
				+  SET "_prog=%dp0%\node.exe"
			
 
				+) ELSE (
			
 
				+  SET "_prog=node"
			
 
				+  SET PATHEXT=%PATHEXT:;.JS;=;%
			
 
				+)
			
 
				+
			
 
				+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\..\vue-demi\bin\vue-demi-switch.js" %*
			
--- a/ui/node_modules/.bin/vue-demi-switch.ps1
+++ b/ui/node_modules/.bin/vue-demi-switch.ps1
@@ -0,0 +1,28 @@
 
				+#!/usr/bin/env pwsh
			
 
				+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
			
 
				+
			
 
				+$exe=""
			
 
				+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
			
 
				+  # Fix case when both the Windows and Linux builds of Node
			
 
				+  # are installed in the same directory
			
 
				+  $exe=".exe"
			
 
				+}
			
 
				+$ret=0
			
 
				+if (Test-Path "$basedir/node$exe") {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "$basedir/node$exe"  "$basedir/../vue-demi/bin/vue-demi-switch.js" $args
			
 
				+  } else {
			
 
				+    & "$basedir/node$exe"  "$basedir/../vue-demi/bin/vue-demi-switch.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+} else {
			
 
				+  # Support pipeline input
			
 
				+  if ($MyInvocation.ExpectingInput) {
			
 
				+    $input | & "node$exe"  "$basedir/../vue-demi/bin/vue-demi-switch.js" $args
			
 
				+  } else {
			
 
				+    & "node$exe"  "$basedir/../vue-demi/bin/vue-demi-switch.js" $args
			
 
				+  }
			
 
				+  $ret=$LASTEXITCODE
			
 
				+}
			
 
				+exit $ret
			
--- a/ui/node_modules/.package-lock.json
+++ b/ui/node_modules/.package-lock.json
@@ -0,0 +1,563 @@
 
				+{
			
 
				+  "name": "tradebrain-crm",
			
 
				+  "version": "1.0.0",
			
 
				+  "lockfileVersion": 3,
			
 
				+  "requires": true,
			
 
				+  "packages": {
			
 
				+    "node_modules/@babel/helper-string-parser": {
			
 
				+      "version": "7.27.1",
			
 
				+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
			
 
				+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
			
 
				+      "license": "MIT",
			
 
				+      "engines": {
			
 
				+        "node": ">=6.9.0"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@babel/helper-validator-identifier": {
			
 
				+      "version": "7.28.5",
			
 
				+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
			
 
				+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
			
 
				+      "license": "MIT",
			
 
				+      "engines": {
			
 
				+        "node": ">=6.9.0"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@babel/parser": {
			
 
				+      "version": "7.29.2",
			
 
				+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
			
 
				+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@babel/types": "^7.29.0"
			
 
				+      },
			
 
				+      "bin": {
			
 
				+        "parser": "bin/babel-parser.js"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": ">=6.0.0"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@babel/types": {
			
 
				+      "version": "7.29.0",
			
 
				+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
			
 
				+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@babel/helper-string-parser": "^7.27.1",
			
 
				+        "@babel/helper-validator-identifier": "^7.28.5"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": ">=6.9.0"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@esbuild/win32-x64": {
			
 
				+      "version": "0.21.5",
			
 
				+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
			
 
				+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
			
 
				+      "cpu": [
			
 
				+        "x64"
			
 
				+      ],
			
 
				+      "dev": true,
			
 
				+      "license": "MIT",
			
 
				+      "optional": true,
			
 
				+      "os": [
			
 
				+        "win32"
			
 
				+      ],
			
 
				+      "engines": {
			
 
				+        "node": ">=12"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@fortawesome/fontawesome-free": {
			
 
				+      "version": "6.7.2",
			
 
				+      "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-free/-/fontawesome-free-6.7.2.tgz",
			
 
				+      "integrity": "sha512-JUOtgFW6k9u4Y+xeIaEiLr3+cjoUPiAuLXoyKOJSia6Duzb7pq+A76P9ZdPDoAoxHdHzq6gE9/jKBGXlZT8FbA==",
			
 
				+      "license": "(CC-BY-4.0 AND OFL-1.1 AND MIT)",
			
 
				+      "engines": {
			
 
				+        "node": ">=6"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@jridgewell/sourcemap-codec": {
			
 
				+      "version": "1.5.5",
			
 
				+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
			
 
				+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
			
 
				+      "license": "MIT"
			
 
				+    },
			
 
				+    "node_modules/@rollup/rollup-win32-x64-gnu": {
			
 
				+      "version": "4.59.0",
			
 
				+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz",
			
 
				+      "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==",
			
 
				+      "cpu": [
			
 
				+        "x64"
			
 
				+      ],
			
 
				+      "dev": true,
			
 
				+      "license": "MIT",
			
 
				+      "optional": true,
			
 
				+      "os": [
			
 
				+        "win32"
			
 
				+      ]
			
 
				+    },
			
 
				+    "node_modules/@rollup/rollup-win32-x64-msvc": {
			
 
				+      "version": "4.59.0",
			
 
				+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz",
			
 
				+      "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==",
			
 
				+      "cpu": [
			
 
				+        "x64"
			
 
				+      ],
			
 
				+      "dev": true,
			
 
				+      "license": "MIT",
			
 
				+      "optional": true,
			
 
				+      "os": [
			
 
				+        "win32"
			
 
				+      ]
			
 
				+    },
			
 
				+    "node_modules/@types/estree": {
			
 
				+      "version": "1.0.8",
			
 
				+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
			
 
				+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
			
 
				+      "dev": true,
			
 
				+      "license": "MIT"
			
 
				+    },
			
 
				+    "node_modules/@vitejs/plugin-vue": {
			
 
				+      "version": "5.2.4",
			
 
				+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz",
			
 
				+      "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==",
			
 
				+      "dev": true,
			
 
				+      "license": "MIT",
			
 
				+      "engines": {
			
 
				+        "node": "^18.0.0 || >=20.0.0"
			
 
				+      },
			
 
				+      "peerDependencies": {
			
 
				+        "vite": "^5.0.0 || ^6.0.0",
			
 
				+        "vue": "^3.2.25"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/compiler-core": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.30.tgz",
			
 
				+      "integrity": "sha512-s3DfdZkcu/qExZ+td75015ljzHc6vE+30cFMGRPROYjqkroYI5NV2X1yAMX9UeyBNWB9MxCfPcsjpLS11nzkkw==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@babel/parser": "^7.29.0",
			
 
				+        "@vue/shared": "3.5.30",
			
 
				+        "entities": "^7.0.1",
			
 
				+        "estree-walker": "^2.0.2",
			
 
				+        "source-map-js": "^1.2.1"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/compiler-dom": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.30.tgz",
			
 
				+      "integrity": "sha512-eCFYESUEVYHhiMuK4SQTldO3RYxyMR/UQL4KdGD1Yrkfdx4m/HYuZ9jSfPdA+nWJY34VWndiYdW/wZXyiPEB9g==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/compiler-core": "3.5.30",
			
 
				+        "@vue/shared": "3.5.30"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/compiler-sfc": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.30.tgz",
			
 
				+      "integrity": "sha512-LqmFPDn89dtU9vI3wHJnwaV6GfTRD87AjWpTWpyrdVOObVtjIuSeZr181z5C4PmVx/V3j2p+0f7edFKGRMpQ5A==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@babel/parser": "^7.29.0",
			
 
				+        "@vue/compiler-core": "3.5.30",
			
 
				+        "@vue/compiler-dom": "3.5.30",
			
 
				+        "@vue/compiler-ssr": "3.5.30",
			
 
				+        "@vue/shared": "3.5.30",
			
 
				+        "estree-walker": "^2.0.2",
			
 
				+        "magic-string": "^0.30.21",
			
 
				+        "postcss": "^8.5.8",
			
 
				+        "source-map-js": "^1.2.1"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/compiler-ssr": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.30.tgz",
			
 
				+      "integrity": "sha512-NsYK6OMTnx109PSL2IAyf62JP6EUdk4Dmj6AkWcJGBvN0dQoMYtVekAmdqgTtWQgEJo+Okstbf/1p7qZr5H+bA==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/compiler-dom": "3.5.30",
			
 
				+        "@vue/shared": "3.5.30"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/devtools-api": {
			
 
				+      "version": "6.6.4",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.4.tgz",
			
 
				+      "integrity": "sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==",
			
 
				+      "license": "MIT"
			
 
				+    },
			
 
				+    "node_modules/@vue/reactivity": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.30.tgz",
			
 
				+      "integrity": "sha512-179YNgKATuwj9gB+66snskRDOitDiuOZqkYia7mHKJaidOMo/WJxHKF8DuGc4V4XbYTJANlfEKb0yxTQotnx4Q==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/shared": "3.5.30"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/runtime-core": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.30.tgz",
			
 
				+      "integrity": "sha512-e0Z+8PQsUTdwV8TtEsLzUM7SzC7lQwYKePydb7K2ZnmS6jjND+WJXkmmfh/swYzRyfP1EY3fpdesyYoymCzYfg==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/reactivity": "3.5.30",
			
 
				+        "@vue/shared": "3.5.30"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/runtime-dom": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.30.tgz",
			
 
				+      "integrity": "sha512-2UIGakjU4WSQ0T4iwDEW0W7vQj6n7AFn7taqZ9Cvm0Q/RA2FFOziLESrDL4GmtI1wV3jXg5nMoJSYO66egDUBw==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/reactivity": "3.5.30",
			
 
				+        "@vue/runtime-core": "3.5.30",
			
 
				+        "@vue/shared": "3.5.30",
			
 
				+        "csstype": "^3.2.3"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/server-renderer": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.30.tgz",
			
 
				+      "integrity": "sha512-v+R34icapydRwbZRD0sXwtHqrQJv38JuMB4JxbOxd8NEpGLny7cncMp53W9UH/zo4j8eDHjQ1dEJXwzFQknjtQ==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/compiler-ssr": "3.5.30",
			
 
				+        "@vue/shared": "3.5.30"
			
 
				+      },
			
 
				+      "peerDependencies": {
			
 
				+        "vue": "3.5.30"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/@vue/shared": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.30.tgz",
			
 
				+      "integrity": "sha512-YXgQ7JjaO18NeK2K9VTbDHaFy62WrObMa6XERNfNOkAhD1F1oDSf3ZJ7K6GqabZ0BvSDHajp8qfS5Sa2I9n8uQ==",
			
 
				+      "license": "MIT"
			
 
				+    },
			
 
				+    "node_modules/csstype": {
			
 
				+      "version": "3.2.3",
			
 
				+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
			
 
				+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
			
 
				+      "license": "MIT"
			
 
				+    },
			
 
				+    "node_modules/entities": {
			
 
				+      "version": "7.0.1",
			
 
				+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
			
 
				+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
			
 
				+      "license": "BSD-2-Clause",
			
 
				+      "engines": {
			
 
				+        "node": ">=0.12"
			
 
				+      },
			
 
				+      "funding": {
			
 
				+        "url": "https://github.com/fb55/entities?sponsor=1"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/esbuild": {
			
 
				+      "version": "0.21.5",
			
 
				+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
			
 
				+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
			
 
				+      "dev": true,
			
 
				+      "hasInstallScript": true,
			
 
				+      "license": "MIT",
			
 
				+      "bin": {
			
 
				+        "esbuild": "bin/esbuild"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": ">=12"
			
 
				+      },
			
 
				+      "optionalDependencies": {
			
 
				+        "@esbuild/aix-ppc64": "0.21.5",
			
 
				+        "@esbuild/android-arm": "0.21.5",
			
 
				+        "@esbuild/android-arm64": "0.21.5",
			
 
				+        "@esbuild/android-x64": "0.21.5",
			
 
				+        "@esbuild/darwin-arm64": "0.21.5",
			
 
				+        "@esbuild/darwin-x64": "0.21.5",
			
 
				+        "@esbuild/freebsd-arm64": "0.21.5",
			
 
				+        "@esbuild/freebsd-x64": "0.21.5",
			
 
				+        "@esbuild/linux-arm": "0.21.5",
			
 
				+        "@esbuild/linux-arm64": "0.21.5",
			
 
				+        "@esbuild/linux-ia32": "0.21.5",
			
 
				+        "@esbuild/linux-loong64": "0.21.5",
			
 
				+        "@esbuild/linux-mips64el": "0.21.5",
			
 
				+        "@esbuild/linux-ppc64": "0.21.5",
			
 
				+        "@esbuild/linux-riscv64": "0.21.5",
			
 
				+        "@esbuild/linux-s390x": "0.21.5",
			
 
				+        "@esbuild/linux-x64": "0.21.5",
			
 
				+        "@esbuild/netbsd-x64": "0.21.5",
			
 
				+        "@esbuild/openbsd-x64": "0.21.5",
			
 
				+        "@esbuild/sunos-x64": "0.21.5",
			
 
				+        "@esbuild/win32-arm64": "0.21.5",
			
 
				+        "@esbuild/win32-ia32": "0.21.5",
			
 
				+        "@esbuild/win32-x64": "0.21.5"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/estree-walker": {
			
 
				+      "version": "2.0.2",
			
 
				+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
			
 
				+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
			
 
				+      "license": "MIT"
			
 
				+    },
			
 
				+    "node_modules/magic-string": {
			
 
				+      "version": "0.30.21",
			
 
				+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
			
 
				+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@jridgewell/sourcemap-codec": "^1.5.5"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/nanoid": {
			
 
				+      "version": "3.3.11",
			
 
				+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
			
 
				+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
			
 
				+      "funding": [
			
 
				+        {
			
 
				+          "type": "github",
			
 
				+          "url": "https://github.com/sponsors/ai"
			
 
				+        }
			
 
				+      ],
			
 
				+      "license": "MIT",
			
 
				+      "bin": {
			
 
				+        "nanoid": "bin/nanoid.cjs"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/picocolors": {
			
 
				+      "version": "1.1.1",
			
 
				+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
			
 
				+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
			
 
				+      "license": "ISC"
			
 
				+    },
			
 
				+    "node_modules/pinia": {
			
 
				+      "version": "2.3.1",
			
 
				+      "resolved": "https://registry.npmjs.org/pinia/-/pinia-2.3.1.tgz",
			
 
				+      "integrity": "sha512-khUlZSwt9xXCaTbbxFYBKDc/bWAGWJjOgvxETwkTN7KRm66EeT1ZdZj6i2ceh9sP2Pzqsbc704r2yngBrxBVug==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/devtools-api": "^6.6.3",
			
 
				+        "vue-demi": "^0.14.10"
			
 
				+      },
			
 
				+      "funding": {
			
 
				+        "url": "https://github.com/sponsors/posva"
			
 
				+      },
			
 
				+      "peerDependencies": {
			
 
				+        "typescript": ">=4.4.4",
			
 
				+        "vue": "^2.7.0 || ^3.5.11"
			
 
				+      },
			
 
				+      "peerDependenciesMeta": {
			
 
				+        "typescript": {
			
 
				+          "optional": true
			
 
				+        }
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/postcss": {
			
 
				+      "version": "8.5.8",
			
 
				+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
			
 
				+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
			
 
				+      "funding": [
			
 
				+        {
			
 
				+          "type": "opencollective",
			
 
				+          "url": "https://opencollective.com/postcss/"
			
 
				+        },
			
 
				+        {
			
 
				+          "type": "tidelift",
			
 
				+          "url": "https://tidelift.com/funding/github/npm/postcss"
			
 
				+        },
			
 
				+        {
			
 
				+          "type": "github",
			
 
				+          "url": "https://github.com/sponsors/ai"
			
 
				+        }
			
 
				+      ],
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "nanoid": "^3.3.11",
			
 
				+        "picocolors": "^1.1.1",
			
 
				+        "source-map-js": "^1.2.1"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": "^10 || ^12 || >=14"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/rollup": {
			
 
				+      "version": "4.59.0",
			
 
				+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
			
 
				+      "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
			
 
				+      "dev": true,
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@types/estree": "1.0.8"
			
 
				+      },
			
 
				+      "bin": {
			
 
				+        "rollup": "dist/bin/rollup"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": ">=18.0.0",
			
 
				+        "npm": ">=8.0.0"
			
 
				+      },
			
 
				+      "optionalDependencies": {
			
 
				+        "@rollup/rollup-android-arm-eabi": "4.59.0",
			
 
				+        "@rollup/rollup-android-arm64": "4.59.0",
			
 
				+        "@rollup/rollup-darwin-arm64": "4.59.0",
			
 
				+        "@rollup/rollup-darwin-x64": "4.59.0",
			
 
				+        "@rollup/rollup-freebsd-arm64": "4.59.0",
			
 
				+        "@rollup/rollup-freebsd-x64": "4.59.0",
			
 
				+        "@rollup/rollup-linux-arm-gnueabihf": "4.59.0",
			
 
				+        "@rollup/rollup-linux-arm-musleabihf": "4.59.0",
			
 
				+        "@rollup/rollup-linux-arm64-gnu": "4.59.0",
			
 
				+        "@rollup/rollup-linux-arm64-musl": "4.59.0",
			
 
				+        "@rollup/rollup-linux-loong64-gnu": "4.59.0",
			
 
				+        "@rollup/rollup-linux-loong64-musl": "4.59.0",
			
 
				+        "@rollup/rollup-linux-ppc64-gnu": "4.59.0",
			
 
				+        "@rollup/rollup-linux-ppc64-musl": "4.59.0",
			
 
				+        "@rollup/rollup-linux-riscv64-gnu": "4.59.0",
			
 
				+        "@rollup/rollup-linux-riscv64-musl": "4.59.0",
			
 
				+        "@rollup/rollup-linux-s390x-gnu": "4.59.0",
			
 
				+        "@rollup/rollup-linux-x64-gnu": "4.59.0",
			
 
				+        "@rollup/rollup-linux-x64-musl": "4.59.0",
			
 
				+        "@rollup/rollup-openbsd-x64": "4.59.0",
			
 
				+        "@rollup/rollup-openharmony-arm64": "4.59.0",
			
 
				+        "@rollup/rollup-win32-arm64-msvc": "4.59.0",
			
 
				+        "@rollup/rollup-win32-ia32-msvc": "4.59.0",
			
 
				+        "@rollup/rollup-win32-x64-gnu": "4.59.0",
			
 
				+        "@rollup/rollup-win32-x64-msvc": "4.59.0",
			
 
				+        "fsevents": "~2.3.2"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/source-map-js": {
			
 
				+      "version": "1.2.1",
			
 
				+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
			
 
				+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
			
 
				+      "license": "BSD-3-Clause",
			
 
				+      "engines": {
			
 
				+        "node": ">=0.10.0"
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/vite": {
			
 
				+      "version": "5.4.21",
			
 
				+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
			
 
				+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
			
 
				+      "dev": true,
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "esbuild": "^0.21.3",
			
 
				+        "postcss": "^8.4.43",
			
 
				+        "rollup": "^4.20.0"
			
 
				+      },
			
 
				+      "bin": {
			
 
				+        "vite": "bin/vite.js"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": "^18.0.0 || >=20.0.0"
			
 
				+      },
			
 
				+      "funding": {
			
 
				+        "url": "https://github.com/vitejs/vite?sponsor=1"
			
 
				+      },
			
 
				+      "optionalDependencies": {
			
 
				+        "fsevents": "~2.3.3"
			
 
				+      },
			
 
				+      "peerDependencies": {
			
 
				+        "@types/node": "^18.0.0 || >=20.0.0",
			
 
				+        "less": "*",
			
 
				+        "lightningcss": "^1.21.0",
			
 
				+        "sass": "*",
			
 
				+        "sass-embedded": "*",
			
 
				+        "stylus": "*",
			
 
				+        "sugarss": "*",
			
 
				+        "terser": "^5.4.0"
			
 
				+      },
			
 
				+      "peerDependenciesMeta": {
			
 
				+        "@types/node": {
			
 
				+          "optional": true
			
 
				+        },
			
 
				+        "less": {
			
 
				+          "optional": true
			
 
				+        },
			
 
				+        "lightningcss": {
			
 
				+          "optional": true
			
 
				+        },
			
 
				+        "sass": {
			
 
				+          "optional": true
			
 
				+        },
			
 
				+        "sass-embedded": {
			
 
				+          "optional": true
			
 
				+        },
			
 
				+        "stylus": {
			
 
				+          "optional": true
			
 
				+        },
			
 
				+        "sugarss": {
			
 
				+          "optional": true
			
 
				+        },
			
 
				+        "terser": {
			
 
				+          "optional": true
			
 
				+        }
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/vue": {
			
 
				+      "version": "3.5.30",
			
 
				+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.30.tgz",
			
 
				+      "integrity": "sha512-hTHLc6VNZyzzEH/l7PFGjpcTvUgiaPK5mdLkbjrTeWSRcEfxFrv56g/XckIYlE9ckuobsdwqd5mk2g1sBkMewg==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/compiler-dom": "3.5.30",
			
 
				+        "@vue/compiler-sfc": "3.5.30",
			
 
				+        "@vue/runtime-dom": "3.5.30",
			
 
				+        "@vue/server-renderer": "3.5.30",
			
 
				+        "@vue/shared": "3.5.30"
			
 
				+      },
			
 
				+      "peerDependencies": {
			
 
				+        "typescript": "*"
			
 
				+      },
			
 
				+      "peerDependenciesMeta": {
			
 
				+        "typescript": {
			
 
				+          "optional": true
			
 
				+        }
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/vue-demi": {
			
 
				+      "version": "0.14.10",
			
 
				+      "resolved": "https://registry.npmjs.org/vue-demi/-/vue-demi-0.14.10.tgz",
			
 
				+      "integrity": "sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg==",
			
 
				+      "hasInstallScript": true,
			
 
				+      "license": "MIT",
			
 
				+      "bin": {
			
 
				+        "vue-demi-fix": "bin/vue-demi-fix.js",
			
 
				+        "vue-demi-switch": "bin/vue-demi-switch.js"
			
 
				+      },
			
 
				+      "engines": {
			
 
				+        "node": ">=12"
			
 
				+      },
			
 
				+      "funding": {
			
 
				+        "url": "https://github.com/sponsors/antfu"
			
 
				+      },
			
 
				+      "peerDependencies": {
			
 
				+        "@vue/composition-api": "^1.0.0-rc.1",
			
 
				+        "vue": "^3.0.0-0 || ^2.6.0"
			
 
				+      },
			
 
				+      "peerDependenciesMeta": {
			
 
				+        "@vue/composition-api": {
			
 
				+          "optional": true
			
 
				+        }
			
 
				+      }
			
 
				+    },
			
 
				+    "node_modules/vue-router": {
			
 
				+      "version": "4.6.4",
			
 
				+      "resolved": "https://registry.npmjs.org/vue-router/-/vue-router-4.6.4.tgz",
			
 
				+      "integrity": "sha512-Hz9q5sa33Yhduglwz6g9skT8OBPii+4bFn88w6J+J4MfEo4KRRpmiNG/hHHkdbRFlLBOqxN8y8gf2Fb0MTUgVg==",
			
 
				+      "license": "MIT",
			
 
				+      "dependencies": {
			
 
				+        "@vue/devtools-api": "^6.6.4"
			
 
				+      },
			
 
				+      "funding": {
			
 
				+        "url": "https://github.com/sponsors/posva"
			
 
				+      },
			
 
				+      "peerDependencies": {
			
 
				+        "vue": "^3.5.0"
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+}
			
--- a/ui/node_modules/.vite/deps/_metadata.json
+++ b/ui/node_modules/.vite/deps/_metadata.json
@@ -0,0 +1,34 @@
 
				+{
			
 
				+  "hash": "3c57bbcc",
			
 
				+  "configHash": "5ddb0565",
			
 
				+  "lockfileHash": "9b422b68",
			
 
				+  "browserHash": "2e6e1045",
			
 
				+  "optimized": {
			
 
				+    "pinia": {
			
 
				+      "src": "../../pinia/dist/pinia.mjs",
			
 
				+      "file": "pinia.js",
			
 
				+      "fileHash": "2b70e06f",
			
 
				+      "needsInterop": false
			
 
				+    },
			
 
				+    "vue": {
			
 
				+      "src": "../../vue/dist/vue.runtime.esm-bundler.js",
			
 
				+      "file": "vue.js",
			
 
				+      "fileHash": "4e039d40",
			
 
				+      "needsInterop": false
			
 
				+    },
			
 
				+    "vue-router": {
			
 
				+      "src": "../../vue-router/dist/vue-router.mjs",
			
 
				+      "file": "vue-router.js",
			
 
				+      "fileHash": "d8cc8131",
			
 
				+      "needsInterop": false
			
 
				+    }
			
 
				+  },
			
 
				+  "chunks": {
			
 
				+    "chunk-YFT6OQ5R": {
			
 
				+      "file": "chunk-YFT6OQ5R.js"
			
 
				+    },
			
 
				+    "chunk-ZIH63DMU": {
			
 
				+      "file": "chunk-ZIH63DMU.js"
			
 
				+    }
			
 
				+  }
			
 
				+}
			
--- a/ui/node_modules/.vite/deps/chunk-YFT6OQ5R.js
+++ b/ui/node_modules/.vite/deps/chunk-YFT6OQ5R.js
@@ -0,0 +1,162 @@
 
				+// node_modules/@vue/devtools-api/lib/esm/env.js
			
 
				+function getDevtoolsGlobalHook() {
			
 
				+  return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
			
 
				+}
			
 
				+function getTarget() {
			
 
				+  return typeof navigator !== "undefined" && typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : {};
			
 
				+}
			
 
				+var isProxyAvailable = typeof Proxy === "function";
			
 
				+
			
 
				+// node_modules/@vue/devtools-api/lib/esm/const.js
			
 
				+var HOOK_SETUP = "devtools-plugin:setup";
			
 
				+var HOOK_PLUGIN_SETTINGS_SET = "plugin:settings:set";
			
 
				+
			
 
				+// node_modules/@vue/devtools-api/lib/esm/time.js
			
 
				+var supported;
			
 
				+var perf;
			
 
				+function isPerformanceSupported() {
			
 
				+  var _a;
			
 
				+  if (supported !== void 0) {
			
 
				+    return supported;
			
 
				+  }
			
 
				+  if (typeof window !== "undefined" && window.performance) {
			
 
				+    supported = true;
			
 
				+    perf = window.performance;
			
 
				+  } else if (typeof globalThis !== "undefined" && ((_a = globalThis.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
			
 
				+    supported = true;
			
 
				+    perf = globalThis.perf_hooks.performance;
			
 
				+  } else {
			
 
				+    supported = false;
			
 
				+  }
			
 
				+  return supported;
			
 
				+}
			
 
				+function now() {
			
 
				+  return isPerformanceSupported() ? perf.now() : Date.now();
			
 
				+}
			
 
				+
			
 
				+// node_modules/@vue/devtools-api/lib/esm/proxy.js
			
 
				+var ApiProxy = class {
			
 
				+  constructor(plugin, hook) {
			
 
				+    this.target = null;
			
 
				+    this.targetQueue = [];
			
 
				+    this.onQueue = [];
			
 
				+    this.plugin = plugin;
			
 
				+    this.hook = hook;
			
 
				+    const defaultSettings = {};
			
 
				+    if (plugin.settings) {
			
 
				+      for (const id in plugin.settings) {
			
 
				+        const item = plugin.settings[id];
			
 
				+        defaultSettings[id] = item.defaultValue;
			
 
				+      }
			
 
				+    }
			
 
				+    const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
			
 
				+    let currentSettings = Object.assign({}, defaultSettings);
			
 
				+    try {
			
 
				+      const raw = localStorage.getItem(localSettingsSaveId);
			
 
				+      const data = JSON.parse(raw);
			
 
				+      Object.assign(currentSettings, data);
			
 
				+    } catch (e) {
			
 
				+    }
			
 
				+    this.fallbacks = {
			
 
				+      getSettings() {
			
 
				+        return currentSettings;
			
 
				+      },
			
 
				+      setSettings(value) {
			
 
				+        try {
			
 
				+          localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
			
 
				+        } catch (e) {
			
 
				+        }
			
 
				+        currentSettings = value;
			
 
				+      },
			
 
				+      now() {
			
 
				+        return now();
			
 
				+      }
			
 
				+    };
			
 
				+    if (hook) {
			
 
				+      hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
			
 
				+        if (pluginId === this.plugin.id) {
			
 
				+          this.fallbacks.setSettings(value);
			
 
				+        }
			
 
				+      });
			
 
				+    }
			
 
				+    this.proxiedOn = new Proxy({}, {
			
 
				+      get: (_target, prop) => {
			
 
				+        if (this.target) {
			
 
				+          return this.target.on[prop];
			
 
				+        } else {
			
 
				+          return (...args) => {
			
 
				+            this.onQueue.push({
			
 
				+              method: prop,
			
 
				+              args
			
 
				+            });
			
 
				+          };
			
 
				+        }
			
 
				+      }
			
 
				+    });
			
 
				+    this.proxiedTarget = new Proxy({}, {
			
 
				+      get: (_target, prop) => {
			
 
				+        if (this.target) {
			
 
				+          return this.target[prop];
			
 
				+        } else if (prop === "on") {
			
 
				+          return this.proxiedOn;
			
 
				+        } else if (Object.keys(this.fallbacks).includes(prop)) {
			
 
				+          return (...args) => {
			
 
				+            this.targetQueue.push({
			
 
				+              method: prop,
			
 
				+              args,
			
 
				+              resolve: () => {
			
 
				+              }
			
 
				+            });
			
 
				+            return this.fallbacks[prop](...args);
			
 
				+          };
			
 
				+        } else {
			
 
				+          return (...args) => {
			
 
				+            return new Promise((resolve) => {
			
 
				+              this.targetQueue.push({
			
 
				+                method: prop,
			
 
				+                args,
			
 
				+                resolve
			
 
				+              });
			
 
				+            });
			
 
				+          };
			
 
				+        }
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+  async setRealTarget(target) {
			
 
				+    this.target = target;
			
 
				+    for (const item of this.onQueue) {
			
 
				+      this.target.on[item.method](...item.args);
			
 
				+    }
			
 
				+    for (const item of this.targetQueue) {
			
 
				+      item.resolve(await this.target[item.method](...item.args));
			
 
				+    }
			
 
				+  }
			
 
				+};
			
 
				+
			
 
				+// node_modules/@vue/devtools-api/lib/esm/index.js
			
 
				+function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
			
 
				+  const descriptor = pluginDescriptor;
			
 
				+  const target = getTarget();
			
 
				+  const hook = getDevtoolsGlobalHook();
			
 
				+  const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;
			
 
				+  if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
			
 
				+    hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
			
 
				+  } else {
			
 
				+    const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;
			
 
				+    const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
			
 
				+    list.push({
			
 
				+      pluginDescriptor: descriptor,
			
 
				+      setupFn,
			
 
				+      proxy
			
 
				+    });
			
 
				+    if (proxy) {
			
 
				+      setupFn(proxy.proxiedTarget);
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+export {
			
 
				+  setupDevtoolsPlugin
			
 
				+};
			
 
				+//# sourceMappingURL=chunk-YFT6OQ5R.js.map
			
--- a/ui/node_modules/.vite/deps/chunk-YFT6OQ5R.js.map
+++ b/ui/node_modules/.vite/deps/chunk-YFT6OQ5R.js.map
--- a/ui/node_modules/.vite/deps/chunk-ZIH63DMU.js
+++ b/ui/node_modules/.vite/deps/chunk-ZIH63DMU.js
--- a/ui/node_modules/.vite/deps/chunk-ZIH63DMU.js.map
+++ b/ui/node_modules/.vite/deps/chunk-ZIH63DMU.js.map
--- a/ui/node_modules/.vite/deps/package.json
+++ b/ui/node_modules/.vite/deps/package.json
@@ -0,0 +1,3 @@
 
				+{
			
 
				+  "type": "module"
			
 
				+}
			
--- a/ui/node_modules/.vite/deps/pinia.js
+++ b/ui/node_modules/.vite/deps/pinia.js
@@ -0,0 +1,1560 @@
 
				+import {
			
 
				+  setupDevtoolsPlugin
			
 
				+} from "./chunk-YFT6OQ5R.js";
			
 
				+import {
			
 
				+  computed,
			
 
				+  effectScope,
			
 
				+  getCurrentInstance,
			
 
				+  getCurrentScope,
			
 
				+  hasInjectionContext,
			
 
				+  inject,
			
 
				+  isReactive,
			
 
				+  isRef,
			
 
				+  markRaw,
			
 
				+  nextTick,
			
 
				+  onScopeDispose,
			
 
				+  reactive,
			
 
				+  ref,
			
 
				+  toRaw,
			
 
				+  toRef,
			
 
				+  toRefs,
			
 
				+  unref,
			
 
				+  watch
			
 
				+} from "./chunk-ZIH63DMU.js";
			
 
				+
			
 
				+// node_modules/vue-demi/lib/index.mjs
			
 
				+var isVue2 = false;
			
 
				+function set(target, key, val) {
			
 
				+  if (Array.isArray(target)) {
			
 
				+    target.length = Math.max(target.length, key);
			
 
				+    target.splice(key, 1, val);
			
 
				+    return val;
			
 
				+  }
			
 
				+  target[key] = val;
			
 
				+  return val;
			
 
				+}
			
 
				+function del(target, key) {
			
 
				+  if (Array.isArray(target)) {
			
 
				+    target.splice(key, 1);
			
 
				+    return;
			
 
				+  }
			
 
				+  delete target[key];
			
 
				+}
			
 
				+
			
 
				+// node_modules/pinia/dist/pinia.mjs
			
 
				+var activePinia;
			
 
				+var setActivePinia = (pinia) => activePinia = pinia;
			
 
				+var getActivePinia = () => hasInjectionContext() && inject(piniaSymbol) || activePinia;
			
 
				+var piniaSymbol = true ? Symbol("pinia") : (
			
 
				+  /* istanbul ignore next */
			
 
				+  Symbol()
			
 
				+);
			
 
				+function isPlainObject(o) {
			
 
				+  return o && typeof o === "object" && Object.prototype.toString.call(o) === "[object Object]" && typeof o.toJSON !== "function";
			
 
				+}
			
 
				+var MutationType;
			
 
				+(function(MutationType2) {
			
 
				+  MutationType2["direct"] = "direct";
			
 
				+  MutationType2["patchObject"] = "patch object";
			
 
				+  MutationType2["patchFunction"] = "patch function";
			
 
				+})(MutationType || (MutationType = {}));
			
 
				+var IS_CLIENT = typeof window !== "undefined";
			
 
				+var _global = (() => typeof window === "object" && window.window === window ? window : typeof self === "object" && self.self === self ? self : typeof global === "object" && global.global === global ? global : typeof globalThis === "object" ? globalThis : { HTMLElement: null })();
			
 
				+function bom(blob, { autoBom = false } = {}) {
			
 
				+  if (autoBom && /^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
			
 
				+    return new Blob([String.fromCharCode(65279), blob], { type: blob.type });
			
 
				+  }
			
 
				+  return blob;
			
 
				+}
			
 
				+function download(url, name, opts) {
			
 
				+  const xhr = new XMLHttpRequest();
			
 
				+  xhr.open("GET", url);
			
 
				+  xhr.responseType = "blob";
			
 
				+  xhr.onload = function() {
			
 
				+    saveAs(xhr.response, name, opts);
			
 
				+  };
			
 
				+  xhr.onerror = function() {
			
 
				+    console.error("could not download file");
			
 
				+  };
			
 
				+  xhr.send();
			
 
				+}
			
 
				+function corsEnabled(url) {
			
 
				+  const xhr = new XMLHttpRequest();
			
 
				+  xhr.open("HEAD", url, false);
			
 
				+  try {
			
 
				+    xhr.send();
			
 
				+  } catch (e) {
			
 
				+  }
			
 
				+  return xhr.status >= 200 && xhr.status <= 299;
			
 
				+}
			
 
				+function click(node) {
			
 
				+  try {
			
 
				+    node.dispatchEvent(new MouseEvent("click"));
			
 
				+  } catch (e) {
			
 
				+    const evt = document.createEvent("MouseEvents");
			
 
				+    evt.initMouseEvent("click", true, true, window, 0, 0, 0, 80, 20, false, false, false, false, 0, null);
			
 
				+    node.dispatchEvent(evt);
			
 
				+  }
			
 
				+}
			
 
				+var _navigator = typeof navigator === "object" ? navigator : { userAgent: "" };
			
 
				+var isMacOSWebView = (() => /Macintosh/.test(_navigator.userAgent) && /AppleWebKit/.test(_navigator.userAgent) && !/Safari/.test(_navigator.userAgent))();
			
 
				+var saveAs = !IS_CLIENT ? () => {
			
 
				+} : (
			
 
				+  // Use download attribute first if possible (#193 Lumia mobile) unless this is a macOS WebView or mini program
			
 
				+  typeof HTMLAnchorElement !== "undefined" && "download" in HTMLAnchorElement.prototype && !isMacOSWebView ? downloadSaveAs : (
			
 
				+    // Use msSaveOrOpenBlob as a second approach
			
 
				+    "msSaveOrOpenBlob" in _navigator ? msSaveAs : (
			
 
				+      // Fallback to using FileReader and a popup
			
 
				+      fileSaverSaveAs
			
 
				+    )
			
 
				+  )
			
 
				+);
			
 
				+function downloadSaveAs(blob, name = "download", opts) {
			
 
				+  const a = document.createElement("a");
			
 
				+  a.download = name;
			
 
				+  a.rel = "noopener";
			
 
				+  if (typeof blob === "string") {
			
 
				+    a.href = blob;
			
 
				+    if (a.origin !== location.origin) {
			
 
				+      if (corsEnabled(a.href)) {
			
 
				+        download(blob, name, opts);
			
 
				+      } else {
			
 
				+        a.target = "_blank";
			
 
				+        click(a);
			
 
				+      }
			
 
				+    } else {
			
 
				+      click(a);
			
 
				+    }
			
 
				+  } else {
			
 
				+    a.href = URL.createObjectURL(blob);
			
 
				+    setTimeout(function() {
			
 
				+      URL.revokeObjectURL(a.href);
			
 
				+    }, 4e4);
			
 
				+    setTimeout(function() {
			
 
				+      click(a);
			
 
				+    }, 0);
			
 
				+  }
			
 
				+}
			
 
				+function msSaveAs(blob, name = "download", opts) {
			
 
				+  if (typeof blob === "string") {
			
 
				+    if (corsEnabled(blob)) {
			
 
				+      download(blob, name, opts);
			
 
				+    } else {
			
 
				+      const a = document.createElement("a");
			
 
				+      a.href = blob;
			
 
				+      a.target = "_blank";
			
 
				+      setTimeout(function() {
			
 
				+        click(a);
			
 
				+      });
			
 
				+    }
			
 
				+  } else {
			
 
				+    navigator.msSaveOrOpenBlob(bom(blob, opts), name);
			
 
				+  }
			
 
				+}
			
 
				+function fileSaverSaveAs(blob, name, opts, popup) {
			
 
				+  popup = popup || open("", "_blank");
			
 
				+  if (popup) {
			
 
				+    popup.document.title = popup.document.body.innerText = "downloading...";
			
 
				+  }
			
 
				+  if (typeof blob === "string")
			
 
				+    return download(blob, name, opts);
			
 
				+  const force = blob.type === "application/octet-stream";
			
 
				+  const isSafari = /constructor/i.test(String(_global.HTMLElement)) || "safari" in _global;
			
 
				+  const isChromeIOS = /CriOS\/[\d]+/.test(navigator.userAgent);
			
 
				+  if ((isChromeIOS || force && isSafari || isMacOSWebView) && typeof FileReader !== "undefined") {
			
 
				+    const reader = new FileReader();
			
 
				+    reader.onloadend = function() {
			
 
				+      let url = reader.result;
			
 
				+      if (typeof url !== "string") {
			
 
				+        popup = null;
			
 
				+        throw new Error("Wrong reader.result type");
			
 
				+      }
			
 
				+      url = isChromeIOS ? url : url.replace(/^data:[^;]*;/, "data:attachment/file;");
			
 
				+      if (popup) {
			
 
				+        popup.location.href = url;
			
 
				+      } else {
			
 
				+        location.assign(url);
			
 
				+      }
			
 
				+      popup = null;
			
 
				+    };
			
 
				+    reader.readAsDataURL(blob);
			
 
				+  } else {
			
 
				+    const url = URL.createObjectURL(blob);
			
 
				+    if (popup)
			
 
				+      popup.location.assign(url);
			
 
				+    else
			
 
				+      location.href = url;
			
 
				+    popup = null;
			
 
				+    setTimeout(function() {
			
 
				+      URL.revokeObjectURL(url);
			
 
				+    }, 4e4);
			
 
				+  }
			
 
				+}
			
 
				+function toastMessage(message, type) {
			
 
				+  const piniaMessage = "🍍 " + message;
			
 
				+  if (typeof __VUE_DEVTOOLS_TOAST__ === "function") {
			
 
				+    __VUE_DEVTOOLS_TOAST__(piniaMessage, type);
			
 
				+  } else if (type === "error") {
			
 
				+    console.error(piniaMessage);
			
 
				+  } else if (type === "warn") {
			
 
				+    console.warn(piniaMessage);
			
 
				+  } else {
			
 
				+    console.log(piniaMessage);
			
 
				+  }
			
 
				+}
			
 
				+function isPinia(o) {
			
 
				+  return "_a" in o && "install" in o;
			
 
				+}
			
 
				+function checkClipboardAccess() {
			
 
				+  if (!("clipboard" in navigator)) {
			
 
				+    toastMessage(`Your browser doesn't support the Clipboard API`, "error");
			
 
				+    return true;
			
 
				+  }
			
 
				+}
			
 
				+function checkNotFocusedError(error) {
			
 
				+  if (error instanceof Error && error.message.toLowerCase().includes("document is not focused")) {
			
 
				+    toastMessage('You need to activate the "Emulate a focused page" setting in the "Rendering" panel of devtools.', "warn");
			
 
				+    return true;
			
 
				+  }
			
 
				+  return false;
			
 
				+}
			
 
				+async function actionGlobalCopyState(pinia) {
			
 
				+  if (checkClipboardAccess())
			
 
				+    return;
			
 
				+  try {
			
 
				+    await navigator.clipboard.writeText(JSON.stringify(pinia.state.value));
			
 
				+    toastMessage("Global state copied to clipboard.");
			
 
				+  } catch (error) {
			
 
				+    if (checkNotFocusedError(error))
			
 
				+      return;
			
 
				+    toastMessage(`Failed to serialize the state. Check the console for more details.`, "error");
			
 
				+    console.error(error);
			
 
				+  }
			
 
				+}
			
 
				+async function actionGlobalPasteState(pinia) {
			
 
				+  if (checkClipboardAccess())
			
 
				+    return;
			
 
				+  try {
			
 
				+    loadStoresState(pinia, JSON.parse(await navigator.clipboard.readText()));
			
 
				+    toastMessage("Global state pasted from clipboard.");
			
 
				+  } catch (error) {
			
 
				+    if (checkNotFocusedError(error))
			
 
				+      return;
			
 
				+    toastMessage(`Failed to deserialize the state from clipboard. Check the console for more details.`, "error");
			
 
				+    console.error(error);
			
 
				+  }
			
 
				+}
			
 
				+async function actionGlobalSaveState(pinia) {
			
 
				+  try {
			
 
				+    saveAs(new Blob([JSON.stringify(pinia.state.value)], {
			
 
				+      type: "text/plain;charset=utf-8"
			
 
				+    }), "pinia-state.json");
			
 
				+  } catch (error) {
			
 
				+    toastMessage(`Failed to export the state as JSON. Check the console for more details.`, "error");
			
 
				+    console.error(error);
			
 
				+  }
			
 
				+}
			
 
				+var fileInput;
			
 
				+function getFileOpener() {
			
 
				+  if (!fileInput) {
			
 
				+    fileInput = document.createElement("input");
			
 
				+    fileInput.type = "file";
			
 
				+    fileInput.accept = ".json";
			
 
				+  }
			
 
				+  function openFile() {
			
 
				+    return new Promise((resolve, reject) => {
			
 
				+      fileInput.onchange = async () => {
			
 
				+        const files = fileInput.files;
			
 
				+        if (!files)
			
 
				+          return resolve(null);
			
 
				+        const file = files.item(0);
			
 
				+        if (!file)
			
 
				+          return resolve(null);
			
 
				+        return resolve({ text: await file.text(), file });
			
 
				+      };
			
 
				+      fileInput.oncancel = () => resolve(null);
			
 
				+      fileInput.onerror = reject;
			
 
				+      fileInput.click();
			
 
				+    });
			
 
				+  }
			
 
				+  return openFile;
			
 
				+}
			
 
				+async function actionGlobalOpenStateFile(pinia) {
			
 
				+  try {
			
 
				+    const open2 = getFileOpener();
			
 
				+    const result = await open2();
			
 
				+    if (!result)
			
 
				+      return;
			
 
				+    const { text, file } = result;
			
 
				+    loadStoresState(pinia, JSON.parse(text));
			
 
				+    toastMessage(`Global state imported from "${file.name}".`);
			
 
				+  } catch (error) {
			
 
				+    toastMessage(`Failed to import the state from JSON. Check the console for more details.`, "error");
			
 
				+    console.error(error);
			
 
				+  }
			
 
				+}
			
 
				+function loadStoresState(pinia, state) {
			
 
				+  for (const key in state) {
			
 
				+    const storeState = pinia.state.value[key];
			
 
				+    if (storeState) {
			
 
				+      Object.assign(storeState, state[key]);
			
 
				+    } else {
			
 
				+      pinia.state.value[key] = state[key];
			
 
				+    }
			
 
				+  }
			
 
				+}
			
 
				+function formatDisplay(display) {
			
 
				+  return {
			
 
				+    _custom: {
			
 
				+      display
			
 
				+    }
			
 
				+  };
			
 
				+}
			
 
				+var PINIA_ROOT_LABEL = "🍍 Pinia (root)";
			
 
				+var PINIA_ROOT_ID = "_root";
			
 
				+function formatStoreForInspectorTree(store) {
			
 
				+  return isPinia(store) ? {
			
 
				+    id: PINIA_ROOT_ID,
			
 
				+    label: PINIA_ROOT_LABEL
			
 
				+  } : {
			
 
				+    id: store.$id,
			
 
				+    label: store.$id
			
 
				+  };
			
 
				+}
			
 
				+function formatStoreForInspectorState(store) {
			
 
				+  if (isPinia(store)) {
			
 
				+    const storeNames = Array.from(store._s.keys());
			
 
				+    const storeMap = store._s;
			
 
				+    const state2 = {
			
 
				+      state: storeNames.map((storeId) => ({
			
 
				+        editable: true,
			
 
				+        key: storeId,
			
 
				+        value: store.state.value[storeId]
			
 
				+      })),
			
 
				+      getters: storeNames.filter((id) => storeMap.get(id)._getters).map((id) => {
			
 
				+        const store2 = storeMap.get(id);
			
 
				+        return {
			
 
				+          editable: false,
			
 
				+          key: id,
			
 
				+          value: store2._getters.reduce((getters, key) => {
			
 
				+            getters[key] = store2[key];
			
 
				+            return getters;
			
 
				+          }, {})
			
 
				+        };
			
 
				+      })
			
 
				+    };
			
 
				+    return state2;
			
 
				+  }
			
 
				+  const state = {
			
 
				+    state: Object.keys(store.$state).map((key) => ({
			
 
				+      editable: true,
			
 
				+      key,
			
 
				+      value: store.$state[key]
			
 
				+    }))
			
 
				+  };
			
 
				+  if (store._getters && store._getters.length) {
			
 
				+    state.getters = store._getters.map((getterName) => ({
			
 
				+      editable: false,
			
 
				+      key: getterName,
			
 
				+      value: store[getterName]
			
 
				+    }));
			
 
				+  }
			
 
				+  if (store._customProperties.size) {
			
 
				+    state.customProperties = Array.from(store._customProperties).map((key) => ({
			
 
				+      editable: true,
			
 
				+      key,
			
 
				+      value: store[key]
			
 
				+    }));
			
 
				+  }
			
 
				+  return state;
			
 
				+}
			
 
				+function formatEventData(events) {
			
 
				+  if (!events)
			
 
				+    return {};
			
 
				+  if (Array.isArray(events)) {
			
 
				+    return events.reduce((data, event) => {
			
 
				+      data.keys.push(event.key);
			
 
				+      data.operations.push(event.type);
			
 
				+      data.oldValue[event.key] = event.oldValue;
			
 
				+      data.newValue[event.key] = event.newValue;
			
 
				+      return data;
			
 
				+    }, {
			
 
				+      oldValue: {},
			
 
				+      keys: [],
			
 
				+      operations: [],
			
 
				+      newValue: {}
			
 
				+    });
			
 
				+  } else {
			
 
				+    return {
			
 
				+      operation: formatDisplay(events.type),
			
 
				+      key: formatDisplay(events.key),
			
 
				+      oldValue: events.oldValue,
			
 
				+      newValue: events.newValue
			
 
				+    };
			
 
				+  }
			
 
				+}
			
 
				+function formatMutationType(type) {
			
 
				+  switch (type) {
			
 
				+    case MutationType.direct:
			
 
				+      return "mutation";
			
 
				+    case MutationType.patchFunction:
			
 
				+      return "$patch";
			
 
				+    case MutationType.patchObject:
			
 
				+      return "$patch";
			
 
				+    default:
			
 
				+      return "unknown";
			
 
				+  }
			
 
				+}
			
 
				+var isTimelineActive = true;
			
 
				+var componentStateTypes = [];
			
 
				+var MUTATIONS_LAYER_ID = "pinia:mutations";
			
 
				+var INSPECTOR_ID = "pinia";
			
 
				+var { assign: assign$1 } = Object;
			
 
				+var getStoreType = (id) => "🍍 " + id;
			
 
				+function registerPiniaDevtools(app, pinia) {
			
 
				+  setupDevtoolsPlugin({
			
 
				+    id: "dev.esm.pinia",
			
 
				+    label: "Pinia 🍍",
			
 
				+    logo: "https://pinia.vuejs.org/logo.svg",
			
 
				+    packageName: "pinia",
			
 
				+    homepage: "https://pinia.vuejs.org",
			
 
				+    componentStateTypes,
			
 
				+    app
			
 
				+  }, (api) => {
			
 
				+    if (typeof api.now !== "function") {
			
 
				+      toastMessage("You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html.");
			
 
				+    }
			
 
				+    api.addTimelineLayer({
			
 
				+      id: MUTATIONS_LAYER_ID,
			
 
				+      label: `Pinia 🍍`,
			
 
				+      color: 15064968
			
 
				+    });
			
 
				+    api.addInspector({
			
 
				+      id: INSPECTOR_ID,
			
 
				+      label: "Pinia 🍍",
			
 
				+      icon: "storage",
			
 
				+      treeFilterPlaceholder: "Search stores",
			
 
				+      actions: [
			
 
				+        {
			
 
				+          icon: "content_copy",
			
 
				+          action: () => {
			
 
				+            actionGlobalCopyState(pinia);
			
 
				+          },
			
 
				+          tooltip: "Serialize and copy the state"
			
 
				+        },
			
 
				+        {
			
 
				+          icon: "content_paste",
			
 
				+          action: async () => {
			
 
				+            await actionGlobalPasteState(pinia);
			
 
				+            api.sendInspectorTree(INSPECTOR_ID);
			
 
				+            api.sendInspectorState(INSPECTOR_ID);
			
 
				+          },
			
 
				+          tooltip: "Replace the state with the content of your clipboard"
			
 
				+        },
			
 
				+        {
			
 
				+          icon: "save",
			
 
				+          action: () => {
			
 
				+            actionGlobalSaveState(pinia);
			
 
				+          },
			
 
				+          tooltip: "Save the state as a JSON file"
			
 
				+        },
			
 
				+        {
			
 
				+          icon: "folder_open",
			
 
				+          action: async () => {
			
 
				+            await actionGlobalOpenStateFile(pinia);
			
 
				+            api.sendInspectorTree(INSPECTOR_ID);
			
 
				+            api.sendInspectorState(INSPECTOR_ID);
			
 
				+          },
			
 
				+          tooltip: "Import the state from a JSON file"
			
 
				+        }
			
 
				+      ],
			
 
				+      nodeActions: [
			
 
				+        {
			
 
				+          icon: "restore",
			
 
				+          tooltip: 'Reset the state (with "$reset")',
			
 
				+          action: (nodeId) => {
			
 
				+            const store = pinia._s.get(nodeId);
			
 
				+            if (!store) {
			
 
				+              toastMessage(`Cannot reset "${nodeId}" store because it wasn't found.`, "warn");
			
 
				+            } else if (typeof store.$reset !== "function") {
			
 
				+              toastMessage(`Cannot reset "${nodeId}" store because it doesn't have a "$reset" method implemented.`, "warn");
			
 
				+            } else {
			
 
				+              store.$reset();
			
 
				+              toastMessage(`Store "${nodeId}" reset.`);
			
 
				+            }
			
 
				+          }
			
 
				+        }
			
 
				+      ]
			
 
				+    });
			
 
				+    api.on.inspectComponent((payload, ctx) => {
			
 
				+      const proxy = payload.componentInstance && payload.componentInstance.proxy;
			
 
				+      if (proxy && proxy._pStores) {
			
 
				+        const piniaStores = payload.componentInstance.proxy._pStores;
			
 
				+        Object.values(piniaStores).forEach((store) => {
			
 
				+          payload.instanceData.state.push({
			
 
				+            type: getStoreType(store.$id),
			
 
				+            key: "state",
			
 
				+            editable: true,
			
 
				+            value: store._isOptionsAPI ? {
			
 
				+              _custom: {
			
 
				+                value: toRaw(store.$state),
			
 
				+                actions: [
			
 
				+                  {
			
 
				+                    icon: "restore",
			
 
				+                    tooltip: "Reset the state of this store",
			
 
				+                    action: () => store.$reset()
			
 
				+                  }
			
 
				+                ]
			
 
				+              }
			
 
				+            } : (
			
 
				+              // NOTE: workaround to unwrap transferred refs
			
 
				+              Object.keys(store.$state).reduce((state, key) => {
			
 
				+                state[key] = store.$state[key];
			
 
				+                return state;
			
 
				+              }, {})
			
 
				+            )
			
 
				+          });
			
 
				+          if (store._getters && store._getters.length) {
			
 
				+            payload.instanceData.state.push({
			
 
				+              type: getStoreType(store.$id),
			
 
				+              key: "getters",
			
 
				+              editable: false,
			
 
				+              value: store._getters.reduce((getters, key) => {
			
 
				+                try {
			
 
				+                  getters[key] = store[key];
			
 
				+                } catch (error) {
			
 
				+                  getters[key] = error;
			
 
				+                }
			
 
				+                return getters;
			
 
				+              }, {})
			
 
				+            });
			
 
				+          }
			
 
				+        });
			
 
				+      }
			
 
				+    });
			
 
				+    api.on.getInspectorTree((payload) => {
			
 
				+      if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
			
 
				+        let stores = [pinia];
			
 
				+        stores = stores.concat(Array.from(pinia._s.values()));
			
 
				+        payload.rootNodes = (payload.filter ? stores.filter((store) => "$id" in store ? store.$id.toLowerCase().includes(payload.filter.toLowerCase()) : PINIA_ROOT_LABEL.toLowerCase().includes(payload.filter.toLowerCase())) : stores).map(formatStoreForInspectorTree);
			
 
				+      }
			
 
				+    });
			
 
				+    globalThis.$pinia = pinia;
			
 
				+    api.on.getInspectorState((payload) => {
			
 
				+      if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
			
 
				+        const inspectedStore = payload.nodeId === PINIA_ROOT_ID ? pinia : pinia._s.get(payload.nodeId);
			
 
				+        if (!inspectedStore) {
			
 
				+          return;
			
 
				+        }
			
 
				+        if (inspectedStore) {
			
 
				+          if (payload.nodeId !== PINIA_ROOT_ID)
			
 
				+            globalThis.$store = toRaw(inspectedStore);
			
 
				+          payload.state = formatStoreForInspectorState(inspectedStore);
			
 
				+        }
			
 
				+      }
			
 
				+    });
			
 
				+    api.on.editInspectorState((payload, ctx) => {
			
 
				+      if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {
			
 
				+        const inspectedStore = payload.nodeId === PINIA_ROOT_ID ? pinia : pinia._s.get(payload.nodeId);
			
 
				+        if (!inspectedStore) {
			
 
				+          return toastMessage(`store "${payload.nodeId}" not found`, "error");
			
 
				+        }
			
 
				+        const { path } = payload;
			
 
				+        if (!isPinia(inspectedStore)) {
			
 
				+          if (path.length !== 1 || !inspectedStore._customProperties.has(path[0]) || path[0] in inspectedStore.$state) {
			
 
				+            path.unshift("$state");
			
 
				+          }
			
 
				+        } else {
			
 
				+          path.unshift("state");
			
 
				+        }
			
 
				+        isTimelineActive = false;
			
 
				+        payload.set(inspectedStore, path, payload.state.value);
			
 
				+        isTimelineActive = true;
			
 
				+      }
			
 
				+    });
			
 
				+    api.on.editComponentState((payload) => {
			
 
				+      if (payload.type.startsWith("🍍")) {
			
 
				+        const storeId = payload.type.replace(/^🍍\s*/, "");
			
 
				+        const store = pinia._s.get(storeId);
			
 
				+        if (!store) {
			
 
				+          return toastMessage(`store "${storeId}" not found`, "error");
			
 
				+        }
			
 
				+        const { path } = payload;
			
 
				+        if (path[0] !== "state") {
			
 
				+          return toastMessage(`Invalid path for store "${storeId}":
			
 
				+${path}
			
 
				+Only state can be modified.`);
			
 
				+        }
			
 
				+        path[0] = "$state";
			
 
				+        isTimelineActive = false;
			
 
				+        payload.set(store, path, payload.state.value);
			
 
				+        isTimelineActive = true;
			
 
				+      }
			
 
				+    });
			
 
				+  });
			
 
				+}
			
 
				+function addStoreToDevtools(app, store) {
			
 
				+  if (!componentStateTypes.includes(getStoreType(store.$id))) {
			
 
				+    componentStateTypes.push(getStoreType(store.$id));
			
 
				+  }
			
 
				+  setupDevtoolsPlugin({
			
 
				+    id: "dev.esm.pinia",
			
 
				+    label: "Pinia 🍍",
			
 
				+    logo: "https://pinia.vuejs.org/logo.svg",
			
 
				+    packageName: "pinia",
			
 
				+    homepage: "https://pinia.vuejs.org",
			
 
				+    componentStateTypes,
			
 
				+    app,
			
 
				+    settings: {
			
 
				+      logStoreChanges: {
			
 
				+        label: "Notify about new/deleted stores",
			
 
				+        type: "boolean",
			
 
				+        defaultValue: true
			
 
				+      }
			
 
				+      // useEmojis: {
			
 
				+      //   label: 'Use emojis in messages ⚡️',
			
 
				+      //   type: 'boolean',
			
 
				+      //   defaultValue: true,
			
 
				+      // },
			
 
				+    }
			
 
				+  }, (api) => {
			
 
				+    const now = typeof api.now === "function" ? api.now.bind(api) : Date.now;
			
 
				+    store.$onAction(({ after, onError, name, args }) => {
			
 
				+      const groupId = runningActionId++;
			
 
				+      api.addTimelineEvent({
			
 
				+        layerId: MUTATIONS_LAYER_ID,
			
 
				+        event: {
			
 
				+          time: now(),
			
 
				+          title: "🛫 " + name,
			
 
				+          subtitle: "start",
			
 
				+          data: {
			
 
				+            store: formatDisplay(store.$id),
			
 
				+            action: formatDisplay(name),
			
 
				+            args
			
 
				+          },
			
 
				+          groupId
			
 
				+        }
			
 
				+      });
			
 
				+      after((result) => {
			
 
				+        activeAction = void 0;
			
 
				+        api.addTimelineEvent({
			
 
				+          layerId: MUTATIONS_LAYER_ID,
			
 
				+          event: {
			
 
				+            time: now(),
			
 
				+            title: "🛬 " + name,
			
 
				+            subtitle: "end",
			
 
				+            data: {
			
 
				+              store: formatDisplay(store.$id),
			
 
				+              action: formatDisplay(name),
			
 
				+              args,
			
 
				+              result
			
 
				+            },
			
 
				+            groupId
			
 
				+          }
			
 
				+        });
			
 
				+      });
			
 
				+      onError((error) => {
			
 
				+        activeAction = void 0;
			
 
				+        api.addTimelineEvent({
			
 
				+          layerId: MUTATIONS_LAYER_ID,
			
 
				+          event: {
			
 
				+            time: now(),
			
 
				+            logType: "error",
			
 
				+            title: "💥 " + name,
			
 
				+            subtitle: "end",
			
 
				+            data: {
			
 
				+              store: formatDisplay(store.$id),
			
 
				+              action: formatDisplay(name),
			
 
				+              args,
			
 
				+              error
			
 
				+            },
			
 
				+            groupId
			
 
				+          }
			
 
				+        });
			
 
				+      });
			
 
				+    }, true);
			
 
				+    store._customProperties.forEach((name) => {
			
 
				+      watch(() => unref(store[name]), (newValue, oldValue) => {
			
 
				+        api.notifyComponentUpdate();
			
 
				+        api.sendInspectorState(INSPECTOR_ID);
			
 
				+        if (isTimelineActive) {
			
 
				+          api.addTimelineEvent({
			
 
				+            layerId: MUTATIONS_LAYER_ID,
			
 
				+            event: {
			
 
				+              time: now(),
			
 
				+              title: "Change",
			
 
				+              subtitle: name,
			
 
				+              data: {
			
 
				+                newValue,
			
 
				+                oldValue
			
 
				+              },
			
 
				+              groupId: activeAction
			
 
				+            }
			
 
				+          });
			
 
				+        }
			
 
				+      }, { deep: true });
			
 
				+    });
			
 
				+    store.$subscribe(({ events, type }, state) => {
			
 
				+      api.notifyComponentUpdate();
			
 
				+      api.sendInspectorState(INSPECTOR_ID);
			
 
				+      if (!isTimelineActive)
			
 
				+        return;
			
 
				+      const eventData = {
			
 
				+        time: now(),
			
 
				+        title: formatMutationType(type),
			
 
				+        data: assign$1({ store: formatDisplay(store.$id) }, formatEventData(events)),
			
 
				+        groupId: activeAction
			
 
				+      };
			
 
				+      if (type === MutationType.patchFunction) {
			
 
				+        eventData.subtitle = "⤵️";
			
 
				+      } else if (type === MutationType.patchObject) {
			
 
				+        eventData.subtitle = "🧩";
			
 
				+      } else if (events && !Array.isArray(events)) {
			
 
				+        eventData.subtitle = events.type;
			
 
				+      }
			
 
				+      if (events) {
			
 
				+        eventData.data["rawEvent(s)"] = {
			
 
				+          _custom: {
			
 
				+            display: "DebuggerEvent",
			
 
				+            type: "object",
			
 
				+            tooltip: "raw DebuggerEvent[]",
			
 
				+            value: events
			
 
				+          }
			
 
				+        };
			
 
				+      }
			
 
				+      api.addTimelineEvent({
			
 
				+        layerId: MUTATIONS_LAYER_ID,
			
 
				+        event: eventData
			
 
				+      });
			
 
				+    }, { detached: true, flush: "sync" });
			
 
				+    const hotUpdate = store._hotUpdate;
			
 
				+    store._hotUpdate = markRaw((newStore) => {
			
 
				+      hotUpdate(newStore);
			
 
				+      api.addTimelineEvent({
			
 
				+        layerId: MUTATIONS_LAYER_ID,
			
 
				+        event: {
			
 
				+          time: now(),
			
 
				+          title: "🔥 " + store.$id,
			
 
				+          subtitle: "HMR update",
			
 
				+          data: {
			
 
				+            store: formatDisplay(store.$id),
			
 
				+            info: formatDisplay(`HMR update`)
			
 
				+          }
			
 
				+        }
			
 
				+      });
			
 
				+      api.notifyComponentUpdate();
			
 
				+      api.sendInspectorTree(INSPECTOR_ID);
			
 
				+      api.sendInspectorState(INSPECTOR_ID);
			
 
				+    });
			
 
				+    const { $dispose } = store;
			
 
				+    store.$dispose = () => {
			
 
				+      $dispose();
			
 
				+      api.notifyComponentUpdate();
			
 
				+      api.sendInspectorTree(INSPECTOR_ID);
			
 
				+      api.sendInspectorState(INSPECTOR_ID);
			
 
				+      api.getSettings().logStoreChanges && toastMessage(`Disposed "${store.$id}" store 🗑`);
			
 
				+    };
			
 
				+    api.notifyComponentUpdate();
			
 
				+    api.sendInspectorTree(INSPECTOR_ID);
			
 
				+    api.sendInspectorState(INSPECTOR_ID);
			
 
				+    api.getSettings().logStoreChanges && toastMessage(`"${store.$id}" store installed 🆕`);
			
 
				+  });
			
 
				+}
			
 
				+var runningActionId = 0;
			
 
				+var activeAction;
			
 
				+function patchActionForGrouping(store, actionNames, wrapWithProxy) {
			
 
				+  const actions = actionNames.reduce((storeActions, actionName) => {
			
 
				+    storeActions[actionName] = toRaw(store)[actionName];
			
 
				+    return storeActions;
			
 
				+  }, {});
			
 
				+  for (const actionName in actions) {
			
 
				+    store[actionName] = function() {
			
 
				+      const _actionId = runningActionId;
			
 
				+      const trackedStore = wrapWithProxy ? new Proxy(store, {
			
 
				+        get(...args) {
			
 
				+          activeAction = _actionId;
			
 
				+          return Reflect.get(...args);
			
 
				+        },
			
 
				+        set(...args) {
			
 
				+          activeAction = _actionId;
			
 
				+          return Reflect.set(...args);
			
 
				+        }
			
 
				+      }) : store;
			
 
				+      activeAction = _actionId;
			
 
				+      const retValue = actions[actionName].apply(trackedStore, arguments);
			
 
				+      activeAction = void 0;
			
 
				+      return retValue;
			
 
				+    };
			
 
				+  }
			
 
				+}
			
 
				+function devtoolsPlugin({ app, store, options }) {
			
 
				+  if (store.$id.startsWith("__hot:")) {
			
 
				+    return;
			
 
				+  }
			
 
				+  store._isOptionsAPI = !!options.state;
			
 
				+  if (!store._p._testing) {
			
 
				+    patchActionForGrouping(store, Object.keys(options.actions), store._isOptionsAPI);
			
 
				+    const originalHotUpdate = store._hotUpdate;
			
 
				+    toRaw(store)._hotUpdate = function(newStore) {
			
 
				+      originalHotUpdate.apply(this, arguments);
			
 
				+      patchActionForGrouping(store, Object.keys(newStore._hmrPayload.actions), !!store._isOptionsAPI);
			
 
				+    };
			
 
				+  }
			
 
				+  addStoreToDevtools(
			
 
				+    app,
			
 
				+    // FIXME: is there a way to allow the assignment from Store<Id, S, G, A> to StoreGeneric?
			
 
				+    store
			
 
				+  );
			
 
				+}
			
 
				+function createPinia() {
			
 
				+  const scope = effectScope(true);
			
 
				+  const state = scope.run(() => ref({}));
			
 
				+  let _p = [];
			
 
				+  let toBeInstalled = [];
			
 
				+  const pinia = markRaw({
			
 
				+    install(app) {
			
 
				+      setActivePinia(pinia);
			
 
				+      if (!isVue2) {
			
 
				+        pinia._a = app;
			
 
				+        app.provide(piniaSymbol, pinia);
			
 
				+        app.config.globalProperties.$pinia = pinia;
			
 
				+        if (IS_CLIENT) {
			
 
				+          registerPiniaDevtools(app, pinia);
			
 
				+        }
			
 
				+        toBeInstalled.forEach((plugin) => _p.push(plugin));
			
 
				+        toBeInstalled = [];
			
 
				+      }
			
 
				+    },
			
 
				+    use(plugin) {
			
 
				+      if (!this._a && !isVue2) {
			
 
				+        toBeInstalled.push(plugin);
			
 
				+      } else {
			
 
				+        _p.push(plugin);
			
 
				+      }
			
 
				+      return this;
			
 
				+    },
			
 
				+    _p,
			
 
				+    // it's actually undefined here
			
 
				+    // @ts-expect-error
			
 
				+    _a: null,
			
 
				+    _e: scope,
			
 
				+    _s: /* @__PURE__ */ new Map(),
			
 
				+    state
			
 
				+  });
			
 
				+  if (IS_CLIENT && typeof Proxy !== "undefined") {
			
 
				+    pinia.use(devtoolsPlugin);
			
 
				+  }
			
 
				+  return pinia;
			
 
				+}
			
 
				+function disposePinia(pinia) {
			
 
				+  pinia._e.stop();
			
 
				+  pinia._s.clear();
			
 
				+  pinia._p.splice(0);
			
 
				+  pinia.state.value = {};
			
 
				+  pinia._a = null;
			
 
				+}
			
 
				+var isUseStore = (fn) => {
			
 
				+  return typeof fn === "function" && typeof fn.$id === "string";
			
 
				+};
			
 
				+function patchObject(newState, oldState) {
			
 
				+  for (const key in oldState) {
			
 
				+    const subPatch = oldState[key];
			
 
				+    if (!(key in newState)) {
			
 
				+      continue;
			
 
				+    }
			
 
				+    const targetValue = newState[key];
			
 
				+    if (isPlainObject(targetValue) && isPlainObject(subPatch) && !isRef(subPatch) && !isReactive(subPatch)) {
			
 
				+      newState[key] = patchObject(targetValue, subPatch);
			
 
				+    } else {
			
 
				+      if (isVue2) {
			
 
				+        set(newState, key, subPatch);
			
 
				+      } else {
			
 
				+        newState[key] = subPatch;
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+  return newState;
			
 
				+}
			
 
				+function acceptHMRUpdate(initialUseStore, hot) {
			
 
				+  if (false) {
			
 
				+    return () => {
			
 
				+    };
			
 
				+  }
			
 
				+  return (newModule) => {
			
 
				+    const pinia = hot.data.pinia || initialUseStore._pinia;
			
 
				+    if (!pinia) {
			
 
				+      return;
			
 
				+    }
			
 
				+    hot.data.pinia = pinia;
			
 
				+    for (const exportName in newModule) {
			
 
				+      const useStore = newModule[exportName];
			
 
				+      if (isUseStore(useStore) && pinia._s.has(useStore.$id)) {
			
 
				+        const id = useStore.$id;
			
 
				+        if (id !== initialUseStore.$id) {
			
 
				+          console.warn(`The id of the store changed from "${initialUseStore.$id}" to "${id}". Reloading.`);
			
 
				+          return hot.invalidate();
			
 
				+        }
			
 
				+        const existingStore = pinia._s.get(id);
			
 
				+        if (!existingStore) {
			
 
				+          console.log(`[Pinia]: skipping hmr because store doesn't exist yet`);
			
 
				+          return;
			
 
				+        }
			
 
				+        useStore(pinia, existingStore);
			
 
				+      }
			
 
				+    }
			
 
				+  };
			
 
				+}
			
 
				+var noop = () => {
			
 
				+};
			
 
				+function addSubscription(subscriptions, callback, detached, onCleanup = noop) {
			
 
				+  subscriptions.push(callback);
			
 
				+  const removeSubscription = () => {
			
 
				+    const idx = subscriptions.indexOf(callback);
			
 
				+    if (idx > -1) {
			
 
				+      subscriptions.splice(idx, 1);
			
 
				+      onCleanup();
			
 
				+    }
			
 
				+  };
			
 
				+  if (!detached && getCurrentScope()) {
			
 
				+    onScopeDispose(removeSubscription);
			
 
				+  }
			
 
				+  return removeSubscription;
			
 
				+}
			
 
				+function triggerSubscriptions(subscriptions, ...args) {
			
 
				+  subscriptions.slice().forEach((callback) => {
			
 
				+    callback(...args);
			
 
				+  });
			
 
				+}
			
 
				+var fallbackRunWithContext = (fn) => fn();
			
 
				+var ACTION_MARKER = Symbol();
			
 
				+var ACTION_NAME = Symbol();
			
 
				+function mergeReactiveObjects(target, patchToApply) {
			
 
				+  if (target instanceof Map && patchToApply instanceof Map) {
			
 
				+    patchToApply.forEach((value, key) => target.set(key, value));
			
 
				+  } else if (target instanceof Set && patchToApply instanceof Set) {
			
 
				+    patchToApply.forEach(target.add, target);
			
 
				+  }
			
 
				+  for (const key in patchToApply) {
			
 
				+    if (!patchToApply.hasOwnProperty(key))
			
 
				+      continue;
			
 
				+    const subPatch = patchToApply[key];
			
 
				+    const targetValue = target[key];
			
 
				+    if (isPlainObject(targetValue) && isPlainObject(subPatch) && target.hasOwnProperty(key) && !isRef(subPatch) && !isReactive(subPatch)) {
			
 
				+      target[key] = mergeReactiveObjects(targetValue, subPatch);
			
 
				+    } else {
			
 
				+      target[key] = subPatch;
			
 
				+    }
			
 
				+  }
			
 
				+  return target;
			
 
				+}
			
 
				+var skipHydrateSymbol = true ? Symbol("pinia:skipHydration") : (
			
 
				+  /* istanbul ignore next */
			
 
				+  Symbol()
			
 
				+);
			
 
				+function skipHydrate(obj) {
			
 
				+  return Object.defineProperty(obj, skipHydrateSymbol, {});
			
 
				+}
			
 
				+function shouldHydrate(obj) {
			
 
				+  return !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
			
 
				+}
			
 
				+var { assign } = Object;
			
 
				+function isComputed(o) {
			
 
				+  return !!(isRef(o) && o.effect);
			
 
				+}
			
 
				+function createOptionsStore(id, options, pinia, hot) {
			
 
				+  const { state, actions, getters } = options;
			
 
				+  const initialState = pinia.state.value[id];
			
 
				+  let store;
			
 
				+  function setup() {
			
 
				+    if (!initialState && !hot) {
			
 
				+      if (isVue2) {
			
 
				+        set(pinia.state.value, id, state ? state() : {});
			
 
				+      } else {
			
 
				+        pinia.state.value[id] = state ? state() : {};
			
 
				+      }
			
 
				+    }
			
 
				+    const localState = hot ? (
			
 
				+      // use ref() to unwrap refs inside state TODO: check if this is still necessary
			
 
				+      toRefs(ref(state ? state() : {}).value)
			
 
				+    ) : toRefs(pinia.state.value[id]);
			
 
				+    return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name) => {
			
 
				+      if (name in localState) {
			
 
				+        console.warn(`[🍍]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`);
			
 
				+      }
			
 
				+      computedGetters[name] = markRaw(computed(() => {
			
 
				+        setActivePinia(pinia);
			
 
				+        const store2 = pinia._s.get(id);
			
 
				+        if (isVue2 && !store2._r)
			
 
				+          return;
			
 
				+        return getters[name].call(store2, store2);
			
 
				+      }));
			
 
				+      return computedGetters;
			
 
				+    }, {}));
			
 
				+  }
			
 
				+  store = createSetupStore(id, setup, options, pinia, hot, true);
			
 
				+  return store;
			
 
				+}
			
 
				+function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
			
 
				+  let scope;
			
 
				+  const optionsForPlugin = assign({ actions: {} }, options);
			
 
				+  if (!pinia._e.active) {
			
 
				+    throw new Error("Pinia destroyed");
			
 
				+  }
			
 
				+  const $subscribeOptions = { deep: true };
			
 
				+  if (!isVue2) {
			
 
				+    $subscribeOptions.onTrigger = (event) => {
			
 
				+      if (isListening) {
			
 
				+        debuggerEvents = event;
			
 
				+      } else if (isListening == false && !store._hotUpdating) {
			
 
				+        if (Array.isArray(debuggerEvents)) {
			
 
				+          debuggerEvents.push(event);
			
 
				+        } else {
			
 
				+          console.error("🍍 debuggerEvents should be an array. This is most likely an internal Pinia bug.");
			
 
				+        }
			
 
				+      }
			
 
				+    };
			
 
				+  }
			
 
				+  let isListening;
			
 
				+  let isSyncListening;
			
 
				+  let subscriptions = [];
			
 
				+  let actionSubscriptions = [];
			
 
				+  let debuggerEvents;
			
 
				+  const initialState = pinia.state.value[$id];
			
 
				+  if (!isOptionsStore && !initialState && !hot) {
			
 
				+    if (isVue2) {
			
 
				+      set(pinia.state.value, $id, {});
			
 
				+    } else {
			
 
				+      pinia.state.value[$id] = {};
			
 
				+    }
			
 
				+  }
			
 
				+  const hotState = ref({});
			
 
				+  let activeListener;
			
 
				+  function $patch(partialStateOrMutator) {
			
 
				+    let subscriptionMutation;
			
 
				+    isListening = isSyncListening = false;
			
 
				+    if (true) {
			
 
				+      debuggerEvents = [];
			
 
				+    }
			
 
				+    if (typeof partialStateOrMutator === "function") {
			
 
				+      partialStateOrMutator(pinia.state.value[$id]);
			
 
				+      subscriptionMutation = {
			
 
				+        type: MutationType.patchFunction,
			
 
				+        storeId: $id,
			
 
				+        events: debuggerEvents
			
 
				+      };
			
 
				+    } else {
			
 
				+      mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
			
 
				+      subscriptionMutation = {
			
 
				+        type: MutationType.patchObject,
			
 
				+        payload: partialStateOrMutator,
			
 
				+        storeId: $id,
			
 
				+        events: debuggerEvents
			
 
				+      };
			
 
				+    }
			
 
				+    const myListenerId = activeListener = Symbol();
			
 
				+    nextTick().then(() => {
			
 
				+      if (activeListener === myListenerId) {
			
 
				+        isListening = true;
			
 
				+      }
			
 
				+    });
			
 
				+    isSyncListening = true;
			
 
				+    triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
			
 
				+  }
			
 
				+  const $reset = isOptionsStore ? function $reset2() {
			
 
				+    const { state } = options;
			
 
				+    const newState = state ? state() : {};
			
 
				+    this.$patch(($state) => {
			
 
				+      assign($state, newState);
			
 
				+    });
			
 
				+  } : (
			
 
				+    /* istanbul ignore next */
			
 
				+    true ? () => {
			
 
				+      throw new Error(`🍍: Store "${$id}" is built using the setup syntax and does not implement $reset().`);
			
 
				+    } : noop
			
 
				+  );
			
 
				+  function $dispose() {
			
 
				+    scope.stop();
			
 
				+    subscriptions = [];
			
 
				+    actionSubscriptions = [];
			
 
				+    pinia._s.delete($id);
			
 
				+  }
			
 
				+  const action = (fn, name = "") => {
			
 
				+    if (ACTION_MARKER in fn) {
			
 
				+      fn[ACTION_NAME] = name;
			
 
				+      return fn;
			
 
				+    }
			
 
				+    const wrappedAction = function() {
			
 
				+      setActivePinia(pinia);
			
 
				+      const args = Array.from(arguments);
			
 
				+      const afterCallbackList = [];
			
 
				+      const onErrorCallbackList = [];
			
 
				+      function after(callback) {
			
 
				+        afterCallbackList.push(callback);
			
 
				+      }
			
 
				+      function onError(callback) {
			
 
				+        onErrorCallbackList.push(callback);
			
 
				+      }
			
 
				+      triggerSubscriptions(actionSubscriptions, {
			
 
				+        args,
			
 
				+        name: wrappedAction[ACTION_NAME],
			
 
				+        store,
			
 
				+        after,
			
 
				+        onError
			
 
				+      });
			
 
				+      let ret;
			
 
				+      try {
			
 
				+        ret = fn.apply(this && this.$id === $id ? this : store, args);
			
 
				+      } catch (error) {
			
 
				+        triggerSubscriptions(onErrorCallbackList, error);
			
 
				+        throw error;
			
 
				+      }
			
 
				+      if (ret instanceof Promise) {
			
 
				+        return ret.then((value) => {
			
 
				+          triggerSubscriptions(afterCallbackList, value);
			
 
				+          return value;
			
 
				+        }).catch((error) => {
			
 
				+          triggerSubscriptions(onErrorCallbackList, error);
			
 
				+          return Promise.reject(error);
			
 
				+        });
			
 
				+      }
			
 
				+      triggerSubscriptions(afterCallbackList, ret);
			
 
				+      return ret;
			
 
				+    };
			
 
				+    wrappedAction[ACTION_MARKER] = true;
			
 
				+    wrappedAction[ACTION_NAME] = name;
			
 
				+    return wrappedAction;
			
 
				+  };
			
 
				+  const _hmrPayload = markRaw({
			
 
				+    actions: {},
			
 
				+    getters: {},
			
 
				+    state: [],
			
 
				+    hotState
			
 
				+  });
			
 
				+  const partialStore = {
			
 
				+    _p: pinia,
			
 
				+    // _s: scope,
			
 
				+    $id,
			
 
				+    $onAction: addSubscription.bind(null, actionSubscriptions),
			
 
				+    $patch,
			
 
				+    $reset,
			
 
				+    $subscribe(callback, options2 = {}) {
			
 
				+      const removeSubscription = addSubscription(subscriptions, callback, options2.detached, () => stopWatcher());
			
 
				+      const stopWatcher = scope.run(() => watch(() => pinia.state.value[$id], (state) => {
			
 
				+        if (options2.flush === "sync" ? isSyncListening : isListening) {
			
 
				+          callback({
			
 
				+            storeId: $id,
			
 
				+            type: MutationType.direct,
			
 
				+            events: debuggerEvents
			
 
				+          }, state);
			
 
				+        }
			
 
				+      }, assign({}, $subscribeOptions, options2)));
			
 
				+      return removeSubscription;
			
 
				+    },
			
 
				+    $dispose
			
 
				+  };
			
 
				+  if (isVue2) {
			
 
				+    partialStore._r = false;
			
 
				+  }
			
 
				+  const store = reactive(true ? assign(
			
 
				+    {
			
 
				+      _hmrPayload,
			
 
				+      _customProperties: markRaw(/* @__PURE__ */ new Set())
			
 
				+      // devtools custom properties
			
 
				+    },
			
 
				+    partialStore
			
 
				+    // must be added later
			
 
				+    // setupStore
			
 
				+  ) : partialStore);
			
 
				+  pinia._s.set($id, store);
			
 
				+  const runWithContext = pinia._a && pinia._a.runWithContext || fallbackRunWithContext;
			
 
				+  const setupStore = runWithContext(() => pinia._e.run(() => (scope = effectScope()).run(() => setup({ action }))));
			
 
				+  for (const key in setupStore) {
			
 
				+    const prop = setupStore[key];
			
 
				+    if (isRef(prop) && !isComputed(prop) || isReactive(prop)) {
			
 
				+      if (hot) {
			
 
				+        set(hotState.value, key, toRef(setupStore, key));
			
 
				+      } else if (!isOptionsStore) {
			
 
				+        if (initialState && shouldHydrate(prop)) {
			
 
				+          if (isRef(prop)) {
			
 
				+            prop.value = initialState[key];
			
 
				+          } else {
			
 
				+            mergeReactiveObjects(prop, initialState[key]);
			
 
				+          }
			
 
				+        }
			
 
				+        if (isVue2) {
			
 
				+          set(pinia.state.value[$id], key, prop);
			
 
				+        } else {
			
 
				+          pinia.state.value[$id][key] = prop;
			
 
				+        }
			
 
				+      }
			
 
				+      if (true) {
			
 
				+        _hmrPayload.state.push(key);
			
 
				+      }
			
 
				+    } else if (typeof prop === "function") {
			
 
				+      const actionValue = hot ? prop : action(prop, key);
			
 
				+      if (isVue2) {
			
 
				+        set(setupStore, key, actionValue);
			
 
				+      } else {
			
 
				+        setupStore[key] = actionValue;
			
 
				+      }
			
 
				+      if (true) {
			
 
				+        _hmrPayload.actions[key] = prop;
			
 
				+      }
			
 
				+      optionsForPlugin.actions[key] = prop;
			
 
				+    } else if (true) {
			
 
				+      if (isComputed(prop)) {
			
 
				+        _hmrPayload.getters[key] = isOptionsStore ? (
			
 
				+          // @ts-expect-error
			
 
				+          options.getters[key]
			
 
				+        ) : prop;
			
 
				+        if (IS_CLIENT) {
			
 
				+          const getters = setupStore._getters || // @ts-expect-error: same
			
 
				+          (setupStore._getters = markRaw([]));
			
 
				+          getters.push(key);
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+  if (isVue2) {
			
 
				+    Object.keys(setupStore).forEach((key) => {
			
 
				+      set(store, key, setupStore[key]);
			
 
				+    });
			
 
				+  } else {
			
 
				+    assign(store, setupStore);
			
 
				+    assign(toRaw(store), setupStore);
			
 
				+  }
			
 
				+  Object.defineProperty(store, "$state", {
			
 
				+    get: () => hot ? hotState.value : pinia.state.value[$id],
			
 
				+    set: (state) => {
			
 
				+      if (hot) {
			
 
				+        throw new Error("cannot set hotState");
			
 
				+      }
			
 
				+      $patch(($state) => {
			
 
				+        assign($state, state);
			
 
				+      });
			
 
				+    }
			
 
				+  });
			
 
				+  if (true) {
			
 
				+    store._hotUpdate = markRaw((newStore) => {
			
 
				+      store._hotUpdating = true;
			
 
				+      newStore._hmrPayload.state.forEach((stateKey) => {
			
 
				+        if (stateKey in store.$state) {
			
 
				+          const newStateTarget = newStore.$state[stateKey];
			
 
				+          const oldStateSource = store.$state[stateKey];
			
 
				+          if (typeof newStateTarget === "object" && isPlainObject(newStateTarget) && isPlainObject(oldStateSource)) {
			
 
				+            patchObject(newStateTarget, oldStateSource);
			
 
				+          } else {
			
 
				+            newStore.$state[stateKey] = oldStateSource;
			
 
				+          }
			
 
				+        }
			
 
				+        set(store, stateKey, toRef(newStore.$state, stateKey));
			
 
				+      });
			
 
				+      Object.keys(store.$state).forEach((stateKey) => {
			
 
				+        if (!(stateKey in newStore.$state)) {
			
 
				+          del(store, stateKey);
			
 
				+        }
			
 
				+      });
			
 
				+      isListening = false;
			
 
				+      isSyncListening = false;
			
 
				+      pinia.state.value[$id] = toRef(newStore._hmrPayload, "hotState");
			
 
				+      isSyncListening = true;
			
 
				+      nextTick().then(() => {
			
 
				+        isListening = true;
			
 
				+      });
			
 
				+      for (const actionName in newStore._hmrPayload.actions) {
			
 
				+        const actionFn = newStore[actionName];
			
 
				+        set(store, actionName, action(actionFn, actionName));
			
 
				+      }
			
 
				+      for (const getterName in newStore._hmrPayload.getters) {
			
 
				+        const getter = newStore._hmrPayload.getters[getterName];
			
 
				+        const getterValue = isOptionsStore ? (
			
 
				+          // special handling of options api
			
 
				+          computed(() => {
			
 
				+            setActivePinia(pinia);
			
 
				+            return getter.call(store, store);
			
 
				+          })
			
 
				+        ) : getter;
			
 
				+        set(store, getterName, getterValue);
			
 
				+      }
			
 
				+      Object.keys(store._hmrPayload.getters).forEach((key) => {
			
 
				+        if (!(key in newStore._hmrPayload.getters)) {
			
 
				+          del(store, key);
			
 
				+        }
			
 
				+      });
			
 
				+      Object.keys(store._hmrPayload.actions).forEach((key) => {
			
 
				+        if (!(key in newStore._hmrPayload.actions)) {
			
 
				+          del(store, key);
			
 
				+        }
			
 
				+      });
			
 
				+      store._hmrPayload = newStore._hmrPayload;
			
 
				+      store._getters = newStore._getters;
			
 
				+      store._hotUpdating = false;
			
 
				+    });
			
 
				+  }
			
 
				+  if (IS_CLIENT) {
			
 
				+    const nonEnumerable = {
			
 
				+      writable: true,
			
 
				+      configurable: true,
			
 
				+      // avoid warning on devtools trying to display this property
			
 
				+      enumerable: false
			
 
				+    };
			
 
				+    ["_p", "_hmrPayload", "_getters", "_customProperties"].forEach((p) => {
			
 
				+      Object.defineProperty(store, p, assign({ value: store[p] }, nonEnumerable));
			
 
				+    });
			
 
				+  }
			
 
				+  if (isVue2) {
			
 
				+    store._r = true;
			
 
				+  }
			
 
				+  pinia._p.forEach((extender) => {
			
 
				+    if (IS_CLIENT) {
			
 
				+      const extensions = scope.run(() => extender({
			
 
				+        store,
			
 
				+        app: pinia._a,
			
 
				+        pinia,
			
 
				+        options: optionsForPlugin
			
 
				+      }));
			
 
				+      Object.keys(extensions || {}).forEach((key) => store._customProperties.add(key));
			
 
				+      assign(store, extensions);
			
 
				+    } else {
			
 
				+      assign(store, scope.run(() => extender({
			
 
				+        store,
			
 
				+        app: pinia._a,
			
 
				+        pinia,
			
 
				+        options: optionsForPlugin
			
 
				+      })));
			
 
				+    }
			
 
				+  });
			
 
				+  if (store.$state && typeof store.$state === "object" && typeof store.$state.constructor === "function" && !store.$state.constructor.toString().includes("[native code]")) {
			
 
				+    console.warn(`[🍍]: The "state" must be a plain object. It cannot be
			
 
				+	state: () => new MyClass()
			
 
				+Found in store "${store.$id}".`);
			
 
				+  }
			
 
				+  if (initialState && isOptionsStore && options.hydrate) {
			
 
				+    options.hydrate(store.$state, initialState);
			
 
				+  }
			
 
				+  isListening = true;
			
 
				+  isSyncListening = true;
			
 
				+  return store;
			
 
				+}
			
 
				+function defineStore(idOrOptions, setup, setupOptions) {
			
 
				+  let id;
			
 
				+  let options;
			
 
				+  const isSetupStore = typeof setup === "function";
			
 
				+  if (typeof idOrOptions === "string") {
			
 
				+    id = idOrOptions;
			
 
				+    options = isSetupStore ? setupOptions : setup;
			
 
				+  } else {
			
 
				+    options = idOrOptions;
			
 
				+    id = idOrOptions.id;
			
 
				+    if (typeof id !== "string") {
			
 
				+      throw new Error(`[🍍]: "defineStore()" must be passed a store id as its first argument.`);
			
 
				+    }
			
 
				+  }
			
 
				+  function useStore(pinia, hot) {
			
 
				+    const hasContext = hasInjectionContext();
			
 
				+    pinia = // in test mode, ignore the argument provided as we can always retrieve a
			
 
				+    // pinia instance with getActivePinia()
			
 
				+    (false ? null : pinia) || (hasContext ? inject(piniaSymbol, null) : null);
			
 
				+    if (pinia)
			
 
				+      setActivePinia(pinia);
			
 
				+    if (!activePinia) {
			
 
				+      throw new Error(`[🍍]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "app.use(pinia)"?
			
 
				+See https://pinia.vuejs.org/core-concepts/outside-component-usage.html for help.
			
 
				+This will fail in production.`);
			
 
				+    }
			
 
				+    pinia = activePinia;
			
 
				+    if (!pinia._s.has(id)) {
			
 
				+      if (isSetupStore) {
			
 
				+        createSetupStore(id, setup, options, pinia);
			
 
				+      } else {
			
 
				+        createOptionsStore(id, options, pinia);
			
 
				+      }
			
 
				+      if (true) {
			
 
				+        useStore._pinia = pinia;
			
 
				+      }
			
 
				+    }
			
 
				+    const store = pinia._s.get(id);
			
 
				+    if (hot) {
			
 
				+      const hotId = "__hot:" + id;
			
 
				+      const newStore = isSetupStore ? createSetupStore(hotId, setup, options, pinia, true) : createOptionsStore(hotId, assign({}, options), pinia, true);
			
 
				+      hot._hotUpdate(newStore);
			
 
				+      delete pinia.state.value[hotId];
			
 
				+      pinia._s.delete(hotId);
			
 
				+    }
			
 
				+    if (IS_CLIENT) {
			
 
				+      const currentInstance = getCurrentInstance();
			
 
				+      if (currentInstance && currentInstance.proxy && // avoid adding stores that are just built for hot module replacement
			
 
				+      !hot) {
			
 
				+        const vm = currentInstance.proxy;
			
 
				+        const cache = "_pStores" in vm ? vm._pStores : vm._pStores = {};
			
 
				+        cache[id] = store;
			
 
				+      }
			
 
				+    }
			
 
				+    return store;
			
 
				+  }
			
 
				+  useStore.$id = id;
			
 
				+  return useStore;
			
 
				+}
			
 
				+var mapStoreSuffix = "Store";
			
 
				+function setMapStoreSuffix(suffix) {
			
 
				+  mapStoreSuffix = suffix;
			
 
				+}
			
 
				+function mapStores(...stores) {
			
 
				+  if (Array.isArray(stores[0])) {
			
 
				+    console.warn(`[🍍]: Directly pass all stores to "mapStores()" without putting them in an array:
			
 
				+Replace
			
 
				+	mapStores([useAuthStore, useCartStore])
			
 
				+with
			
 
				+	mapStores(useAuthStore, useCartStore)
			
 
				+This will fail in production if not fixed.`);
			
 
				+    stores = stores[0];
			
 
				+  }
			
 
				+  return stores.reduce((reduced, useStore) => {
			
 
				+    reduced[useStore.$id + mapStoreSuffix] = function() {
			
 
				+      return useStore(this.$pinia);
			
 
				+    };
			
 
				+    return reduced;
			
 
				+  }, {});
			
 
				+}
			
 
				+function mapState(useStore, keysOrMapper) {
			
 
				+  return Array.isArray(keysOrMapper) ? keysOrMapper.reduce((reduced, key) => {
			
 
				+    reduced[key] = function() {
			
 
				+      return useStore(this.$pinia)[key];
			
 
				+    };
			
 
				+    return reduced;
			
 
				+  }, {}) : Object.keys(keysOrMapper).reduce((reduced, key) => {
			
 
				+    reduced[key] = function() {
			
 
				+      const store = useStore(this.$pinia);
			
 
				+      const storeKey = keysOrMapper[key];
			
 
				+      return typeof storeKey === "function" ? storeKey.call(this, store) : (
			
 
				+        // @ts-expect-error: FIXME: should work?
			
 
				+        store[storeKey]
			
 
				+      );
			
 
				+    };
			
 
				+    return reduced;
			
 
				+  }, {});
			
 
				+}
			
 
				+var mapGetters = mapState;
			
 
				+function mapActions(useStore, keysOrMapper) {
			
 
				+  return Array.isArray(keysOrMapper) ? keysOrMapper.reduce((reduced, key) => {
			
 
				+    reduced[key] = function(...args) {
			
 
				+      return useStore(this.$pinia)[key](...args);
			
 
				+    };
			
 
				+    return reduced;
			
 
				+  }, {}) : Object.keys(keysOrMapper).reduce((reduced, key) => {
			
 
				+    reduced[key] = function(...args) {
			
 
				+      return useStore(this.$pinia)[keysOrMapper[key]](...args);
			
 
				+    };
			
 
				+    return reduced;
			
 
				+  }, {});
			
 
				+}
			
 
				+function mapWritableState(useStore, keysOrMapper) {
			
 
				+  return Array.isArray(keysOrMapper) ? keysOrMapper.reduce((reduced, key) => {
			
 
				+    reduced[key] = {
			
 
				+      get() {
			
 
				+        return useStore(this.$pinia)[key];
			
 
				+      },
			
 
				+      set(value) {
			
 
				+        return useStore(this.$pinia)[key] = value;
			
 
				+      }
			
 
				+    };
			
 
				+    return reduced;
			
 
				+  }, {}) : Object.keys(keysOrMapper).reduce((reduced, key) => {
			
 
				+    reduced[key] = {
			
 
				+      get() {
			
 
				+        return useStore(this.$pinia)[keysOrMapper[key]];
			
 
				+      },
			
 
				+      set(value) {
			
 
				+        return useStore(this.$pinia)[keysOrMapper[key]] = value;
			
 
				+      }
			
 
				+    };
			
 
				+    return reduced;
			
 
				+  }, {});
			
 
				+}
			
 
				+function storeToRefs(store) {
			
 
				+  if (isVue2) {
			
 
				+    return toRefs(store);
			
 
				+  } else {
			
 
				+    const rawStore = toRaw(store);
			
 
				+    const refs = {};
			
 
				+    for (const key in rawStore) {
			
 
				+      const value = rawStore[key];
			
 
				+      if (value.effect) {
			
 
				+        refs[key] = // ...
			
 
				+        computed({
			
 
				+          get: () => store[key],
			
 
				+          set(value2) {
			
 
				+            store[key] = value2;
			
 
				+          }
			
 
				+        });
			
 
				+      } else if (isRef(value) || isReactive(value)) {
			
 
				+        refs[key] = // ---
			
 
				+        toRef(store, key);
			
 
				+      }
			
 
				+    }
			
 
				+    return refs;
			
 
				+  }
			
 
				+}
			
 
				+var PiniaVuePlugin = function(_Vue) {
			
 
				+  _Vue.mixin({
			
 
				+    beforeCreate() {
			
 
				+      const options = this.$options;
			
 
				+      if (options.pinia) {
			
 
				+        const pinia = options.pinia;
			
 
				+        if (!this._provided) {
			
 
				+          const provideCache = {};
			
 
				+          Object.defineProperty(this, "_provided", {
			
 
				+            get: () => provideCache,
			
 
				+            set: (v) => Object.assign(provideCache, v)
			
 
				+          });
			
 
				+        }
			
 
				+        this._provided[piniaSymbol] = pinia;
			
 
				+        if (!this.$pinia) {
			
 
				+          this.$pinia = pinia;
			
 
				+        }
			
 
				+        pinia._a = this;
			
 
				+        if (IS_CLIENT) {
			
 
				+          setActivePinia(pinia);
			
 
				+        }
			
 
				+        if (IS_CLIENT) {
			
 
				+          registerPiniaDevtools(pinia._a, pinia);
			
 
				+        }
			
 
				+      } else if (!this.$pinia && options.parent && options.parent.$pinia) {
			
 
				+        this.$pinia = options.parent.$pinia;
			
 
				+      }
			
 
				+    },
			
 
				+    destroyed() {
			
 
				+      delete this._pStores;
			
 
				+    }
			
 
				+  });
			
 
				+};
			
 
				+export {
			
 
				+  MutationType,
			
 
				+  PiniaVuePlugin,
			
 
				+  acceptHMRUpdate,
			
 
				+  createPinia,
			
 
				+  defineStore,
			
 
				+  disposePinia,
			
 
				+  getActivePinia,
			
 
				+  mapActions,
			
 
				+  mapGetters,
			
 
				+  mapState,
			
 
				+  mapStores,
			
 
				+  mapWritableState,
			
 
				+  setActivePinia,
			
 
				+  setMapStoreSuffix,
			
 
				+  shouldHydrate,
			
 
				+  skipHydrate,
			
 
				+  storeToRefs
			
 
				+};
			
 
				+/*! Bundled license information:
			
 
				+
			
 
				+pinia/dist/pinia.mjs:
			
 
				+  (*!
			
 
				+   * pinia v2.3.1
			
 
				+   * (c) 2025 Eduardo San Martin Morote
			
 
				+   * @license MIT
			
 
				+   *)
			
 
				+  (*! #__NO_SIDE_EFFECTS__ *)
			
 
				+*/
			
 
				+//# sourceMappingURL=pinia.js.map
			
--- a/ui/node_modules/.vite/deps/pinia.js.map
+++ b/ui/node_modules/.vite/deps/pinia.js.map
--- a/ui/node_modules/.vite/deps/vue-router.js
+++ b/ui/node_modules/.vite/deps/vue-router.js
@@ -0,0 +1,2246 @@
 
				+import {
			
 
				+  setupDevtoolsPlugin
			
 
				+} from "./chunk-YFT6OQ5R.js";
			
 
				+import {
			
 
				+  computed,
			
 
				+  defineComponent,
			
 
				+  getCurrentInstance,
			
 
				+  h,
			
 
				+  inject,
			
 
				+  nextTick,
			
 
				+  onActivated,
			
 
				+  onDeactivated,
			
 
				+  onUnmounted,
			
 
				+  provide,
			
 
				+  reactive,
			
 
				+  ref,
			
 
				+  shallowReactive,
			
 
				+  shallowRef,
			
 
				+  unref,
			
 
				+  watch,
			
 
				+  watchEffect
			
 
				+} from "./chunk-ZIH63DMU.js";
			
 
				+
			
 
				+// node_modules/vue-router/dist/devtools-EWN81iOl.mjs
			
 
				+var isBrowser = typeof document !== "undefined";
			
 
				+function isRouteComponent(component) {
			
 
				+  return typeof component === "object" || "displayName" in component || "props" in component || "__vccOpts" in component;
			
 
				+}
			
 
				+function isESModule(obj) {
			
 
				+  return obj.__esModule || obj[Symbol.toStringTag] === "Module" || obj.default && isRouteComponent(obj.default);
			
 
				+}
			
 
				+var assign = Object.assign;
			
 
				+function applyToParams(fn, params) {
			
 
				+  const newParams = {};
			
 
				+  for (const key in params) {
			
 
				+    const value = params[key];
			
 
				+    newParams[key] = isArray(value) ? value.map(fn) : fn(value);
			
 
				+  }
			
 
				+  return newParams;
			
 
				+}
			
 
				+var noop = () => {
			
 
				+};
			
 
				+var isArray = Array.isArray;
			
 
				+function mergeOptions(defaults, partialOptions) {
			
 
				+  const options = {};
			
 
				+  for (const key in defaults) options[key] = key in partialOptions ? partialOptions[key] : defaults[key];
			
 
				+  return options;
			
 
				+}
			
 
				+function warn$1(msg) {
			
 
				+  const args = Array.from(arguments).slice(1);
			
 
				+  console.warn.apply(console, ["[Vue Router warn]: " + msg].concat(args));
			
 
				+}
			
 
				+var HASH_RE = /#/g;
			
 
				+var AMPERSAND_RE = /&/g;
			
 
				+var SLASH_RE = /\//g;
			
 
				+var EQUAL_RE = /=/g;
			
 
				+var IM_RE = /\?/g;
			
 
				+var PLUS_RE = /\+/g;
			
 
				+var ENC_BRACKET_OPEN_RE = /%5B/g;
			
 
				+var ENC_BRACKET_CLOSE_RE = /%5D/g;
			
 
				+var ENC_CARET_RE = /%5E/g;
			
 
				+var ENC_BACKTICK_RE = /%60/g;
			
 
				+var ENC_CURLY_OPEN_RE = /%7B/g;
			
 
				+var ENC_PIPE_RE = /%7C/g;
			
 
				+var ENC_CURLY_CLOSE_RE = /%7D/g;
			
 
				+var ENC_SPACE_RE = /%20/g;
			
 
				+function commonEncode(text) {
			
 
				+  return text == null ? "" : encodeURI("" + text).replace(ENC_PIPE_RE, "|").replace(ENC_BRACKET_OPEN_RE, "[").replace(ENC_BRACKET_CLOSE_RE, "]");
			
 
				+}
			
 
				+function encodeHash(text) {
			
 
				+  return commonEncode(text).replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
			
 
				+}
			
 
				+function encodeQueryValue(text) {
			
 
				+  return commonEncode(text).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CURLY_OPEN_RE, "{").replace(ENC_CURLY_CLOSE_RE, "}").replace(ENC_CARET_RE, "^");
			
 
				+}
			
 
				+function encodeQueryKey(text) {
			
 
				+  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
			
 
				+}
			
 
				+function encodePath(text) {
			
 
				+  return commonEncode(text).replace(HASH_RE, "%23").replace(IM_RE, "%3F");
			
 
				+}
			
 
				+function encodeParam(text) {
			
 
				+  return encodePath(text).replace(SLASH_RE, "%2F");
			
 
				+}
			
 
				+function decode(text) {
			
 
				+  if (text == null) return null;
			
 
				+  try {
			
 
				+    return decodeURIComponent("" + text);
			
 
				+  } catch (err) {
			
 
				+    warn$1(`Error decoding "${text}". Using original value`);
			
 
				+  }
			
 
				+  return "" + text;
			
 
				+}
			
 
				+var TRAILING_SLASH_RE = /\/$/;
			
 
				+var removeTrailingSlash = (path) => path.replace(TRAILING_SLASH_RE, "");
			
 
				+function parseURL(parseQuery$1, location2, currentLocation = "/") {
			
 
				+  let path, query = {}, searchString = "", hash = "";
			
 
				+  const hashPos = location2.indexOf("#");
			
 
				+  let searchPos = location2.indexOf("?");
			
 
				+  searchPos = hashPos >= 0 && searchPos > hashPos ? -1 : searchPos;
			
 
				+  if (searchPos >= 0) {
			
 
				+    path = location2.slice(0, searchPos);
			
 
				+    searchString = location2.slice(searchPos, hashPos > 0 ? hashPos : location2.length);
			
 
				+    query = parseQuery$1(searchString.slice(1));
			
 
				+  }
			
 
				+  if (hashPos >= 0) {
			
 
				+    path = path || location2.slice(0, hashPos);
			
 
				+    hash = location2.slice(hashPos, location2.length);
			
 
				+  }
			
 
				+  path = resolveRelativePath(path != null ? path : location2, currentLocation);
			
 
				+  return {
			
 
				+    fullPath: path + searchString + hash,
			
 
				+    path,
			
 
				+    query,
			
 
				+    hash: decode(hash)
			
 
				+  };
			
 
				+}
			
 
				+function stringifyURL(stringifyQuery$1, location2) {
			
 
				+  const query = location2.query ? stringifyQuery$1(location2.query) : "";
			
 
				+  return location2.path + (query && "?") + query + (location2.hash || "");
			
 
				+}
			
 
				+function stripBase(pathname, base) {
			
 
				+  if (!base || !pathname.toLowerCase().startsWith(base.toLowerCase())) return pathname;
			
 
				+  return pathname.slice(base.length) || "/";
			
 
				+}
			
 
				+function isSameRouteLocation(stringifyQuery$1, a, b) {
			
 
				+  const aLastIndex = a.matched.length - 1;
			
 
				+  const bLastIndex = b.matched.length - 1;
			
 
				+  return aLastIndex > -1 && aLastIndex === bLastIndex && isSameRouteRecord(a.matched[aLastIndex], b.matched[bLastIndex]) && isSameRouteLocationParams(a.params, b.params) && stringifyQuery$1(a.query) === stringifyQuery$1(b.query) && a.hash === b.hash;
			
 
				+}
			
 
				+function isSameRouteRecord(a, b) {
			
 
				+  return (a.aliasOf || a) === (b.aliasOf || b);
			
 
				+}
			
 
				+function isSameRouteLocationParams(a, b) {
			
 
				+  if (Object.keys(a).length !== Object.keys(b).length) return false;
			
 
				+  for (var key in a) if (!isSameRouteLocationParamsValue(a[key], b[key])) return false;
			
 
				+  return true;
			
 
				+}
			
 
				+function isSameRouteLocationParamsValue(a, b) {
			
 
				+  return isArray(a) ? isEquivalentArray(a, b) : isArray(b) ? isEquivalentArray(b, a) : (a == null ? void 0 : a.valueOf()) === (b == null ? void 0 : b.valueOf());
			
 
				+}
			
 
				+function isEquivalentArray(a, b) {
			
 
				+  return isArray(b) ? a.length === b.length && a.every((value, i) => value === b[i]) : a.length === 1 && a[0] === b;
			
 
				+}
			
 
				+function resolveRelativePath(to, from) {
			
 
				+  if (to.startsWith("/")) return to;
			
 
				+  if (!from.startsWith("/")) {
			
 
				+    warn$1(`Cannot resolve a relative location without an absolute path. Trying to resolve "${to}" from "${from}". It should look like "/${from}".`);
			
 
				+    return to;
			
 
				+  }
			
 
				+  if (!to) return from;
			
 
				+  const fromSegments = from.split("/");
			
 
				+  const toSegments = to.split("/");
			
 
				+  const lastToSegment = toSegments[toSegments.length - 1];
			
 
				+  if (lastToSegment === ".." || lastToSegment === ".") toSegments.push("");
			
 
				+  let position = fromSegments.length - 1;
			
 
				+  let toPosition;
			
 
				+  let segment;
			
 
				+  for (toPosition = 0; toPosition < toSegments.length; toPosition++) {
			
 
				+    segment = toSegments[toPosition];
			
 
				+    if (segment === ".") continue;
			
 
				+    if (segment === "..") {
			
 
				+      if (position > 1) position--;
			
 
				+    } else break;
			
 
				+  }
			
 
				+  return fromSegments.slice(0, position).join("/") + "/" + toSegments.slice(toPosition).join("/");
			
 
				+}
			
 
				+var START_LOCATION_NORMALIZED = {
			
 
				+  path: "/",
			
 
				+  name: void 0,
			
 
				+  params: {},
			
 
				+  query: {},
			
 
				+  hash: "",
			
 
				+  fullPath: "/",
			
 
				+  matched: [],
			
 
				+  meta: {},
			
 
				+  redirectedFrom: void 0
			
 
				+};
			
 
				+var NavigationType = function(NavigationType$1) {
			
 
				+  NavigationType$1["pop"] = "pop";
			
 
				+  NavigationType$1["push"] = "push";
			
 
				+  return NavigationType$1;
			
 
				+}({});
			
 
				+var NavigationDirection = function(NavigationDirection$1) {
			
 
				+  NavigationDirection$1["back"] = "back";
			
 
				+  NavigationDirection$1["forward"] = "forward";
			
 
				+  NavigationDirection$1["unknown"] = "";
			
 
				+  return NavigationDirection$1;
			
 
				+}({});
			
 
				+var START = "";
			
 
				+function normalizeBase(base) {
			
 
				+  if (!base) if (isBrowser) {
			
 
				+    const baseEl = document.querySelector("base");
			
 
				+    base = baseEl && baseEl.getAttribute("href") || "/";
			
 
				+    base = base.replace(/^\w+:\/\/[^\/]+/, "");
			
 
				+  } else base = "/";
			
 
				+  if (base[0] !== "/" && base[0] !== "#") base = "/" + base;
			
 
				+  return removeTrailingSlash(base);
			
 
				+}
			
 
				+var BEFORE_HASH_RE = /^[^#]+#/;
			
 
				+function createHref(base, location2) {
			
 
				+  return base.replace(BEFORE_HASH_RE, "#") + location2;
			
 
				+}
			
 
				+function getElementPosition(el, offset) {
			
 
				+  const docRect = document.documentElement.getBoundingClientRect();
			
 
				+  const elRect = el.getBoundingClientRect();
			
 
				+  return {
			
 
				+    behavior: offset.behavior,
			
 
				+    left: elRect.left - docRect.left - (offset.left || 0),
			
 
				+    top: elRect.top - docRect.top - (offset.top || 0)
			
 
				+  };
			
 
				+}
			
 
				+var computeScrollPosition = () => ({
			
 
				+  left: window.scrollX,
			
 
				+  top: window.scrollY
			
 
				+});
			
 
				+function scrollToPosition(position) {
			
 
				+  let scrollToOptions;
			
 
				+  if ("el" in position) {
			
 
				+    const positionEl = position.el;
			
 
				+    const isIdSelector = typeof positionEl === "string" && positionEl.startsWith("#");
			
 
				+    if (typeof position.el === "string") {
			
 
				+      if (!isIdSelector || !document.getElementById(position.el.slice(1))) try {
			
 
				+        const foundEl = document.querySelector(position.el);
			
 
				+        if (isIdSelector && foundEl) {
			
 
				+          warn$1(`The selector "${position.el}" should be passed as "el: document.querySelector('${position.el}')" because it starts with "#".`);
			
 
				+          return;
			
 
				+        }
			
 
				+      } catch (err) {
			
 
				+        warn$1(`The selector "${position.el}" is invalid. If you are using an id selector, make sure to escape it. You can find more information about escaping characters in selectors at https://mathiasbynens.be/notes/css-escapes or use CSS.escape (https://developer.mozilla.org/en-US/docs/Web/API/CSS/escape).`);
			
 
				+        return;
			
 
				+      }
			
 
				+    }
			
 
				+    const el = typeof positionEl === "string" ? isIdSelector ? document.getElementById(positionEl.slice(1)) : document.querySelector(positionEl) : positionEl;
			
 
				+    if (!el) {
			
 
				+      warn$1(`Couldn't find element using selector "${position.el}" returned by scrollBehavior.`);
			
 
				+      return;
			
 
				+    }
			
 
				+    scrollToOptions = getElementPosition(el, position);
			
 
				+  } else scrollToOptions = position;
			
 
				+  if ("scrollBehavior" in document.documentElement.style) window.scrollTo(scrollToOptions);
			
 
				+  else window.scrollTo(scrollToOptions.left != null ? scrollToOptions.left : window.scrollX, scrollToOptions.top != null ? scrollToOptions.top : window.scrollY);
			
 
				+}
			
 
				+function getScrollKey(path, delta) {
			
 
				+  return (history.state ? history.state.position - delta : -1) + path;
			
 
				+}
			
 
				+var scrollPositions = /* @__PURE__ */ new Map();
			
 
				+function saveScrollPosition(key, scrollPosition) {
			
 
				+  scrollPositions.set(key, scrollPosition);
			
 
				+}
			
 
				+function getSavedScrollPosition(key) {
			
 
				+  const scroll = scrollPositions.get(key);
			
 
				+  scrollPositions.delete(key);
			
 
				+  return scroll;
			
 
				+}
			
 
				+function isRouteLocation(route) {
			
 
				+  return typeof route === "string" || route && typeof route === "object";
			
 
				+}
			
 
				+function isRouteName(name) {
			
 
				+  return typeof name === "string" || typeof name === "symbol";
			
 
				+}
			
 
				+var ErrorTypes = function(ErrorTypes$1) {
			
 
				+  ErrorTypes$1[ErrorTypes$1["MATCHER_NOT_FOUND"] = 1] = "MATCHER_NOT_FOUND";
			
 
				+  ErrorTypes$1[ErrorTypes$1["NAVIGATION_GUARD_REDIRECT"] = 2] = "NAVIGATION_GUARD_REDIRECT";
			
 
				+  ErrorTypes$1[ErrorTypes$1["NAVIGATION_ABORTED"] = 4] = "NAVIGATION_ABORTED";
			
 
				+  ErrorTypes$1[ErrorTypes$1["NAVIGATION_CANCELLED"] = 8] = "NAVIGATION_CANCELLED";
			
 
				+  ErrorTypes$1[ErrorTypes$1["NAVIGATION_DUPLICATED"] = 16] = "NAVIGATION_DUPLICATED";
			
 
				+  return ErrorTypes$1;
			
 
				+}({});
			
 
				+var NavigationFailureSymbol = Symbol(true ? "navigation failure" : "");
			
 
				+var NavigationFailureType = function(NavigationFailureType$1) {
			
 
				+  NavigationFailureType$1[NavigationFailureType$1["aborted"] = 4] = "aborted";
			
 
				+  NavigationFailureType$1[NavigationFailureType$1["cancelled"] = 8] = "cancelled";
			
 
				+  NavigationFailureType$1[NavigationFailureType$1["duplicated"] = 16] = "duplicated";
			
 
				+  return NavigationFailureType$1;
			
 
				+}({});
			
 
				+var ErrorTypeMessages = {
			
 
				+  [ErrorTypes.MATCHER_NOT_FOUND]({ location: location2, currentLocation }) {
			
 
				+    return `No match for
			
 
				+ ${JSON.stringify(location2)}${currentLocation ? "\nwhile being at\n" + JSON.stringify(currentLocation) : ""}`;
			
 
				+  },
			
 
				+  [ErrorTypes.NAVIGATION_GUARD_REDIRECT]({ from, to }) {
			
 
				+    return `Redirected from "${from.fullPath}" to "${stringifyRoute(to)}" via a navigation guard.`;
			
 
				+  },
			
 
				+  [ErrorTypes.NAVIGATION_ABORTED]({ from, to }) {
			
 
				+    return `Navigation aborted from "${from.fullPath}" to "${to.fullPath}" via a navigation guard.`;
			
 
				+  },
			
 
				+  [ErrorTypes.NAVIGATION_CANCELLED]({ from, to }) {
			
 
				+    return `Navigation cancelled from "${from.fullPath}" to "${to.fullPath}" with a new navigation.`;
			
 
				+  },
			
 
				+  [ErrorTypes.NAVIGATION_DUPLICATED]({ from, to }) {
			
 
				+    return `Avoided redundant navigation to current location: "${from.fullPath}".`;
			
 
				+  }
			
 
				+};
			
 
				+function createRouterError(type, params) {
			
 
				+  if (true) return assign(new Error(ErrorTypeMessages[type](params)), {
			
 
				+    type,
			
 
				+    [NavigationFailureSymbol]: true
			
 
				+  }, params);
			
 
				+  else return assign(new Error(), {
			
 
				+    type,
			
 
				+    [NavigationFailureSymbol]: true
			
 
				+  }, params);
			
 
				+}
			
 
				+function isNavigationFailure(error, type) {
			
 
				+  return error instanceof Error && NavigationFailureSymbol in error && (type == null || !!(error.type & type));
			
 
				+}
			
 
				+var propertiesToLog = [
			
 
				+  "params",
			
 
				+  "query",
			
 
				+  "hash"
			
 
				+];
			
 
				+function stringifyRoute(to) {
			
 
				+  if (typeof to === "string") return to;
			
 
				+  if (to.path != null) return to.path;
			
 
				+  const location2 = {};
			
 
				+  for (const key of propertiesToLog) if (key in to) location2[key] = to[key];
			
 
				+  return JSON.stringify(location2, null, 2);
			
 
				+}
			
 
				+function parseQuery(search) {
			
 
				+  const query = {};
			
 
				+  if (search === "" || search === "?") return query;
			
 
				+  const searchParams = (search[0] === "?" ? search.slice(1) : search).split("&");
			
 
				+  for (let i = 0; i < searchParams.length; ++i) {
			
 
				+    const searchParam = searchParams[i].replace(PLUS_RE, " ");
			
 
				+    const eqPos = searchParam.indexOf("=");
			
 
				+    const key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));
			
 
				+    const value = eqPos < 0 ? null : decode(searchParam.slice(eqPos + 1));
			
 
				+    if (key in query) {
			
 
				+      let currentValue = query[key];
			
 
				+      if (!isArray(currentValue)) currentValue = query[key] = [currentValue];
			
 
				+      currentValue.push(value);
			
 
				+    } else query[key] = value;
			
 
				+  }
			
 
				+  return query;
			
 
				+}
			
 
				+function stringifyQuery(query) {
			
 
				+  let search = "";
			
 
				+  for (let key in query) {
			
 
				+    const value = query[key];
			
 
				+    key = encodeQueryKey(key);
			
 
				+    if (value == null) {
			
 
				+      if (value !== void 0) search += (search.length ? "&" : "") + key;
			
 
				+      continue;
			
 
				+    }
			
 
				+    (isArray(value) ? value.map((v) => v && encodeQueryValue(v)) : [value && encodeQueryValue(value)]).forEach((value$1) => {
			
 
				+      if (value$1 !== void 0) {
			
 
				+        search += (search.length ? "&" : "") + key;
			
 
				+        if (value$1 != null) search += "=" + value$1;
			
 
				+      }
			
 
				+    });
			
 
				+  }
			
 
				+  return search;
			
 
				+}
			
 
				+function normalizeQuery(query) {
			
 
				+  const normalizedQuery = {};
			
 
				+  for (const key in query) {
			
 
				+    const value = query[key];
			
 
				+    if (value !== void 0) normalizedQuery[key] = isArray(value) ? value.map((v) => v == null ? null : "" + v) : value == null ? value : "" + value;
			
 
				+  }
			
 
				+  return normalizedQuery;
			
 
				+}
			
 
				+var matchedRouteKey = Symbol(true ? "router view location matched" : "");
			
 
				+var viewDepthKey = Symbol(true ? "router view depth" : "");
			
 
				+var routerKey = Symbol(true ? "router" : "");
			
 
				+var routeLocationKey = Symbol(true ? "route location" : "");
			
 
				+var routerViewLocationKey = Symbol(true ? "router view location" : "");
			
 
				+function useCallbacks() {
			
 
				+  let handlers = [];
			
 
				+  function add(handler) {
			
 
				+    handlers.push(handler);
			
 
				+    return () => {
			
 
				+      const i = handlers.indexOf(handler);
			
 
				+      if (i > -1) handlers.splice(i, 1);
			
 
				+    };
			
 
				+  }
			
 
				+  function reset() {
			
 
				+    handlers = [];
			
 
				+  }
			
 
				+  return {
			
 
				+    add,
			
 
				+    list: () => handlers.slice(),
			
 
				+    reset
			
 
				+  };
			
 
				+}
			
 
				+function registerGuard(record, name, guard) {
			
 
				+  const removeFromList = () => {
			
 
				+    record[name].delete(guard);
			
 
				+  };
			
 
				+  onUnmounted(removeFromList);
			
 
				+  onDeactivated(removeFromList);
			
 
				+  onActivated(() => {
			
 
				+    record[name].add(guard);
			
 
				+  });
			
 
				+  record[name].add(guard);
			
 
				+}
			
 
				+function onBeforeRouteLeave(leaveGuard) {
			
 
				+  if (!getCurrentInstance()) {
			
 
				+    warn$1("getCurrentInstance() returned null. onBeforeRouteLeave() must be called at the top of a setup function");
			
 
				+    return;
			
 
				+  }
			
 
				+  const activeRecord = inject(matchedRouteKey, {}).value;
			
 
				+  if (!activeRecord) {
			
 
				+    warn$1("No active route record was found when calling `onBeforeRouteLeave()`. Make sure you call this function inside a component child of <router-view>. Maybe you called it inside of App.vue?");
			
 
				+    return;
			
 
				+  }
			
 
				+  registerGuard(activeRecord, "leaveGuards", leaveGuard);
			
 
				+}
			
 
				+function onBeforeRouteUpdate(updateGuard) {
			
 
				+  if (!getCurrentInstance()) {
			
 
				+    warn$1("getCurrentInstance() returned null. onBeforeRouteUpdate() must be called at the top of a setup function");
			
 
				+    return;
			
 
				+  }
			
 
				+  const activeRecord = inject(matchedRouteKey, {}).value;
			
 
				+  if (!activeRecord) {
			
 
				+    warn$1("No active route record was found when calling `onBeforeRouteUpdate()`. Make sure you call this function inside a component child of <router-view>. Maybe you called it inside of App.vue?");
			
 
				+    return;
			
 
				+  }
			
 
				+  registerGuard(activeRecord, "updateGuards", updateGuard);
			
 
				+}
			
 
				+function guardToPromiseFn(guard, to, from, record, name, runWithContext = (fn) => fn()) {
			
 
				+  const enterCallbackArray = record && (record.enterCallbacks[name] = record.enterCallbacks[name] || []);
			
 
				+  return () => new Promise((resolve, reject) => {
			
 
				+    const next = (valid) => {
			
 
				+      if (valid === false) reject(createRouterError(ErrorTypes.NAVIGATION_ABORTED, {
			
 
				+        from,
			
 
				+        to
			
 
				+      }));
			
 
				+      else if (valid instanceof Error) reject(valid);
			
 
				+      else if (isRouteLocation(valid)) reject(createRouterError(ErrorTypes.NAVIGATION_GUARD_REDIRECT, {
			
 
				+        from: to,
			
 
				+        to: valid
			
 
				+      }));
			
 
				+      else {
			
 
				+        if (enterCallbackArray && record.enterCallbacks[name] === enterCallbackArray && typeof valid === "function") enterCallbackArray.push(valid);
			
 
				+        resolve();
			
 
				+      }
			
 
				+    };
			
 
				+    const guardReturn = runWithContext(() => guard.call(record && record.instances[name], to, from, true ? canOnlyBeCalledOnce(next, to, from) : next));
			
 
				+    let guardCall = Promise.resolve(guardReturn);
			
 
				+    if (guard.length < 3) guardCall = guardCall.then(next);
			
 
				+    if (guard.length > 2) {
			
 
				+      const message = `The "next" callback was never called inside of ${guard.name ? '"' + guard.name + '"' : ""}:
			
 
				+${guard.toString()}
			
 
				+. If you are returning a value instead of calling "next", make sure to remove the "next" parameter from your function.`;
			
 
				+      if (typeof guardReturn === "object" && "then" in guardReturn) guardCall = guardCall.then((resolvedValue) => {
			
 
				+        if (!next._called) {
			
 
				+          warn$1(message);
			
 
				+          return Promise.reject(new Error("Invalid navigation guard"));
			
 
				+        }
			
 
				+        return resolvedValue;
			
 
				+      });
			
 
				+      else if (guardReturn !== void 0) {
			
 
				+        if (!next._called) {
			
 
				+          warn$1(message);
			
 
				+          reject(new Error("Invalid navigation guard"));
			
 
				+          return;
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+    guardCall.catch((err) => reject(err));
			
 
				+  });
			
 
				+}
			
 
				+function canOnlyBeCalledOnce(next, to, from) {
			
 
				+  let called = 0;
			
 
				+  return function() {
			
 
				+    if (called++ === 1) warn$1(`The "next" callback was called more than once in one navigation guard when going from "${from.fullPath}" to "${to.fullPath}". It should be called exactly one time in each navigation guard. This will fail in production.`);
			
 
				+    next._called = true;
			
 
				+    if (called === 1) next.apply(null, arguments);
			
 
				+  };
			
 
				+}
			
 
				+function extractComponentsGuards(matched, guardType, to, from, runWithContext = (fn) => fn()) {
			
 
				+  const guards = [];
			
 
				+  for (const record of matched) {
			
 
				+    if (!record.components && record.children && !record.children.length) warn$1(`Record with path "${record.path}" is either missing a "component(s)" or "children" property.`);
			
 
				+    for (const name in record.components) {
			
 
				+      let rawComponent = record.components[name];
			
 
				+      if (true) {
			
 
				+        if (!rawComponent || typeof rawComponent !== "object" && typeof rawComponent !== "function") {
			
 
				+          warn$1(`Component "${name}" in record with path "${record.path}" is not a valid component. Received "${String(rawComponent)}".`);
			
 
				+          throw new Error("Invalid route component");
			
 
				+        } else if ("then" in rawComponent) {
			
 
				+          warn$1(`Component "${name}" in record with path "${record.path}" is a Promise instead of a function that returns a Promise. Did you write "import('./MyPage.vue')" instead of "() => import('./MyPage.vue')" ? This will break in production if not fixed.`);
			
 
				+          const promise = rawComponent;
			
 
				+          rawComponent = () => promise;
			
 
				+        } else if (rawComponent.__asyncLoader && !rawComponent.__warnedDefineAsync) {
			
 
				+          rawComponent.__warnedDefineAsync = true;
			
 
				+          warn$1(`Component "${name}" in record with path "${record.path}" is defined using "defineAsyncComponent()". Write "() => import('./MyPage.vue')" instead of "defineAsyncComponent(() => import('./MyPage.vue'))".`);
			
 
				+        }
			
 
				+      }
			
 
				+      if (guardType !== "beforeRouteEnter" && !record.instances[name]) continue;
			
 
				+      if (isRouteComponent(rawComponent)) {
			
 
				+        const guard = (rawComponent.__vccOpts || rawComponent)[guardType];
			
 
				+        guard && guards.push(guardToPromiseFn(guard, to, from, record, name, runWithContext));
			
 
				+      } else {
			
 
				+        let componentPromise = rawComponent();
			
 
				+        if (!("catch" in componentPromise)) {
			
 
				+          warn$1(`Component "${name}" in record with path "${record.path}" is a function that does not return a Promise. If you were passing a functional component, make sure to add a "displayName" to the component. This will break in production if not fixed.`);
			
 
				+          componentPromise = Promise.resolve(componentPromise);
			
 
				+        }
			
 
				+        guards.push(() => componentPromise.then((resolved) => {
			
 
				+          if (!resolved) throw new Error(`Couldn't resolve component "${name}" at "${record.path}"`);
			
 
				+          const resolvedComponent = isESModule(resolved) ? resolved.default : resolved;
			
 
				+          record.mods[name] = resolved;
			
 
				+          record.components[name] = resolvedComponent;
			
 
				+          const guard = (resolvedComponent.__vccOpts || resolvedComponent)[guardType];
			
 
				+          return guard && guardToPromiseFn(guard, to, from, record, name, runWithContext)();
			
 
				+        }));
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+  return guards;
			
 
				+}
			
 
				+function loadRouteLocation(route) {
			
 
				+  return route.matched.every((record) => record.redirect) ? Promise.reject(new Error("Cannot load a route that redirects.")) : Promise.all(route.matched.map((record) => record.components && Promise.all(Object.keys(record.components).reduce((promises, name) => {
			
 
				+    const rawComponent = record.components[name];
			
 
				+    if (typeof rawComponent === "function" && !("displayName" in rawComponent)) promises.push(rawComponent().then((resolved) => {
			
 
				+      if (!resolved) return Promise.reject(new Error(`Couldn't resolve component "${name}" at "${record.path}". Ensure you passed a function that returns a promise.`));
			
 
				+      const resolvedComponent = isESModule(resolved) ? resolved.default : resolved;
			
 
				+      record.mods[name] = resolved;
			
 
				+      record.components[name] = resolvedComponent;
			
 
				+    }));
			
 
				+    return promises;
			
 
				+  }, [])))).then(() => route);
			
 
				+}
			
 
				+function extractChangingRecords(to, from) {
			
 
				+  const leavingRecords = [];
			
 
				+  const updatingRecords = [];
			
 
				+  const enteringRecords = [];
			
 
				+  const len = Math.max(from.matched.length, to.matched.length);
			
 
				+  for (let i = 0; i < len; i++) {
			
 
				+    const recordFrom = from.matched[i];
			
 
				+    if (recordFrom) if (to.matched.find((record) => isSameRouteRecord(record, recordFrom))) updatingRecords.push(recordFrom);
			
 
				+    else leavingRecords.push(recordFrom);
			
 
				+    const recordTo = to.matched[i];
			
 
				+    if (recordTo) {
			
 
				+      if (!from.matched.find((record) => isSameRouteRecord(record, recordTo))) enteringRecords.push(recordTo);
			
 
				+    }
			
 
				+  }
			
 
				+  return [
			
 
				+    leavingRecords,
			
 
				+    updatingRecords,
			
 
				+    enteringRecords
			
 
				+  ];
			
 
				+}
			
 
				+function formatRouteLocation(routeLocation, tooltip) {
			
 
				+  const copy = assign({}, routeLocation, { matched: routeLocation.matched.map((matched) => omit(matched, [
			
 
				+    "instances",
			
 
				+    "children",
			
 
				+    "aliasOf"
			
 
				+  ])) });
			
 
				+  return { _custom: {
			
 
				+    type: null,
			
 
				+    readOnly: true,
			
 
				+    display: routeLocation.fullPath,
			
 
				+    tooltip,
			
 
				+    value: copy
			
 
				+  } };
			
 
				+}
			
 
				+function formatDisplay(display) {
			
 
				+  return { _custom: { display } };
			
 
				+}
			
 
				+var routerId = 0;
			
 
				+function addDevtools(app, router, matcher) {
			
 
				+  if (router.__hasDevtools) return;
			
 
				+  router.__hasDevtools = true;
			
 
				+  const id = routerId++;
			
 
				+  setupDevtoolsPlugin({
			
 
				+    id: "org.vuejs.router" + (id ? "." + id : ""),
			
 
				+    label: "Vue Router",
			
 
				+    packageName: "vue-router",
			
 
				+    homepage: "https://router.vuejs.org",
			
 
				+    logo: "https://router.vuejs.org/logo.png",
			
 
				+    componentStateTypes: ["Routing"],
			
 
				+    app
			
 
				+  }, (api) => {
			
 
				+    if (typeof api.now !== "function") warn$1("[Vue Router]: You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html.");
			
 
				+    api.on.inspectComponent((payload, ctx) => {
			
 
				+      if (payload.instanceData) payload.instanceData.state.push({
			
 
				+        type: "Routing",
			
 
				+        key: "$route",
			
 
				+        editable: false,
			
 
				+        value: formatRouteLocation(router.currentRoute.value, "Current Route")
			
 
				+      });
			
 
				+    });
			
 
				+    api.on.visitComponentTree(({ treeNode: node, componentInstance }) => {
			
 
				+      if (componentInstance.__vrv_devtools) {
			
 
				+        const info = componentInstance.__vrv_devtools;
			
 
				+        node.tags.push({
			
 
				+          label: (info.name ? `${info.name.toString()}: ` : "") + info.path,
			
 
				+          textColor: 0,
			
 
				+          tooltip: "This component is rendered by &lt;router-view&gt;",
			
 
				+          backgroundColor: PINK_500
			
 
				+        });
			
 
				+      }
			
 
				+      if (isArray(componentInstance.__vrl_devtools)) {
			
 
				+        componentInstance.__devtoolsApi = api;
			
 
				+        componentInstance.__vrl_devtools.forEach((devtoolsData) => {
			
 
				+          let label = devtoolsData.route.path;
			
 
				+          let backgroundColor = ORANGE_400;
			
 
				+          let tooltip = "";
			
 
				+          let textColor = 0;
			
 
				+          if (devtoolsData.error) {
			
 
				+            label = devtoolsData.error;
			
 
				+            backgroundColor = RED_100;
			
 
				+            textColor = RED_700;
			
 
				+          } else if (devtoolsData.isExactActive) {
			
 
				+            backgroundColor = LIME_500;
			
 
				+            tooltip = "This is exactly active";
			
 
				+          } else if (devtoolsData.isActive) {
			
 
				+            backgroundColor = BLUE_600;
			
 
				+            tooltip = "This link is active";
			
 
				+          }
			
 
				+          node.tags.push({
			
 
				+            label,
			
 
				+            textColor,
			
 
				+            tooltip,
			
 
				+            backgroundColor
			
 
				+          });
			
 
				+        });
			
 
				+      }
			
 
				+    });
			
 
				+    watch(router.currentRoute, () => {
			
 
				+      refreshRoutesView();
			
 
				+      api.notifyComponentUpdate();
			
 
				+      api.sendInspectorTree(routerInspectorId);
			
 
				+      api.sendInspectorState(routerInspectorId);
			
 
				+    });
			
 
				+    const navigationsLayerId = "router:navigations:" + id;
			
 
				+    api.addTimelineLayer({
			
 
				+      id: navigationsLayerId,
			
 
				+      label: `Router${id ? " " + id : ""} Navigations`,
			
 
				+      color: 4237508
			
 
				+    });
			
 
				+    router.onError((error, to) => {
			
 
				+      api.addTimelineEvent({
			
 
				+        layerId: navigationsLayerId,
			
 
				+        event: {
			
 
				+          title: "Error during Navigation",
			
 
				+          subtitle: to.fullPath,
			
 
				+          logType: "error",
			
 
				+          time: api.now(),
			
 
				+          data: { error },
			
 
				+          groupId: to.meta.__navigationId
			
 
				+        }
			
 
				+      });
			
 
				+    });
			
 
				+    let navigationId = 0;
			
 
				+    router.beforeEach((to, from) => {
			
 
				+      const data = {
			
 
				+        guard: formatDisplay("beforeEach"),
			
 
				+        from: formatRouteLocation(from, "Current Location during this navigation"),
			
 
				+        to: formatRouteLocation(to, "Target location")
			
 
				+      };
			
 
				+      Object.defineProperty(to.meta, "__navigationId", { value: navigationId++ });
			
 
				+      api.addTimelineEvent({
			
 
				+        layerId: navigationsLayerId,
			
 
				+        event: {
			
 
				+          time: api.now(),
			
 
				+          title: "Start of navigation",
			
 
				+          subtitle: to.fullPath,
			
 
				+          data,
			
 
				+          groupId: to.meta.__navigationId
			
 
				+        }
			
 
				+      });
			
 
				+    });
			
 
				+    router.afterEach((to, from, failure) => {
			
 
				+      const data = { guard: formatDisplay("afterEach") };
			
 
				+      if (failure) {
			
 
				+        data.failure = { _custom: {
			
 
				+          type: Error,
			
 
				+          readOnly: true,
			
 
				+          display: failure ? failure.message : "",
			
 
				+          tooltip: "Navigation Failure",
			
 
				+          value: failure
			
 
				+        } };
			
 
				+        data.status = formatDisplay("❌");
			
 
				+      } else data.status = formatDisplay("✅");
			
 
				+      data.from = formatRouteLocation(from, "Current Location during this navigation");
			
 
				+      data.to = formatRouteLocation(to, "Target location");
			
 
				+      api.addTimelineEvent({
			
 
				+        layerId: navigationsLayerId,
			
 
				+        event: {
			
 
				+          title: "End of navigation",
			
 
				+          subtitle: to.fullPath,
			
 
				+          time: api.now(),
			
 
				+          data,
			
 
				+          logType: failure ? "warning" : "default",
			
 
				+          groupId: to.meta.__navigationId
			
 
				+        }
			
 
				+      });
			
 
				+    });
			
 
				+    const routerInspectorId = "router-inspector:" + id;
			
 
				+    api.addInspector({
			
 
				+      id: routerInspectorId,
			
 
				+      label: "Routes" + (id ? " " + id : ""),
			
 
				+      icon: "book",
			
 
				+      treeFilterPlaceholder: "Search routes"
			
 
				+    });
			
 
				+    function refreshRoutesView() {
			
 
				+      if (!activeRoutesPayload) return;
			
 
				+      const payload = activeRoutesPayload;
			
 
				+      let routes = matcher.getRoutes().filter((route) => !route.parent || !route.parent.record.components);
			
 
				+      routes.forEach(resetMatchStateOnRouteRecord);
			
 
				+      if (payload.filter) routes = routes.filter((route) => isRouteMatching(route, payload.filter.toLowerCase()));
			
 
				+      routes.forEach((route) => markRouteRecordActive(route, router.currentRoute.value));
			
 
				+      payload.rootNodes = routes.map(formatRouteRecordForInspector);
			
 
				+    }
			
 
				+    let activeRoutesPayload;
			
 
				+    api.on.getInspectorTree((payload) => {
			
 
				+      activeRoutesPayload = payload;
			
 
				+      if (payload.app === app && payload.inspectorId === routerInspectorId) refreshRoutesView();
			
 
				+    });
			
 
				+    api.on.getInspectorState((payload) => {
			
 
				+      if (payload.app === app && payload.inspectorId === routerInspectorId) {
			
 
				+        const route = matcher.getRoutes().find((route$1) => route$1.record.__vd_id === payload.nodeId);
			
 
				+        if (route) payload.state = { options: formatRouteRecordMatcherForStateInspector(route) };
			
 
				+      }
			
 
				+    });
			
 
				+    api.sendInspectorTree(routerInspectorId);
			
 
				+    api.sendInspectorState(routerInspectorId);
			
 
				+  });
			
 
				+}
			
 
				+function modifierForKey(key) {
			
 
				+  if (key.optional) return key.repeatable ? "*" : "?";
			
 
				+  else return key.repeatable ? "+" : "";
			
 
				+}
			
 
				+function formatRouteRecordMatcherForStateInspector(route) {
			
 
				+  const { record } = route;
			
 
				+  const fields = [{
			
 
				+    editable: false,
			
 
				+    key: "path",
			
 
				+    value: record.path
			
 
				+  }];
			
 
				+  if (record.name != null) fields.push({
			
 
				+    editable: false,
			
 
				+    key: "name",
			
 
				+    value: record.name
			
 
				+  });
			
 
				+  fields.push({
			
 
				+    editable: false,
			
 
				+    key: "regexp",
			
 
				+    value: route.re
			
 
				+  });
			
 
				+  if (route.keys.length) fields.push({
			
 
				+    editable: false,
			
 
				+    key: "keys",
			
 
				+    value: { _custom: {
			
 
				+      type: null,
			
 
				+      readOnly: true,
			
 
				+      display: route.keys.map((key) => `${key.name}${modifierForKey(key)}`).join(" "),
			
 
				+      tooltip: "Param keys",
			
 
				+      value: route.keys
			
 
				+    } }
			
 
				+  });
			
 
				+  if (record.redirect != null) fields.push({
			
 
				+    editable: false,
			
 
				+    key: "redirect",
			
 
				+    value: record.redirect
			
 
				+  });
			
 
				+  if (route.alias.length) fields.push({
			
 
				+    editable: false,
			
 
				+    key: "aliases",
			
 
				+    value: route.alias.map((alias) => alias.record.path)
			
 
				+  });
			
 
				+  if (Object.keys(route.record.meta).length) fields.push({
			
 
				+    editable: false,
			
 
				+    key: "meta",
			
 
				+    value: route.record.meta
			
 
				+  });
			
 
				+  fields.push({
			
 
				+    key: "score",
			
 
				+    editable: false,
			
 
				+    value: { _custom: {
			
 
				+      type: null,
			
 
				+      readOnly: true,
			
 
				+      display: route.score.map((score) => score.join(", ")).join(" | "),
			
 
				+      tooltip: "Score used to sort routes",
			
 
				+      value: route.score
			
 
				+    } }
			
 
				+  });
			
 
				+  return fields;
			
 
				+}
			
 
				+var PINK_500 = 15485081;
			
 
				+var BLUE_600 = 2450411;
			
 
				+var LIME_500 = 8702998;
			
 
				+var CYAN_400 = 2282478;
			
 
				+var ORANGE_400 = 16486972;
			
 
				+var DARK = 6710886;
			
 
				+var RED_100 = 16704226;
			
 
				+var RED_700 = 12131356;
			
 
				+function formatRouteRecordForInspector(route) {
			
 
				+  const tags = [];
			
 
				+  const { record } = route;
			
 
				+  if (record.name != null) tags.push({
			
 
				+    label: String(record.name),
			
 
				+    textColor: 0,
			
 
				+    backgroundColor: CYAN_400
			
 
				+  });
			
 
				+  if (record.aliasOf) tags.push({
			
 
				+    label: "alias",
			
 
				+    textColor: 0,
			
 
				+    backgroundColor: ORANGE_400
			
 
				+  });
			
 
				+  if (route.__vd_match) tags.push({
			
 
				+    label: "matches",
			
 
				+    textColor: 0,
			
 
				+    backgroundColor: PINK_500
			
 
				+  });
			
 
				+  if (route.__vd_exactActive) tags.push({
			
 
				+    label: "exact",
			
 
				+    textColor: 0,
			
 
				+    backgroundColor: LIME_500
			
 
				+  });
			
 
				+  if (route.__vd_active) tags.push({
			
 
				+    label: "active",
			
 
				+    textColor: 0,
			
 
				+    backgroundColor: BLUE_600
			
 
				+  });
			
 
				+  if (record.redirect) tags.push({
			
 
				+    label: typeof record.redirect === "string" ? `redirect: ${record.redirect}` : "redirects",
			
 
				+    textColor: 16777215,
			
 
				+    backgroundColor: DARK
			
 
				+  });
			
 
				+  let id = record.__vd_id;
			
 
				+  if (id == null) {
			
 
				+    id = String(routeRecordId++);
			
 
				+    record.__vd_id = id;
			
 
				+  }
			
 
				+  return {
			
 
				+    id,
			
 
				+    label: record.path,
			
 
				+    tags,
			
 
				+    children: route.children.map(formatRouteRecordForInspector)
			
 
				+  };
			
 
				+}
			
 
				+var routeRecordId = 0;
			
 
				+var EXTRACT_REGEXP_RE = /^\/(.*)\/([a-z]*)$/;
			
 
				+function markRouteRecordActive(route, currentRoute) {
			
 
				+  const isExactActive = currentRoute.matched.length && isSameRouteRecord(currentRoute.matched[currentRoute.matched.length - 1], route.record);
			
 
				+  route.__vd_exactActive = route.__vd_active = isExactActive;
			
 
				+  if (!isExactActive) route.__vd_active = currentRoute.matched.some((match) => isSameRouteRecord(match, route.record));
			
 
				+  route.children.forEach((childRoute) => markRouteRecordActive(childRoute, currentRoute));
			
 
				+}
			
 
				+function resetMatchStateOnRouteRecord(route) {
			
 
				+  route.__vd_match = false;
			
 
				+  route.children.forEach(resetMatchStateOnRouteRecord);
			
 
				+}
			
 
				+function isRouteMatching(route, filter) {
			
 
				+  const found = String(route.re).match(EXTRACT_REGEXP_RE);
			
 
				+  route.__vd_match = false;
			
 
				+  if (!found || found.length < 3) return false;
			
 
				+  if (new RegExp(found[1].replace(/\$$/, ""), found[2]).test(filter)) {
			
 
				+    route.children.forEach((child) => isRouteMatching(child, filter));
			
 
				+    if (route.record.path !== "/" || filter === "/") {
			
 
				+      route.__vd_match = route.re.test(filter);
			
 
				+      return true;
			
 
				+    }
			
 
				+    return false;
			
 
				+  }
			
 
				+  const path = route.record.path.toLowerCase();
			
 
				+  const decodedPath = decode(path);
			
 
				+  if (!filter.startsWith("/") && (decodedPath.includes(filter) || path.includes(filter))) return true;
			
 
				+  if (decodedPath.startsWith(filter) || path.startsWith(filter)) return true;
			
 
				+  if (route.record.name && String(route.record.name).includes(filter)) return true;
			
 
				+  return route.children.some((child) => isRouteMatching(child, filter));
			
 
				+}
			
 
				+function omit(obj, keys) {
			
 
				+  const ret = {};
			
 
				+  for (const key in obj) if (!keys.includes(key)) ret[key] = obj[key];
			
 
				+  return ret;
			
 
				+}
			
 
				+
			
 
				+// node_modules/vue-router/dist/vue-router.mjs
			
 
				+var createBaseLocation = () => location.protocol + "//" + location.host;
			
 
				+function createCurrentLocation(base, location$1) {
			
 
				+  const { pathname, search, hash } = location$1;
			
 
				+  const hashPos = base.indexOf("#");
			
 
				+  if (hashPos > -1) {
			
 
				+    let slicePos = hash.includes(base.slice(hashPos)) ? base.slice(hashPos).length : 1;
			
 
				+    let pathFromHash = hash.slice(slicePos);
			
 
				+    if (pathFromHash[0] !== "/") pathFromHash = "/" + pathFromHash;
			
 
				+    return stripBase(pathFromHash, "");
			
 
				+  }
			
 
				+  return stripBase(pathname, base) + search + hash;
			
 
				+}
			
 
				+function useHistoryListeners(base, historyState, currentLocation, replace) {
			
 
				+  let listeners = [];
			
 
				+  let teardowns = [];
			
 
				+  let pauseState = null;
			
 
				+  const popStateHandler = ({ state }) => {
			
 
				+    const to = createCurrentLocation(base, location);
			
 
				+    const from = currentLocation.value;
			
 
				+    const fromState = historyState.value;
			
 
				+    let delta = 0;
			
 
				+    if (state) {
			
 
				+      currentLocation.value = to;
			
 
				+      historyState.value = state;
			
 
				+      if (pauseState && pauseState === from) {
			
 
				+        pauseState = null;
			
 
				+        return;
			
 
				+      }
			
 
				+      delta = fromState ? state.position - fromState.position : 0;
			
 
				+    } else replace(to);
			
 
				+    listeners.forEach((listener) => {
			
 
				+      listener(currentLocation.value, from, {
			
 
				+        delta,
			
 
				+        type: NavigationType.pop,
			
 
				+        direction: delta ? delta > 0 ? NavigationDirection.forward : NavigationDirection.back : NavigationDirection.unknown
			
 
				+      });
			
 
				+    });
			
 
				+  };
			
 
				+  function pauseListeners() {
			
 
				+    pauseState = currentLocation.value;
			
 
				+  }
			
 
				+  function listen(callback) {
			
 
				+    listeners.push(callback);
			
 
				+    const teardown = () => {
			
 
				+      const index = listeners.indexOf(callback);
			
 
				+      if (index > -1) listeners.splice(index, 1);
			
 
				+    };
			
 
				+    teardowns.push(teardown);
			
 
				+    return teardown;
			
 
				+  }
			
 
				+  function beforeUnloadListener() {
			
 
				+    if (document.visibilityState === "hidden") {
			
 
				+      const { history: history$1 } = window;
			
 
				+      if (!history$1.state) return;
			
 
				+      history$1.replaceState(assign({}, history$1.state, { scroll: computeScrollPosition() }), "");
			
 
				+    }
			
 
				+  }
			
 
				+  function destroy() {
			
 
				+    for (const teardown of teardowns) teardown();
			
 
				+    teardowns = [];
			
 
				+    window.removeEventListener("popstate", popStateHandler);
			
 
				+    window.removeEventListener("pagehide", beforeUnloadListener);
			
 
				+    document.removeEventListener("visibilitychange", beforeUnloadListener);
			
 
				+  }
			
 
				+  window.addEventListener("popstate", popStateHandler);
			
 
				+  window.addEventListener("pagehide", beforeUnloadListener);
			
 
				+  document.addEventListener("visibilitychange", beforeUnloadListener);
			
 
				+  return {
			
 
				+    pauseListeners,
			
 
				+    listen,
			
 
				+    destroy
			
 
				+  };
			
 
				+}
			
 
				+function buildState(back, current, forward, replaced = false, computeScroll = false) {
			
 
				+  return {
			
 
				+    back,
			
 
				+    current,
			
 
				+    forward,
			
 
				+    replaced,
			
 
				+    position: window.history.length,
			
 
				+    scroll: computeScroll ? computeScrollPosition() : null
			
 
				+  };
			
 
				+}
			
 
				+function useHistoryStateNavigation(base) {
			
 
				+  const { history: history$1, location: location$1 } = window;
			
 
				+  const currentLocation = { value: createCurrentLocation(base, location$1) };
			
 
				+  const historyState = { value: history$1.state };
			
 
				+  if (!historyState.value) changeLocation(currentLocation.value, {
			
 
				+    back: null,
			
 
				+    current: currentLocation.value,
			
 
				+    forward: null,
			
 
				+    position: history$1.length - 1,
			
 
				+    replaced: true,
			
 
				+    scroll: null
			
 
				+  }, true);
			
 
				+  function changeLocation(to, state, replace$1) {
			
 
				+    const hashIndex = base.indexOf("#");
			
 
				+    const url = hashIndex > -1 ? (location$1.host && document.querySelector("base") ? base : base.slice(hashIndex)) + to : createBaseLocation() + base + to;
			
 
				+    try {
			
 
				+      history$1[replace$1 ? "replaceState" : "pushState"](state, "", url);
			
 
				+      historyState.value = state;
			
 
				+    } catch (err) {
			
 
				+      if (true) warn$1("Error with push/replace State", err);
			
 
				+      else console.error(err);
			
 
				+      location$1[replace$1 ? "replace" : "assign"](url);
			
 
				+    }
			
 
				+  }
			
 
				+  function replace(to, data) {
			
 
				+    changeLocation(to, assign({}, history$1.state, buildState(historyState.value.back, to, historyState.value.forward, true), data, { position: historyState.value.position }), true);
			
 
				+    currentLocation.value = to;
			
 
				+  }
			
 
				+  function push(to, data) {
			
 
				+    const currentState = assign({}, historyState.value, history$1.state, {
			
 
				+      forward: to,
			
 
				+      scroll: computeScrollPosition()
			
 
				+    });
			
 
				+    if (!history$1.state) warn$1("history.state seems to have been manually replaced without preserving the necessary values. Make sure to preserve existing history state if you are manually calling history.replaceState:\n\nhistory.replaceState(history.state, '', url)\n\nYou can find more information at https://router.vuejs.org/guide/migration/#Usage-of-history-state");
			
 
				+    changeLocation(currentState.current, currentState, true);
			
 
				+    changeLocation(to, assign({}, buildState(currentLocation.value, to, null), { position: currentState.position + 1 }, data), false);
			
 
				+    currentLocation.value = to;
			
 
				+  }
			
 
				+  return {
			
 
				+    location: currentLocation,
			
 
				+    state: historyState,
			
 
				+    push,
			
 
				+    replace
			
 
				+  };
			
 
				+}
			
 
				+function createWebHistory(base) {
			
 
				+  base = normalizeBase(base);
			
 
				+  const historyNavigation = useHistoryStateNavigation(base);
			
 
				+  const historyListeners = useHistoryListeners(base, historyNavigation.state, historyNavigation.location, historyNavigation.replace);
			
 
				+  function go(delta, triggerListeners = true) {
			
 
				+    if (!triggerListeners) historyListeners.pauseListeners();
			
 
				+    history.go(delta);
			
 
				+  }
			
 
				+  const routerHistory = assign({
			
 
				+    location: "",
			
 
				+    base,
			
 
				+    go,
			
 
				+    createHref: createHref.bind(null, base)
			
 
				+  }, historyNavigation, historyListeners);
			
 
				+  Object.defineProperty(routerHistory, "location", {
			
 
				+    enumerable: true,
			
 
				+    get: () => historyNavigation.location.value
			
 
				+  });
			
 
				+  Object.defineProperty(routerHistory, "state", {
			
 
				+    enumerable: true,
			
 
				+    get: () => historyNavigation.state.value
			
 
				+  });
			
 
				+  return routerHistory;
			
 
				+}
			
 
				+function createMemoryHistory(base = "") {
			
 
				+  let listeners = [];
			
 
				+  let queue = [[START, {}]];
			
 
				+  let position = 0;
			
 
				+  base = normalizeBase(base);
			
 
				+  function setLocation(location$1, state = {}) {
			
 
				+    position++;
			
 
				+    if (position !== queue.length) queue.splice(position);
			
 
				+    queue.push([location$1, state]);
			
 
				+  }
			
 
				+  function triggerListeners(to, from, { direction, delta }) {
			
 
				+    const info = {
			
 
				+      direction,
			
 
				+      delta,
			
 
				+      type: NavigationType.pop
			
 
				+    };
			
 
				+    for (const callback of listeners) callback(to, from, info);
			
 
				+  }
			
 
				+  const routerHistory = {
			
 
				+    location: START,
			
 
				+    state: {},
			
 
				+    base,
			
 
				+    createHref: createHref.bind(null, base),
			
 
				+    replace(to, state) {
			
 
				+      queue.splice(position--, 1);
			
 
				+      setLocation(to, state);
			
 
				+    },
			
 
				+    push(to, state) {
			
 
				+      setLocation(to, state);
			
 
				+    },
			
 
				+    listen(callback) {
			
 
				+      listeners.push(callback);
			
 
				+      return () => {
			
 
				+        const index = listeners.indexOf(callback);
			
 
				+        if (index > -1) listeners.splice(index, 1);
			
 
				+      };
			
 
				+    },
			
 
				+    destroy() {
			
 
				+      listeners = [];
			
 
				+      queue = [[START, {}]];
			
 
				+      position = 0;
			
 
				+    },
			
 
				+    go(delta, shouldTrigger = true) {
			
 
				+      const from = this.location;
			
 
				+      const direction = delta < 0 ? NavigationDirection.back : NavigationDirection.forward;
			
 
				+      position = Math.max(0, Math.min(position + delta, queue.length - 1));
			
 
				+      if (shouldTrigger) triggerListeners(this.location, from, {
			
 
				+        direction,
			
 
				+        delta
			
 
				+      });
			
 
				+    }
			
 
				+  };
			
 
				+  Object.defineProperty(routerHistory, "location", {
			
 
				+    enumerable: true,
			
 
				+    get: () => queue[position][0]
			
 
				+  });
			
 
				+  Object.defineProperty(routerHistory, "state", {
			
 
				+    enumerable: true,
			
 
				+    get: () => queue[position][1]
			
 
				+  });
			
 
				+  return routerHistory;
			
 
				+}
			
 
				+function createWebHashHistory(base) {
			
 
				+  base = location.host ? base || location.pathname + location.search : "";
			
 
				+  if (!base.includes("#")) base += "#";
			
 
				+  if (!base.endsWith("#/") && !base.endsWith("#")) warn$1(`A hash base must end with a "#":
			
 
				+"${base}" should be "${base.replace(/#.*$/, "#")}".`);
			
 
				+  return createWebHistory(base);
			
 
				+}
			
 
				+var TokenType = function(TokenType$1) {
			
 
				+  TokenType$1[TokenType$1["Static"] = 0] = "Static";
			
 
				+  TokenType$1[TokenType$1["Param"] = 1] = "Param";
			
 
				+  TokenType$1[TokenType$1["Group"] = 2] = "Group";
			
 
				+  return TokenType$1;
			
 
				+}({});
			
 
				+var TokenizerState = function(TokenizerState$1) {
			
 
				+  TokenizerState$1[TokenizerState$1["Static"] = 0] = "Static";
			
 
				+  TokenizerState$1[TokenizerState$1["Param"] = 1] = "Param";
			
 
				+  TokenizerState$1[TokenizerState$1["ParamRegExp"] = 2] = "ParamRegExp";
			
 
				+  TokenizerState$1[TokenizerState$1["ParamRegExpEnd"] = 3] = "ParamRegExpEnd";
			
 
				+  TokenizerState$1[TokenizerState$1["EscapeNext"] = 4] = "EscapeNext";
			
 
				+  return TokenizerState$1;
			
 
				+}(TokenizerState || {});
			
 
				+var ROOT_TOKEN = {
			
 
				+  type: TokenType.Static,
			
 
				+  value: ""
			
 
				+};
			
 
				+var VALID_PARAM_RE = /[a-zA-Z0-9_]/;
			
 
				+function tokenizePath(path) {
			
 
				+  if (!path) return [[]];
			
 
				+  if (path === "/") return [[ROOT_TOKEN]];
			
 
				+  if (!path.startsWith("/")) throw new Error(true ? `Route paths should start with a "/": "${path}" should be "/${path}".` : `Invalid path "${path}"`);
			
 
				+  function crash(message) {
			
 
				+    throw new Error(`ERR (${state})/"${buffer}": ${message}`);
			
 
				+  }
			
 
				+  let state = TokenizerState.Static;
			
 
				+  let previousState = state;
			
 
				+  const tokens = [];
			
 
				+  let segment;
			
 
				+  function finalizeSegment() {
			
 
				+    if (segment) tokens.push(segment);
			
 
				+    segment = [];
			
 
				+  }
			
 
				+  let i = 0;
			
 
				+  let char;
			
 
				+  let buffer = "";
			
 
				+  let customRe = "";
			
 
				+  function consumeBuffer() {
			
 
				+    if (!buffer) return;
			
 
				+    if (state === TokenizerState.Static) segment.push({
			
 
				+      type: TokenType.Static,
			
 
				+      value: buffer
			
 
				+    });
			
 
				+    else if (state === TokenizerState.Param || state === TokenizerState.ParamRegExp || state === TokenizerState.ParamRegExpEnd) {
			
 
				+      if (segment.length > 1 && (char === "*" || char === "+")) crash(`A repeatable param (${buffer}) must be alone in its segment. eg: '/:ids+.`);
			
 
				+      segment.push({
			
 
				+        type: TokenType.Param,
			
 
				+        value: buffer,
			
 
				+        regexp: customRe,
			
 
				+        repeatable: char === "*" || char === "+",
			
 
				+        optional: char === "*" || char === "?"
			
 
				+      });
			
 
				+    } else crash("Invalid state to consume buffer");
			
 
				+    buffer = "";
			
 
				+  }
			
 
				+  function addCharToBuffer() {
			
 
				+    buffer += char;
			
 
				+  }
			
 
				+  while (i < path.length) {
			
 
				+    char = path[i++];
			
 
				+    if (char === "\\" && state !== TokenizerState.ParamRegExp) {
			
 
				+      previousState = state;
			
 
				+      state = TokenizerState.EscapeNext;
			
 
				+      continue;
			
 
				+    }
			
 
				+    switch (state) {
			
 
				+      case TokenizerState.Static:
			
 
				+        if (char === "/") {
			
 
				+          if (buffer) consumeBuffer();
			
 
				+          finalizeSegment();
			
 
				+        } else if (char === ":") {
			
 
				+          consumeBuffer();
			
 
				+          state = TokenizerState.Param;
			
 
				+        } else addCharToBuffer();
			
 
				+        break;
			
 
				+      case TokenizerState.EscapeNext:
			
 
				+        addCharToBuffer();
			
 
				+        state = previousState;
			
 
				+        break;
			
 
				+      case TokenizerState.Param:
			
 
				+        if (char === "(") state = TokenizerState.ParamRegExp;
			
 
				+        else if (VALID_PARAM_RE.test(char)) addCharToBuffer();
			
 
				+        else {
			
 
				+          consumeBuffer();
			
 
				+          state = TokenizerState.Static;
			
 
				+          if (char !== "*" && char !== "?" && char !== "+") i--;
			
 
				+        }
			
 
				+        break;
			
 
				+      case TokenizerState.ParamRegExp:
			
 
				+        if (char === ")") if (customRe[customRe.length - 1] == "\\") customRe = customRe.slice(0, -1) + char;
			
 
				+        else state = TokenizerState.ParamRegExpEnd;
			
 
				+        else customRe += char;
			
 
				+        break;
			
 
				+      case TokenizerState.ParamRegExpEnd:
			
 
				+        consumeBuffer();
			
 
				+        state = TokenizerState.Static;
			
 
				+        if (char !== "*" && char !== "?" && char !== "+") i--;
			
 
				+        customRe = "";
			
 
				+        break;
			
 
				+      default:
			
 
				+        crash("Unknown state");
			
 
				+        break;
			
 
				+    }
			
 
				+  }
			
 
				+  if (state === TokenizerState.ParamRegExp) crash(`Unfinished custom RegExp for param "${buffer}"`);
			
 
				+  consumeBuffer();
			
 
				+  finalizeSegment();
			
 
				+  return tokens;
			
 
				+}
			
 
				+var BASE_PARAM_PATTERN = "[^/]+?";
			
 
				+var BASE_PATH_PARSER_OPTIONS = {
			
 
				+  sensitive: false,
			
 
				+  strict: false,
			
 
				+  start: true,
			
 
				+  end: true
			
 
				+};
			
 
				+var PathScore = function(PathScore$1) {
			
 
				+  PathScore$1[PathScore$1["_multiplier"] = 10] = "_multiplier";
			
 
				+  PathScore$1[PathScore$1["Root"] = 90] = "Root";
			
 
				+  PathScore$1[PathScore$1["Segment"] = 40] = "Segment";
			
 
				+  PathScore$1[PathScore$1["SubSegment"] = 30] = "SubSegment";
			
 
				+  PathScore$1[PathScore$1["Static"] = 40] = "Static";
			
 
				+  PathScore$1[PathScore$1["Dynamic"] = 20] = "Dynamic";
			
 
				+  PathScore$1[PathScore$1["BonusCustomRegExp"] = 10] = "BonusCustomRegExp";
			
 
				+  PathScore$1[PathScore$1["BonusWildcard"] = -50] = "BonusWildcard";
			
 
				+  PathScore$1[PathScore$1["BonusRepeatable"] = -20] = "BonusRepeatable";
			
 
				+  PathScore$1[PathScore$1["BonusOptional"] = -8] = "BonusOptional";
			
 
				+  PathScore$1[PathScore$1["BonusStrict"] = 0.7000000000000001] = "BonusStrict";
			
 
				+  PathScore$1[PathScore$1["BonusCaseSensitive"] = 0.25] = "BonusCaseSensitive";
			
 
				+  return PathScore$1;
			
 
				+}(PathScore || {});
			
 
				+var REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
			
 
				+function tokensToParser(segments, extraOptions) {
			
 
				+  const options = assign({}, BASE_PATH_PARSER_OPTIONS, extraOptions);
			
 
				+  const score = [];
			
 
				+  let pattern = options.start ? "^" : "";
			
 
				+  const keys = [];
			
 
				+  for (const segment of segments) {
			
 
				+    const segmentScores = segment.length ? [] : [PathScore.Root];
			
 
				+    if (options.strict && !segment.length) pattern += "/";
			
 
				+    for (let tokenIndex = 0; tokenIndex < segment.length; tokenIndex++) {
			
 
				+      const token = segment[tokenIndex];
			
 
				+      let subSegmentScore = PathScore.Segment + (options.sensitive ? PathScore.BonusCaseSensitive : 0);
			
 
				+      if (token.type === TokenType.Static) {
			
 
				+        if (!tokenIndex) pattern += "/";
			
 
				+        pattern += token.value.replace(REGEX_CHARS_RE, "\\$&");
			
 
				+        subSegmentScore += PathScore.Static;
			
 
				+      } else if (token.type === TokenType.Param) {
			
 
				+        const { value, repeatable, optional, regexp } = token;
			
 
				+        keys.push({
			
 
				+          name: value,
			
 
				+          repeatable,
			
 
				+          optional
			
 
				+        });
			
 
				+        const re$1 = regexp ? regexp : BASE_PARAM_PATTERN;
			
 
				+        if (re$1 !== BASE_PARAM_PATTERN) {
			
 
				+          subSegmentScore += PathScore.BonusCustomRegExp;
			
 
				+          try {
			
 
				+            `${re$1}`;
			
 
				+          } catch (err) {
			
 
				+            throw new Error(`Invalid custom RegExp for param "${value}" (${re$1}): ` + err.message);
			
 
				+          }
			
 
				+        }
			
 
				+        let subPattern = repeatable ? `((?:${re$1})(?:/(?:${re$1}))*)` : `(${re$1})`;
			
 
				+        if (!tokenIndex) subPattern = optional && segment.length < 2 ? `(?:/${subPattern})` : "/" + subPattern;
			
 
				+        if (optional) subPattern += "?";
			
 
				+        pattern += subPattern;
			
 
				+        subSegmentScore += PathScore.Dynamic;
			
 
				+        if (optional) subSegmentScore += PathScore.BonusOptional;
			
 
				+        if (repeatable) subSegmentScore += PathScore.BonusRepeatable;
			
 
				+        if (re$1 === ".*") subSegmentScore += PathScore.BonusWildcard;
			
 
				+      }
			
 
				+      segmentScores.push(subSegmentScore);
			
 
				+    }
			
 
				+    score.push(segmentScores);
			
 
				+  }
			
 
				+  if (options.strict && options.end) {
			
 
				+    const i = score.length - 1;
			
 
				+    score[i][score[i].length - 1] += PathScore.BonusStrict;
			
 
				+  }
			
 
				+  if (!options.strict) pattern += "/?";
			
 
				+  if (options.end) pattern += "$";
			
 
				+  else if (options.strict && !pattern.endsWith("/")) pattern += "(?:/|$)";
			
 
				+  const re = new RegExp(pattern, options.sensitive ? "" : "i");
			
 
				+  function parse(path) {
			
 
				+    const match = path.match(re);
			
 
				+    const params = {};
			
 
				+    if (!match) return null;
			
 
				+    for (let i = 1; i < match.length; i++) {
			
 
				+      const value = match[i] || "";
			
 
				+      const key = keys[i - 1];
			
 
				+      params[key.name] = value && key.repeatable ? value.split("/") : value;
			
 
				+    }
			
 
				+    return params;
			
 
				+  }
			
 
				+  function stringify(params) {
			
 
				+    let path = "";
			
 
				+    let avoidDuplicatedSlash = false;
			
 
				+    for (const segment of segments) {
			
 
				+      if (!avoidDuplicatedSlash || !path.endsWith("/")) path += "/";
			
 
				+      avoidDuplicatedSlash = false;
			
 
				+      for (const token of segment) if (token.type === TokenType.Static) path += token.value;
			
 
				+      else if (token.type === TokenType.Param) {
			
 
				+        const { value, repeatable, optional } = token;
			
 
				+        const param = value in params ? params[value] : "";
			
 
				+        if (isArray(param) && !repeatable) throw new Error(`Provided param "${value}" is an array but it is not repeatable (* or + modifiers)`);
			
 
				+        const text = isArray(param) ? param.join("/") : param;
			
 
				+        if (!text) if (optional) {
			
 
				+          if (segment.length < 2) if (path.endsWith("/")) path = path.slice(0, -1);
			
 
				+          else avoidDuplicatedSlash = true;
			
 
				+        } else throw new Error(`Missing required param "${value}"`);
			
 
				+        path += text;
			
 
				+      }
			
 
				+    }
			
 
				+    return path || "/";
			
 
				+  }
			
 
				+  return {
			
 
				+    re,
			
 
				+    score,
			
 
				+    keys,
			
 
				+    parse,
			
 
				+    stringify
			
 
				+  };
			
 
				+}
			
 
				+function compareScoreArray(a, b) {
			
 
				+  let i = 0;
			
 
				+  while (i < a.length && i < b.length) {
			
 
				+    const diff = b[i] - a[i];
			
 
				+    if (diff) return diff;
			
 
				+    i++;
			
 
				+  }
			
 
				+  if (a.length < b.length) return a.length === 1 && a[0] === PathScore.Static + PathScore.Segment ? -1 : 1;
			
 
				+  else if (a.length > b.length) return b.length === 1 && b[0] === PathScore.Static + PathScore.Segment ? 1 : -1;
			
 
				+  return 0;
			
 
				+}
			
 
				+function comparePathParserScore(a, b) {
			
 
				+  let i = 0;
			
 
				+  const aScore = a.score;
			
 
				+  const bScore = b.score;
			
 
				+  while (i < aScore.length && i < bScore.length) {
			
 
				+    const comp = compareScoreArray(aScore[i], bScore[i]);
			
 
				+    if (comp) return comp;
			
 
				+    i++;
			
 
				+  }
			
 
				+  if (Math.abs(bScore.length - aScore.length) === 1) {
			
 
				+    if (isLastScoreNegative(aScore)) return 1;
			
 
				+    if (isLastScoreNegative(bScore)) return -1;
			
 
				+  }
			
 
				+  return bScore.length - aScore.length;
			
 
				+}
			
 
				+function isLastScoreNegative(score) {
			
 
				+  const last = score[score.length - 1];
			
 
				+  return score.length > 0 && last[last.length - 1] < 0;
			
 
				+}
			
 
				+var PATH_PARSER_OPTIONS_DEFAULTS = {
			
 
				+  strict: false,
			
 
				+  end: true,
			
 
				+  sensitive: false
			
 
				+};
			
 
				+function createRouteRecordMatcher(record, parent, options) {
			
 
				+  const parser = tokensToParser(tokenizePath(record.path), options);
			
 
				+  if (true) {
			
 
				+    const existingKeys = /* @__PURE__ */ new Set();
			
 
				+    for (const key of parser.keys) {
			
 
				+      if (existingKeys.has(key.name)) warn$1(`Found duplicated params with name "${key.name}" for path "${record.path}". Only the last one will be available on "$route.params".`);
			
 
				+      existingKeys.add(key.name);
			
 
				+    }
			
 
				+  }
			
 
				+  const matcher = assign(parser, {
			
 
				+    record,
			
 
				+    parent,
			
 
				+    children: [],
			
 
				+    alias: []
			
 
				+  });
			
 
				+  if (parent) {
			
 
				+    if (!matcher.record.aliasOf === !parent.record.aliasOf) parent.children.push(matcher);
			
 
				+  }
			
 
				+  return matcher;
			
 
				+}
			
 
				+function createRouterMatcher(routes, globalOptions) {
			
 
				+  const matchers = [];
			
 
				+  const matcherMap = /* @__PURE__ */ new Map();
			
 
				+  globalOptions = mergeOptions(PATH_PARSER_OPTIONS_DEFAULTS, globalOptions);
			
 
				+  function getRecordMatcher(name) {
			
 
				+    return matcherMap.get(name);
			
 
				+  }
			
 
				+  function addRoute(record, parent, originalRecord) {
			
 
				+    const isRootAdd = !originalRecord;
			
 
				+    const mainNormalizedRecord = normalizeRouteRecord(record);
			
 
				+    if (true) checkChildMissingNameWithEmptyPath(mainNormalizedRecord, parent);
			
 
				+    mainNormalizedRecord.aliasOf = originalRecord && originalRecord.record;
			
 
				+    const options = mergeOptions(globalOptions, record);
			
 
				+    const normalizedRecords = [mainNormalizedRecord];
			
 
				+    if ("alias" in record) {
			
 
				+      const aliases = typeof record.alias === "string" ? [record.alias] : record.alias;
			
 
				+      for (const alias of aliases) normalizedRecords.push(normalizeRouteRecord(assign({}, mainNormalizedRecord, {
			
 
				+        components: originalRecord ? originalRecord.record.components : mainNormalizedRecord.components,
			
 
				+        path: alias,
			
 
				+        aliasOf: originalRecord ? originalRecord.record : mainNormalizedRecord
			
 
				+      })));
			
 
				+    }
			
 
				+    let matcher;
			
 
				+    let originalMatcher;
			
 
				+    for (const normalizedRecord of normalizedRecords) {
			
 
				+      const { path } = normalizedRecord;
			
 
				+      if (parent && path[0] !== "/") {
			
 
				+        const parentPath = parent.record.path;
			
 
				+        const connectingSlash = parentPath[parentPath.length - 1] === "/" ? "" : "/";
			
 
				+        normalizedRecord.path = parent.record.path + (path && connectingSlash + path);
			
 
				+      }
			
 
				+      if (normalizedRecord.path === "*") throw new Error('Catch all routes ("*") must now be defined using a param with a custom regexp.\nSee more at https://router.vuejs.org/guide/migration/#Removed-star-or-catch-all-routes.');
			
 
				+      matcher = createRouteRecordMatcher(normalizedRecord, parent, options);
			
 
				+      if (parent && path[0] === "/") checkMissingParamsInAbsolutePath(matcher, parent);
			
 
				+      if (originalRecord) {
			
 
				+        originalRecord.alias.push(matcher);
			
 
				+        if (true) checkSameParams(originalRecord, matcher);
			
 
				+      } else {
			
 
				+        originalMatcher = originalMatcher || matcher;
			
 
				+        if (originalMatcher !== matcher) originalMatcher.alias.push(matcher);
			
 
				+        if (isRootAdd && record.name && !isAliasRecord(matcher)) {
			
 
				+          if (true) checkSameNameAsAncestor(record, parent);
			
 
				+          removeRoute(record.name);
			
 
				+        }
			
 
				+      }
			
 
				+      if (isMatchable(matcher)) insertMatcher(matcher);
			
 
				+      if (mainNormalizedRecord.children) {
			
 
				+        const children = mainNormalizedRecord.children;
			
 
				+        for (let i = 0; i < children.length; i++) addRoute(children[i], matcher, originalRecord && originalRecord.children[i]);
			
 
				+      }
			
 
				+      originalRecord = originalRecord || matcher;
			
 
				+    }
			
 
				+    return originalMatcher ? () => {
			
 
				+      removeRoute(originalMatcher);
			
 
				+    } : noop;
			
 
				+  }
			
 
				+  function removeRoute(matcherRef) {
			
 
				+    if (isRouteName(matcherRef)) {
			
 
				+      const matcher = matcherMap.get(matcherRef);
			
 
				+      if (matcher) {
			
 
				+        matcherMap.delete(matcherRef);
			
 
				+        matchers.splice(matchers.indexOf(matcher), 1);
			
 
				+        matcher.children.forEach(removeRoute);
			
 
				+        matcher.alias.forEach(removeRoute);
			
 
				+      }
			
 
				+    } else {
			
 
				+      const index = matchers.indexOf(matcherRef);
			
 
				+      if (index > -1) {
			
 
				+        matchers.splice(index, 1);
			
 
				+        if (matcherRef.record.name) matcherMap.delete(matcherRef.record.name);
			
 
				+        matcherRef.children.forEach(removeRoute);
			
 
				+        matcherRef.alias.forEach(removeRoute);
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+  function getRoutes() {
			
 
				+    return matchers;
			
 
				+  }
			
 
				+  function insertMatcher(matcher) {
			
 
				+    const index = findInsertionIndex(matcher, matchers);
			
 
				+    matchers.splice(index, 0, matcher);
			
 
				+    if (matcher.record.name && !isAliasRecord(matcher)) matcherMap.set(matcher.record.name, matcher);
			
 
				+  }
			
 
				+  function resolve(location$1, currentLocation) {
			
 
				+    let matcher;
			
 
				+    let params = {};
			
 
				+    let path;
			
 
				+    let name;
			
 
				+    if ("name" in location$1 && location$1.name) {
			
 
				+      matcher = matcherMap.get(location$1.name);
			
 
				+      if (!matcher) throw createRouterError(ErrorTypes.MATCHER_NOT_FOUND, { location: location$1 });
			
 
				+      if (true) {
			
 
				+        const invalidParams = Object.keys(location$1.params || {}).filter((paramName) => !matcher.keys.find((k) => k.name === paramName));
			
 
				+        if (invalidParams.length) warn$1(`Discarded invalid param(s) "${invalidParams.join('", "')}" when navigating. See https://github.com/vuejs/router/blob/main/packages/router/CHANGELOG.md#414-2022-08-22 for more details.`);
			
 
				+      }
			
 
				+      name = matcher.record.name;
			
 
				+      params = assign(pickParams(currentLocation.params, matcher.keys.filter((k) => !k.optional).concat(matcher.parent ? matcher.parent.keys.filter((k) => k.optional) : []).map((k) => k.name)), location$1.params && pickParams(location$1.params, matcher.keys.map((k) => k.name)));
			
 
				+      path = matcher.stringify(params);
			
 
				+    } else if (location$1.path != null) {
			
 
				+      path = location$1.path;
			
 
				+      if (!path.startsWith("/")) warn$1(`The Matcher cannot resolve relative paths but received "${path}". Unless you directly called \`matcher.resolve("${path}")\`, this is probably a bug in vue-router. Please open an issue at https://github.com/vuejs/router/issues/new/choose.`);
			
 
				+      matcher = matchers.find((m) => m.re.test(path));
			
 
				+      if (matcher) {
			
 
				+        params = matcher.parse(path);
			
 
				+        name = matcher.record.name;
			
 
				+      }
			
 
				+    } else {
			
 
				+      matcher = currentLocation.name ? matcherMap.get(currentLocation.name) : matchers.find((m) => m.re.test(currentLocation.path));
			
 
				+      if (!matcher) throw createRouterError(ErrorTypes.MATCHER_NOT_FOUND, {
			
 
				+        location: location$1,
			
 
				+        currentLocation
			
 
				+      });
			
 
				+      name = matcher.record.name;
			
 
				+      params = assign({}, currentLocation.params, location$1.params);
			
 
				+      path = matcher.stringify(params);
			
 
				+    }
			
 
				+    const matched = [];
			
 
				+    let parentMatcher = matcher;
			
 
				+    while (parentMatcher) {
			
 
				+      matched.unshift(parentMatcher.record);
			
 
				+      parentMatcher = parentMatcher.parent;
			
 
				+    }
			
 
				+    return {
			
 
				+      name,
			
 
				+      path,
			
 
				+      params,
			
 
				+      matched,
			
 
				+      meta: mergeMetaFields(matched)
			
 
				+    };
			
 
				+  }
			
 
				+  routes.forEach((route) => addRoute(route));
			
 
				+  function clearRoutes() {
			
 
				+    matchers.length = 0;
			
 
				+    matcherMap.clear();
			
 
				+  }
			
 
				+  return {
			
 
				+    addRoute,
			
 
				+    resolve,
			
 
				+    removeRoute,
			
 
				+    clearRoutes,
			
 
				+    getRoutes,
			
 
				+    getRecordMatcher
			
 
				+  };
			
 
				+}
			
 
				+function pickParams(params, keys) {
			
 
				+  const newParams = {};
			
 
				+  for (const key of keys) if (key in params) newParams[key] = params[key];
			
 
				+  return newParams;
			
 
				+}
			
 
				+function normalizeRouteRecord(record) {
			
 
				+  const normalized = {
			
 
				+    path: record.path,
			
 
				+    redirect: record.redirect,
			
 
				+    name: record.name,
			
 
				+    meta: record.meta || {},
			
 
				+    aliasOf: record.aliasOf,
			
 
				+    beforeEnter: record.beforeEnter,
			
 
				+    props: normalizeRecordProps(record),
			
 
				+    children: record.children || [],
			
 
				+    instances: {},
			
 
				+    leaveGuards: /* @__PURE__ */ new Set(),
			
 
				+    updateGuards: /* @__PURE__ */ new Set(),
			
 
				+    enterCallbacks: {},
			
 
				+    components: "components" in record ? record.components || null : record.component && { default: record.component }
			
 
				+  };
			
 
				+  Object.defineProperty(normalized, "mods", { value: {} });
			
 
				+  return normalized;
			
 
				+}
			
 
				+function normalizeRecordProps(record) {
			
 
				+  const propsObject = {};
			
 
				+  const props = record.props || false;
			
 
				+  if ("component" in record) propsObject.default = props;
			
 
				+  else for (const name in record.components) propsObject[name] = typeof props === "object" ? props[name] : props;
			
 
				+  return propsObject;
			
 
				+}
			
 
				+function isAliasRecord(record) {
			
 
				+  while (record) {
			
 
				+    if (record.record.aliasOf) return true;
			
 
				+    record = record.parent;
			
 
				+  }
			
 
				+  return false;
			
 
				+}
			
 
				+function mergeMetaFields(matched) {
			
 
				+  return matched.reduce((meta, record) => assign(meta, record.meta), {});
			
 
				+}
			
 
				+function isSameParam(a, b) {
			
 
				+  return a.name === b.name && a.optional === b.optional && a.repeatable === b.repeatable;
			
 
				+}
			
 
				+function checkSameParams(a, b) {
			
 
				+  for (const key of a.keys) if (!key.optional && !b.keys.find(isSameParam.bind(null, key))) return warn$1(`Alias "${b.record.path}" and the original record: "${a.record.path}" must have the exact same param named "${key.name}"`);
			
 
				+  for (const key of b.keys) if (!key.optional && !a.keys.find(isSameParam.bind(null, key))) return warn$1(`Alias "${b.record.path}" and the original record: "${a.record.path}" must have the exact same param named "${key.name}"`);
			
 
				+}
			
 
				+function checkChildMissingNameWithEmptyPath(mainNormalizedRecord, parent) {
			
 
				+  if (parent && parent.record.name && !mainNormalizedRecord.name && !mainNormalizedRecord.path) warn$1(`The route named "${String(parent.record.name)}" has a child without a name and an empty path. Using that name won't render the empty path child so you probably want to move the name to the child instead. If this is intentional, add a name to the child route to remove the warning.`);
			
 
				+}
			
 
				+function checkSameNameAsAncestor(record, parent) {
			
 
				+  for (let ancestor = parent; ancestor; ancestor = ancestor.parent) if (ancestor.record.name === record.name) throw new Error(`A route named "${String(record.name)}" has been added as a ${parent === ancestor ? "child" : "descendant"} of a route with the same name. Route names must be unique and a nested route cannot use the same name as an ancestor.`);
			
 
				+}
			
 
				+function checkMissingParamsInAbsolutePath(record, parent) {
			
 
				+  for (const key of parent.keys) if (!record.keys.find(isSameParam.bind(null, key))) return warn$1(`Absolute path "${record.record.path}" must have the exact same param named "${key.name}" as its parent "${parent.record.path}".`);
			
 
				+}
			
 
				+function findInsertionIndex(matcher, matchers) {
			
 
				+  let lower = 0;
			
 
				+  let upper = matchers.length;
			
 
				+  while (lower !== upper) {
			
 
				+    const mid = lower + upper >> 1;
			
 
				+    if (comparePathParserScore(matcher, matchers[mid]) < 0) upper = mid;
			
 
				+    else lower = mid + 1;
			
 
				+  }
			
 
				+  const insertionAncestor = getInsertionAncestor(matcher);
			
 
				+  if (insertionAncestor) {
			
 
				+    upper = matchers.lastIndexOf(insertionAncestor, upper - 1);
			
 
				+    if (upper < 0) warn$1(`Finding ancestor route "${insertionAncestor.record.path}" failed for "${matcher.record.path}"`);
			
 
				+  }
			
 
				+  return upper;
			
 
				+}
			
 
				+function getInsertionAncestor(matcher) {
			
 
				+  let ancestor = matcher;
			
 
				+  while (ancestor = ancestor.parent) if (isMatchable(ancestor) && comparePathParserScore(matcher, ancestor) === 0) return ancestor;
			
 
				+}
			
 
				+function isMatchable({ record }) {
			
 
				+  return !!(record.name || record.components && Object.keys(record.components).length || record.redirect);
			
 
				+}
			
 
				+function useLink(props) {
			
 
				+  const router = inject(routerKey);
			
 
				+  const currentRoute = inject(routeLocationKey);
			
 
				+  let hasPrevious = false;
			
 
				+  let previousTo = null;
			
 
				+  const route = computed(() => {
			
 
				+    const to = unref(props.to);
			
 
				+    if (!hasPrevious || to !== previousTo) {
			
 
				+      if (!isRouteLocation(to)) if (hasPrevious) warn$1(`Invalid value for prop "to" in useLink()
			
 
				+- to:`, to, `
			
 
				+- previous to:`, previousTo, `
			
 
				+- props:`, props);
			
 
				+      else warn$1(`Invalid value for prop "to" in useLink()
			
 
				+- to:`, to, `
			
 
				+- props:`, props);
			
 
				+      previousTo = to;
			
 
				+      hasPrevious = true;
			
 
				+    }
			
 
				+    return router.resolve(to);
			
 
				+  });
			
 
				+  const activeRecordIndex = computed(() => {
			
 
				+    const { matched } = route.value;
			
 
				+    const { length } = matched;
			
 
				+    const routeMatched = matched[length - 1];
			
 
				+    const currentMatched = currentRoute.matched;
			
 
				+    if (!routeMatched || !currentMatched.length) return -1;
			
 
				+    const index = currentMatched.findIndex(isSameRouteRecord.bind(null, routeMatched));
			
 
				+    if (index > -1) return index;
			
 
				+    const parentRecordPath = getOriginalPath(matched[length - 2]);
			
 
				+    return length > 1 && getOriginalPath(routeMatched) === parentRecordPath && currentMatched[currentMatched.length - 1].path !== parentRecordPath ? currentMatched.findIndex(isSameRouteRecord.bind(null, matched[length - 2])) : index;
			
 
				+  });
			
 
				+  const isActive = computed(() => activeRecordIndex.value > -1 && includesParams(currentRoute.params, route.value.params));
			
 
				+  const isExactActive = computed(() => activeRecordIndex.value > -1 && activeRecordIndex.value === currentRoute.matched.length - 1 && isSameRouteLocationParams(currentRoute.params, route.value.params));
			
 
				+  function navigate(e = {}) {
			
 
				+    if (guardEvent(e)) {
			
 
				+      const p = router[unref(props.replace) ? "replace" : "push"](unref(props.to)).catch(noop);
			
 
				+      if (props.viewTransition && typeof document !== "undefined" && "startViewTransition" in document) document.startViewTransition(() => p);
			
 
				+      return p;
			
 
				+    }
			
 
				+    return Promise.resolve();
			
 
				+  }
			
 
				+  if (isBrowser) {
			
 
				+    const instance = getCurrentInstance();
			
 
				+    if (instance) {
			
 
				+      const linkContextDevtools = {
			
 
				+        route: route.value,
			
 
				+        isActive: isActive.value,
			
 
				+        isExactActive: isExactActive.value,
			
 
				+        error: null
			
 
				+      };
			
 
				+      instance.__vrl_devtools = instance.__vrl_devtools || [];
			
 
				+      instance.__vrl_devtools.push(linkContextDevtools);
			
 
				+      watchEffect(() => {
			
 
				+        linkContextDevtools.route = route.value;
			
 
				+        linkContextDevtools.isActive = isActive.value;
			
 
				+        linkContextDevtools.isExactActive = isExactActive.value;
			
 
				+        linkContextDevtools.error = isRouteLocation(unref(props.to)) ? null : 'Invalid "to" value';
			
 
				+      }, { flush: "post" });
			
 
				+    }
			
 
				+  }
			
 
				+  return {
			
 
				+    route,
			
 
				+    href: computed(() => route.value.href),
			
 
				+    isActive,
			
 
				+    isExactActive,
			
 
				+    navigate
			
 
				+  };
			
 
				+}
			
 
				+function preferSingleVNode(vnodes) {
			
 
				+  return vnodes.length === 1 ? vnodes[0] : vnodes;
			
 
				+}
			
 
				+var RouterLinkImpl = defineComponent({
			
 
				+  name: "RouterLink",
			
 
				+  compatConfig: { MODE: 3 },
			
 
				+  props: {
			
 
				+    to: {
			
 
				+      type: [String, Object],
			
 
				+      required: true
			
 
				+    },
			
 
				+    replace: Boolean,
			
 
				+    activeClass: String,
			
 
				+    exactActiveClass: String,
			
 
				+    custom: Boolean,
			
 
				+    ariaCurrentValue: {
			
 
				+      type: String,
			
 
				+      default: "page"
			
 
				+    },
			
 
				+    viewTransition: Boolean
			
 
				+  },
			
 
				+  useLink,
			
 
				+  setup(props, { slots }) {
			
 
				+    const link = reactive(useLink(props));
			
 
				+    const { options } = inject(routerKey);
			
 
				+    const elClass = computed(() => ({
			
 
				+      [getLinkClass(props.activeClass, options.linkActiveClass, "router-link-active")]: link.isActive,
			
 
				+      [getLinkClass(props.exactActiveClass, options.linkExactActiveClass, "router-link-exact-active")]: link.isExactActive
			
 
				+    }));
			
 
				+    return () => {
			
 
				+      const children = slots.default && preferSingleVNode(slots.default(link));
			
 
				+      return props.custom ? children : h("a", {
			
 
				+        "aria-current": link.isExactActive ? props.ariaCurrentValue : null,
			
 
				+        href: link.href,
			
 
				+        onClick: link.navigate,
			
 
				+        class: elClass.value
			
 
				+      }, children);
			
 
				+    };
			
 
				+  }
			
 
				+});
			
 
				+var RouterLink = RouterLinkImpl;
			
 
				+function guardEvent(e) {
			
 
				+  if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return;
			
 
				+  if (e.defaultPrevented) return;
			
 
				+  if (e.button !== void 0 && e.button !== 0) return;
			
 
				+  if (e.currentTarget && e.currentTarget.getAttribute) {
			
 
				+    const target = e.currentTarget.getAttribute("target");
			
 
				+    if (/\b_blank\b/i.test(target)) return;
			
 
				+  }
			
 
				+  if (e.preventDefault) e.preventDefault();
			
 
				+  return true;
			
 
				+}
			
 
				+function includesParams(outer, inner) {
			
 
				+  for (const key in inner) {
			
 
				+    const innerValue = inner[key];
			
 
				+    const outerValue = outer[key];
			
 
				+    if (typeof innerValue === "string") {
			
 
				+      if (innerValue !== outerValue) return false;
			
 
				+    } else if (!isArray(outerValue) || outerValue.length !== innerValue.length || innerValue.some((value, i) => value.valueOf() !== outerValue[i].valueOf())) return false;
			
 
				+  }
			
 
				+  return true;
			
 
				+}
			
 
				+function getOriginalPath(record) {
			
 
				+  return record ? record.aliasOf ? record.aliasOf.path : record.path : "";
			
 
				+}
			
 
				+var getLinkClass = (propClass, globalClass, defaultClass) => propClass != null ? propClass : globalClass != null ? globalClass : defaultClass;
			
 
				+var RouterViewImpl = defineComponent({
			
 
				+  name: "RouterView",
			
 
				+  inheritAttrs: false,
			
 
				+  props: {
			
 
				+    name: {
			
 
				+      type: String,
			
 
				+      default: "default"
			
 
				+    },
			
 
				+    route: Object
			
 
				+  },
			
 
				+  compatConfig: { MODE: 3 },
			
 
				+  setup(props, { attrs, slots }) {
			
 
				+    warnDeprecatedUsage();
			
 
				+    const injectedRoute = inject(routerViewLocationKey);
			
 
				+    const routeToDisplay = computed(() => props.route || injectedRoute.value);
			
 
				+    const injectedDepth = inject(viewDepthKey, 0);
			
 
				+    const depth = computed(() => {
			
 
				+      let initialDepth = unref(injectedDepth);
			
 
				+      const { matched } = routeToDisplay.value;
			
 
				+      let matchedRoute;
			
 
				+      while ((matchedRoute = matched[initialDepth]) && !matchedRoute.components) initialDepth++;
			
 
				+      return initialDepth;
			
 
				+    });
			
 
				+    const matchedRouteRef = computed(() => routeToDisplay.value.matched[depth.value]);
			
 
				+    provide(viewDepthKey, computed(() => depth.value + 1));
			
 
				+    provide(matchedRouteKey, matchedRouteRef);
			
 
				+    provide(routerViewLocationKey, routeToDisplay);
			
 
				+    const viewRef = ref();
			
 
				+    watch(() => [
			
 
				+      viewRef.value,
			
 
				+      matchedRouteRef.value,
			
 
				+      props.name
			
 
				+    ], ([instance, to, name], [oldInstance, from, oldName]) => {
			
 
				+      if (to) {
			
 
				+        to.instances[name] = instance;
			
 
				+        if (from && from !== to && instance && instance === oldInstance) {
			
 
				+          if (!to.leaveGuards.size) to.leaveGuards = from.leaveGuards;
			
 
				+          if (!to.updateGuards.size) to.updateGuards = from.updateGuards;
			
 
				+        }
			
 
				+      }
			
 
				+      if (instance && to && (!from || !isSameRouteRecord(to, from) || !oldInstance)) (to.enterCallbacks[name] || []).forEach((callback) => callback(instance));
			
 
				+    }, { flush: "post" });
			
 
				+    return () => {
			
 
				+      const route = routeToDisplay.value;
			
 
				+      const currentName = props.name;
			
 
				+      const matchedRoute = matchedRouteRef.value;
			
 
				+      const ViewComponent = matchedRoute && matchedRoute.components[currentName];
			
 
				+      if (!ViewComponent) return normalizeSlot(slots.default, {
			
 
				+        Component: ViewComponent,
			
 
				+        route
			
 
				+      });
			
 
				+      const routePropsOption = matchedRoute.props[currentName];
			
 
				+      const routeProps = routePropsOption ? routePropsOption === true ? route.params : typeof routePropsOption === "function" ? routePropsOption(route) : routePropsOption : null;
			
 
				+      const onVnodeUnmounted = (vnode) => {
			
 
				+        if (vnode.component.isUnmounted) matchedRoute.instances[currentName] = null;
			
 
				+      };
			
 
				+      const component = h(ViewComponent, assign({}, routeProps, attrs, {
			
 
				+        onVnodeUnmounted,
			
 
				+        ref: viewRef
			
 
				+      }));
			
 
				+      if (isBrowser && component.ref) {
			
 
				+        const info = {
			
 
				+          depth: depth.value,
			
 
				+          name: matchedRoute.name,
			
 
				+          path: matchedRoute.path,
			
 
				+          meta: matchedRoute.meta
			
 
				+        };
			
 
				+        (isArray(component.ref) ? component.ref.map((r) => r.i) : [component.ref.i]).forEach((instance) => {
			
 
				+          instance.__vrv_devtools = info;
			
 
				+        });
			
 
				+      }
			
 
				+      return normalizeSlot(slots.default, {
			
 
				+        Component: component,
			
 
				+        route
			
 
				+      }) || component;
			
 
				+    };
			
 
				+  }
			
 
				+});
			
 
				+function normalizeSlot(slot, data) {
			
 
				+  if (!slot) return null;
			
 
				+  const slotContent = slot(data);
			
 
				+  return slotContent.length === 1 ? slotContent[0] : slotContent;
			
 
				+}
			
 
				+var RouterView = RouterViewImpl;
			
 
				+function warnDeprecatedUsage() {
			
 
				+  const instance = getCurrentInstance();
			
 
				+  const parentName = instance.parent && instance.parent.type.name;
			
 
				+  const parentSubTreeType = instance.parent && instance.parent.subTree && instance.parent.subTree.type;
			
 
				+  if (parentName && (parentName === "KeepAlive" || parentName.includes("Transition")) && typeof parentSubTreeType === "object" && parentSubTreeType.name === "RouterView") {
			
 
				+    const comp = parentName === "KeepAlive" ? "keep-alive" : "transition";
			
 
				+    warn$1(`<router-view> can no longer be used directly inside <transition> or <keep-alive>.
			
 
				+Use slot props instead:
			
 
				+
			
 
				+<router-view v-slot="{ Component }">
			
 
				+  <${comp}>
			
 
				+    <component :is="Component" />
			
 
				+  </${comp}>
			
 
				+</router-view>`);
			
 
				+  }
			
 
				+}
			
 
				+function createRouter(options) {
			
 
				+  const matcher = createRouterMatcher(options.routes, options);
			
 
				+  const parseQuery$1 = options.parseQuery || parseQuery;
			
 
				+  const stringifyQuery$1 = options.stringifyQuery || stringifyQuery;
			
 
				+  const routerHistory = options.history;
			
 
				+  if (!routerHistory) throw new Error('Provide the "history" option when calling "createRouter()": https://router.vuejs.org/api/interfaces/RouterOptions.html#history');
			
 
				+  const beforeGuards = useCallbacks();
			
 
				+  const beforeResolveGuards = useCallbacks();
			
 
				+  const afterGuards = useCallbacks();
			
 
				+  const currentRoute = shallowRef(START_LOCATION_NORMALIZED);
			
 
				+  let pendingLocation = START_LOCATION_NORMALIZED;
			
 
				+  if (isBrowser && options.scrollBehavior && "scrollRestoration" in history) history.scrollRestoration = "manual";
			
 
				+  const normalizeParams = applyToParams.bind(null, (paramValue) => "" + paramValue);
			
 
				+  const encodeParams = applyToParams.bind(null, encodeParam);
			
 
				+  const decodeParams = applyToParams.bind(null, decode);
			
 
				+  function addRoute(parentOrRoute, route) {
			
 
				+    let parent;
			
 
				+    let record;
			
 
				+    if (isRouteName(parentOrRoute)) {
			
 
				+      parent = matcher.getRecordMatcher(parentOrRoute);
			
 
				+      if (!parent) warn$1(`Parent route "${String(parentOrRoute)}" not found when adding child route`, route);
			
 
				+      record = route;
			
 
				+    } else record = parentOrRoute;
			
 
				+    return matcher.addRoute(record, parent);
			
 
				+  }
			
 
				+  function removeRoute(name) {
			
 
				+    const recordMatcher = matcher.getRecordMatcher(name);
			
 
				+    if (recordMatcher) matcher.removeRoute(recordMatcher);
			
 
				+    else if (true) warn$1(`Cannot remove non-existent route "${String(name)}"`);
			
 
				+  }
			
 
				+  function getRoutes() {
			
 
				+    return matcher.getRoutes().map((routeMatcher) => routeMatcher.record);
			
 
				+  }
			
 
				+  function hasRoute(name) {
			
 
				+    return !!matcher.getRecordMatcher(name);
			
 
				+  }
			
 
				+  function resolve(rawLocation, currentLocation) {
			
 
				+    currentLocation = assign({}, currentLocation || currentRoute.value);
			
 
				+    if (typeof rawLocation === "string") {
			
 
				+      const locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);
			
 
				+      const matchedRoute$1 = matcher.resolve({ path: locationNormalized.path }, currentLocation);
			
 
				+      const href$1 = routerHistory.createHref(locationNormalized.fullPath);
			
 
				+      if (true) {
			
 
				+        if (href$1.startsWith("//")) warn$1(`Location "${rawLocation}" resolved to "${href$1}". A resolved location cannot start with multiple slashes.`);
			
 
				+        else if (!matchedRoute$1.matched.length) warn$1(`No match found for location with path "${rawLocation}"`);
			
 
				+      }
			
 
				+      return assign(locationNormalized, matchedRoute$1, {
			
 
				+        params: decodeParams(matchedRoute$1.params),
			
 
				+        hash: decode(locationNormalized.hash),
			
 
				+        redirectedFrom: void 0,
			
 
				+        href: href$1
			
 
				+      });
			
 
				+    }
			
 
				+    if (!isRouteLocation(rawLocation)) {
			
 
				+      warn$1(`router.resolve() was passed an invalid location. This will fail in production.
			
 
				+- Location:`, rawLocation);
			
 
				+      return resolve({});
			
 
				+    }
			
 
				+    let matcherLocation;
			
 
				+    if (rawLocation.path != null) {
			
 
				+      if ("params" in rawLocation && !("name" in rawLocation) && Object.keys(rawLocation.params).length) warn$1(`Path "${rawLocation.path}" was passed with params but they will be ignored. Use a named route alongside params instead.`);
			
 
				+      matcherLocation = assign({}, rawLocation, { path: parseURL(parseQuery$1, rawLocation.path, currentLocation.path).path });
			
 
				+    } else {
			
 
				+      const targetParams = assign({}, rawLocation.params);
			
 
				+      for (const key in targetParams) if (targetParams[key] == null) delete targetParams[key];
			
 
				+      matcherLocation = assign({}, rawLocation, { params: encodeParams(targetParams) });
			
 
				+      currentLocation.params = encodeParams(currentLocation.params);
			
 
				+    }
			
 
				+    const matchedRoute = matcher.resolve(matcherLocation, currentLocation);
			
 
				+    const hash = rawLocation.hash || "";
			
 
				+    if (hash && !hash.startsWith("#")) warn$1(`A \`hash\` should always start with the character "#". Replace "${hash}" with "#${hash}".`);
			
 
				+    matchedRoute.params = normalizeParams(decodeParams(matchedRoute.params));
			
 
				+    const fullPath = stringifyURL(stringifyQuery$1, assign({}, rawLocation, {
			
 
				+      hash: encodeHash(hash),
			
 
				+      path: matchedRoute.path
			
 
				+    }));
			
 
				+    const href = routerHistory.createHref(fullPath);
			
 
				+    if (true) {
			
 
				+      if (href.startsWith("//")) warn$1(`Location "${rawLocation}" resolved to "${href}". A resolved location cannot start with multiple slashes.`);
			
 
				+      else if (!matchedRoute.matched.length) warn$1(`No match found for location with path "${rawLocation.path != null ? rawLocation.path : rawLocation}"`);
			
 
				+    }
			
 
				+    return assign({
			
 
				+      fullPath,
			
 
				+      hash,
			
 
				+      query: stringifyQuery$1 === stringifyQuery ? normalizeQuery(rawLocation.query) : rawLocation.query || {}
			
 
				+    }, matchedRoute, {
			
 
				+      redirectedFrom: void 0,
			
 
				+      href
			
 
				+    });
			
 
				+  }
			
 
				+  function locationAsObject(to) {
			
 
				+    return typeof to === "string" ? parseURL(parseQuery$1, to, currentRoute.value.path) : assign({}, to);
			
 
				+  }
			
 
				+  function checkCanceledNavigation(to, from) {
			
 
				+    if (pendingLocation !== to) return createRouterError(ErrorTypes.NAVIGATION_CANCELLED, {
			
 
				+      from,
			
 
				+      to
			
 
				+    });
			
 
				+  }
			
 
				+  function push(to) {
			
 
				+    return pushWithRedirect(to);
			
 
				+  }
			
 
				+  function replace(to) {
			
 
				+    return push(assign(locationAsObject(to), { replace: true }));
			
 
				+  }
			
 
				+  function handleRedirectRecord(to, from) {
			
 
				+    const lastMatched = to.matched[to.matched.length - 1];
			
 
				+    if (lastMatched && lastMatched.redirect) {
			
 
				+      const { redirect } = lastMatched;
			
 
				+      let newTargetLocation = typeof redirect === "function" ? redirect(to, from) : redirect;
			
 
				+      if (typeof newTargetLocation === "string") {
			
 
				+        newTargetLocation = newTargetLocation.includes("?") || newTargetLocation.includes("#") ? newTargetLocation = locationAsObject(newTargetLocation) : { path: newTargetLocation };
			
 
				+        newTargetLocation.params = {};
			
 
				+      }
			
 
				+      if (newTargetLocation.path == null && !("name" in newTargetLocation)) {
			
 
				+        warn$1(`Invalid redirect found:
			
 
				+${JSON.stringify(newTargetLocation, null, 2)}
			
 
				+ when navigating to "${to.fullPath}". A redirect must contain a name or path. This will break in production.`);
			
 
				+        throw new Error("Invalid redirect");
			
 
				+      }
			
 
				+      return assign({
			
 
				+        query: to.query,
			
 
				+        hash: to.hash,
			
 
				+        params: newTargetLocation.path != null ? {} : to.params
			
 
				+      }, newTargetLocation);
			
 
				+    }
			
 
				+  }
			
 
				+  function pushWithRedirect(to, redirectedFrom) {
			
 
				+    const targetLocation = pendingLocation = resolve(to);
			
 
				+    const from = currentRoute.value;
			
 
				+    const data = to.state;
			
 
				+    const force = to.force;
			
 
				+    const replace$1 = to.replace === true;
			
 
				+    const shouldRedirect = handleRedirectRecord(targetLocation, from);
			
 
				+    if (shouldRedirect) return pushWithRedirect(assign(locationAsObject(shouldRedirect), {
			
 
				+      state: typeof shouldRedirect === "object" ? assign({}, data, shouldRedirect.state) : data,
			
 
				+      force,
			
 
				+      replace: replace$1
			
 
				+    }), redirectedFrom || targetLocation);
			
 
				+    const toLocation = targetLocation;
			
 
				+    toLocation.redirectedFrom = redirectedFrom;
			
 
				+    let failure;
			
 
				+    if (!force && isSameRouteLocation(stringifyQuery$1, from, targetLocation)) {
			
 
				+      failure = createRouterError(ErrorTypes.NAVIGATION_DUPLICATED, {
			
 
				+        to: toLocation,
			
 
				+        from
			
 
				+      });
			
 
				+      handleScroll(from, from, true, false);
			
 
				+    }
			
 
				+    return (failure ? Promise.resolve(failure) : navigate(toLocation, from)).catch((error) => isNavigationFailure(error) ? isNavigationFailure(error, ErrorTypes.NAVIGATION_GUARD_REDIRECT) ? error : markAsReady(error) : triggerError(error, toLocation, from)).then((failure$1) => {
			
 
				+      if (failure$1) {
			
 
				+        if (isNavigationFailure(failure$1, ErrorTypes.NAVIGATION_GUARD_REDIRECT)) {
			
 
				+          if (isSameRouteLocation(stringifyQuery$1, resolve(failure$1.to), toLocation) && redirectedFrom && (redirectedFrom._count = redirectedFrom._count ? redirectedFrom._count + 1 : 1) > 30) {
			
 
				+            warn$1(`Detected a possibly infinite redirection in a navigation guard when going from "${from.fullPath}" to "${toLocation.fullPath}". Aborting to avoid a Stack Overflow.
			
 
				+ Are you always returning a new location within a navigation guard? That would lead to this error. Only return when redirecting or aborting, that should fix this. This might break in production if not fixed.`);
			
 
				+            return Promise.reject(new Error("Infinite redirect in navigation guard"));
			
 
				+          }
			
 
				+          return pushWithRedirect(assign({ replace: replace$1 }, locationAsObject(failure$1.to), {
			
 
				+            state: typeof failure$1.to === "object" ? assign({}, data, failure$1.to.state) : data,
			
 
				+            force
			
 
				+          }), redirectedFrom || toLocation);
			
 
				+        }
			
 
				+      } else failure$1 = finalizeNavigation(toLocation, from, true, replace$1, data);
			
 
				+      triggerAfterEach(toLocation, from, failure$1);
			
 
				+      return failure$1;
			
 
				+    });
			
 
				+  }
			
 
				+  function checkCanceledNavigationAndReject(to, from) {
			
 
				+    const error = checkCanceledNavigation(to, from);
			
 
				+    return error ? Promise.reject(error) : Promise.resolve();
			
 
				+  }
			
 
				+  function runWithContext(fn) {
			
 
				+    const app = installedApps.values().next().value;
			
 
				+    return app && typeof app.runWithContext === "function" ? app.runWithContext(fn) : fn();
			
 
				+  }
			
 
				+  function navigate(to, from) {
			
 
				+    let guards;
			
 
				+    const [leavingRecords, updatingRecords, enteringRecords] = extractChangingRecords(to, from);
			
 
				+    guards = extractComponentsGuards(leavingRecords.reverse(), "beforeRouteLeave", to, from);
			
 
				+    for (const record of leavingRecords) record.leaveGuards.forEach((guard) => {
			
 
				+      guards.push(guardToPromiseFn(guard, to, from));
			
 
				+    });
			
 
				+    const canceledNavigationCheck = checkCanceledNavigationAndReject.bind(null, to, from);
			
 
				+    guards.push(canceledNavigationCheck);
			
 
				+    return runGuardQueue(guards).then(() => {
			
 
				+      guards = [];
			
 
				+      for (const guard of beforeGuards.list()) guards.push(guardToPromiseFn(guard, to, from));
			
 
				+      guards.push(canceledNavigationCheck);
			
 
				+      return runGuardQueue(guards);
			
 
				+    }).then(() => {
			
 
				+      guards = extractComponentsGuards(updatingRecords, "beforeRouteUpdate", to, from);
			
 
				+      for (const record of updatingRecords) record.updateGuards.forEach((guard) => {
			
 
				+        guards.push(guardToPromiseFn(guard, to, from));
			
 
				+      });
			
 
				+      guards.push(canceledNavigationCheck);
			
 
				+      return runGuardQueue(guards);
			
 
				+    }).then(() => {
			
 
				+      guards = [];
			
 
				+      for (const record of enteringRecords) if (record.beforeEnter) if (isArray(record.beforeEnter)) for (const beforeEnter of record.beforeEnter) guards.push(guardToPromiseFn(beforeEnter, to, from));
			
 
				+      else guards.push(guardToPromiseFn(record.beforeEnter, to, from));
			
 
				+      guards.push(canceledNavigationCheck);
			
 
				+      return runGuardQueue(guards);
			
 
				+    }).then(() => {
			
 
				+      to.matched.forEach((record) => record.enterCallbacks = {});
			
 
				+      guards = extractComponentsGuards(enteringRecords, "beforeRouteEnter", to, from, runWithContext);
			
 
				+      guards.push(canceledNavigationCheck);
			
 
				+      return runGuardQueue(guards);
			
 
				+    }).then(() => {
			
 
				+      guards = [];
			
 
				+      for (const guard of beforeResolveGuards.list()) guards.push(guardToPromiseFn(guard, to, from));
			
 
				+      guards.push(canceledNavigationCheck);
			
 
				+      return runGuardQueue(guards);
			
 
				+    }).catch((err) => isNavigationFailure(err, ErrorTypes.NAVIGATION_CANCELLED) ? err : Promise.reject(err));
			
 
				+  }
			
 
				+  function triggerAfterEach(to, from, failure) {
			
 
				+    afterGuards.list().forEach((guard) => runWithContext(() => guard(to, from, failure)));
			
 
				+  }
			
 
				+  function finalizeNavigation(toLocation, from, isPush, replace$1, data) {
			
 
				+    const error = checkCanceledNavigation(toLocation, from);
			
 
				+    if (error) return error;
			
 
				+    const isFirstNavigation = from === START_LOCATION_NORMALIZED;
			
 
				+    const state = !isBrowser ? {} : history.state;
			
 
				+    if (isPush) if (replace$1 || isFirstNavigation) routerHistory.replace(toLocation.fullPath, assign({ scroll: isFirstNavigation && state && state.scroll }, data));
			
 
				+    else routerHistory.push(toLocation.fullPath, data);
			
 
				+    currentRoute.value = toLocation;
			
 
				+    handleScroll(toLocation, from, isPush, isFirstNavigation);
			
 
				+    markAsReady();
			
 
				+  }
			
 
				+  let removeHistoryListener;
			
 
				+  function setupListeners() {
			
 
				+    if (removeHistoryListener) return;
			
 
				+    removeHistoryListener = routerHistory.listen((to, _from, info) => {
			
 
				+      if (!router.listening) return;
			
 
				+      const toLocation = resolve(to);
			
 
				+      const shouldRedirect = handleRedirectRecord(toLocation, router.currentRoute.value);
			
 
				+      if (shouldRedirect) {
			
 
				+        pushWithRedirect(assign(shouldRedirect, {
			
 
				+          replace: true,
			
 
				+          force: true
			
 
				+        }), toLocation).catch(noop);
			
 
				+        return;
			
 
				+      }
			
 
				+      pendingLocation = toLocation;
			
 
				+      const from = currentRoute.value;
			
 
				+      if (isBrowser) saveScrollPosition(getScrollKey(from.fullPath, info.delta), computeScrollPosition());
			
 
				+      navigate(toLocation, from).catch((error) => {
			
 
				+        if (isNavigationFailure(error, ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_CANCELLED)) return error;
			
 
				+        if (isNavigationFailure(error, ErrorTypes.NAVIGATION_GUARD_REDIRECT)) {
			
 
				+          pushWithRedirect(assign(locationAsObject(error.to), { force: true }), toLocation).then((failure) => {
			
 
				+            if (isNavigationFailure(failure, ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_DUPLICATED) && !info.delta && info.type === NavigationType.pop) routerHistory.go(-1, false);
			
 
				+          }).catch(noop);
			
 
				+          return Promise.reject();
			
 
				+        }
			
 
				+        if (info.delta) routerHistory.go(-info.delta, false);
			
 
				+        return triggerError(error, toLocation, from);
			
 
				+      }).then((failure) => {
			
 
				+        failure = failure || finalizeNavigation(toLocation, from, false);
			
 
				+        if (failure) {
			
 
				+          if (info.delta && !isNavigationFailure(failure, ErrorTypes.NAVIGATION_CANCELLED)) routerHistory.go(-info.delta, false);
			
 
				+          else if (info.type === NavigationType.pop && isNavigationFailure(failure, ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_DUPLICATED)) routerHistory.go(-1, false);
			
 
				+        }
			
 
				+        triggerAfterEach(toLocation, from, failure);
			
 
				+      }).catch(noop);
			
 
				+    });
			
 
				+  }
			
 
				+  let readyHandlers = useCallbacks();
			
 
				+  let errorListeners = useCallbacks();
			
 
				+  let ready;
			
 
				+  function triggerError(error, to, from) {
			
 
				+    markAsReady(error);
			
 
				+    const list = errorListeners.list();
			
 
				+    if (list.length) list.forEach((handler) => handler(error, to, from));
			
 
				+    else {
			
 
				+      if (true) warn$1("uncaught error during route navigation:");
			
 
				+      console.error(error);
			
 
				+    }
			
 
				+    return Promise.reject(error);
			
 
				+  }
			
 
				+  function isReady() {
			
 
				+    if (ready && currentRoute.value !== START_LOCATION_NORMALIZED) return Promise.resolve();
			
 
				+    return new Promise((resolve$1, reject) => {
			
 
				+      readyHandlers.add([resolve$1, reject]);
			
 
				+    });
			
 
				+  }
			
 
				+  function markAsReady(err) {
			
 
				+    if (!ready) {
			
 
				+      ready = !err;
			
 
				+      setupListeners();
			
 
				+      readyHandlers.list().forEach(([resolve$1, reject]) => err ? reject(err) : resolve$1());
			
 
				+      readyHandlers.reset();
			
 
				+    }
			
 
				+    return err;
			
 
				+  }
			
 
				+  function handleScroll(to, from, isPush, isFirstNavigation) {
			
 
				+    const { scrollBehavior } = options;
			
 
				+    if (!isBrowser || !scrollBehavior) return Promise.resolve();
			
 
				+    const scrollPosition = !isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0)) || (isFirstNavigation || !isPush) && history.state && history.state.scroll || null;
			
 
				+    return nextTick().then(() => scrollBehavior(to, from, scrollPosition)).then((position) => position && scrollToPosition(position)).catch((err) => triggerError(err, to, from));
			
 
				+  }
			
 
				+  const go = (delta) => routerHistory.go(delta);
			
 
				+  let started;
			
 
				+  const installedApps = /* @__PURE__ */ new Set();
			
 
				+  const router = {
			
 
				+    currentRoute,
			
 
				+    listening: true,
			
 
				+    addRoute,
			
 
				+    removeRoute,
			
 
				+    clearRoutes: matcher.clearRoutes,
			
 
				+    hasRoute,
			
 
				+    getRoutes,
			
 
				+    resolve,
			
 
				+    options,
			
 
				+    push,
			
 
				+    replace,
			
 
				+    go,
			
 
				+    back: () => go(-1),
			
 
				+    forward: () => go(1),
			
 
				+    beforeEach: beforeGuards.add,
			
 
				+    beforeResolve: beforeResolveGuards.add,
			
 
				+    afterEach: afterGuards.add,
			
 
				+    onError: errorListeners.add,
			
 
				+    isReady,
			
 
				+    install(app) {
			
 
				+      app.component("RouterLink", RouterLink);
			
 
				+      app.component("RouterView", RouterView);
			
 
				+      app.config.globalProperties.$router = router;
			
 
				+      Object.defineProperty(app.config.globalProperties, "$route", {
			
 
				+        enumerable: true,
			
 
				+        get: () => unref(currentRoute)
			
 
				+      });
			
 
				+      if (isBrowser && !started && currentRoute.value === START_LOCATION_NORMALIZED) {
			
 
				+        started = true;
			
 
				+        push(routerHistory.location).catch((err) => {
			
 
				+          if (true) warn$1("Unexpected error when starting the router:", err);
			
 
				+        });
			
 
				+      }
			
 
				+      const reactiveRoute = {};
			
 
				+      for (const key in START_LOCATION_NORMALIZED) Object.defineProperty(reactiveRoute, key, {
			
 
				+        get: () => currentRoute.value[key],
			
 
				+        enumerable: true
			
 
				+      });
			
 
				+      app.provide(routerKey, router);
			
 
				+      app.provide(routeLocationKey, shallowReactive(reactiveRoute));
			
 
				+      app.provide(routerViewLocationKey, currentRoute);
			
 
				+      const unmountApp = app.unmount;
			
 
				+      installedApps.add(app);
			
 
				+      app.unmount = function() {
			
 
				+        installedApps.delete(app);
			
 
				+        if (installedApps.size < 1) {
			
 
				+          pendingLocation = START_LOCATION_NORMALIZED;
			
 
				+          removeHistoryListener && removeHistoryListener();
			
 
				+          removeHistoryListener = null;
			
 
				+          currentRoute.value = START_LOCATION_NORMALIZED;
			
 
				+          started = false;
			
 
				+          ready = false;
			
 
				+        }
			
 
				+        unmountApp();
			
 
				+      };
			
 
				+      if (isBrowser) addDevtools(app, router, matcher);
			
 
				+    }
			
 
				+  };
			
 
				+  function runGuardQueue(guards) {
			
 
				+    return guards.reduce((promise, guard) => promise.then(() => runWithContext(guard)), Promise.resolve());
			
 
				+  }
			
 
				+  return router;
			
 
				+}
			
 
				+function useRouter() {
			
 
				+  return inject(routerKey);
			
 
				+}
			
 
				+function useRoute(_name) {
			
 
				+  return inject(routeLocationKey);
			
 
				+}
			
 
				+export {
			
 
				+  NavigationFailureType,
			
 
				+  RouterLink,
			
 
				+  RouterView,
			
 
				+  START_LOCATION_NORMALIZED as START_LOCATION,
			
 
				+  createMemoryHistory,
			
 
				+  createRouter,
			
 
				+  createRouterMatcher,
			
 
				+  createWebHashHistory,
			
 
				+  createWebHistory,
			
 
				+  isNavigationFailure,
			
 
				+  loadRouteLocation,
			
 
				+  matchedRouteKey,
			
 
				+  onBeforeRouteLeave,
			
 
				+  onBeforeRouteUpdate,
			
 
				+  parseQuery,
			
 
				+  routeLocationKey,
			
 
				+  routerKey,
			
 
				+  routerViewLocationKey,
			
 
				+  stringifyQuery,
			
 
				+  useLink,
			
 
				+  useRoute,
			
 
				+  useRouter,
			
 
				+  viewDepthKey
			
 
				+};
			
 
				+/*! Bundled license information:
			
 
				+
			
 
				+vue-router/dist/devtools-EWN81iOl.mjs:
			
 
				+  (*!
			
 
				+   * vue-router v4.6.4
			
 
				+   * (c) 2025 Eduardo San Martin Morote
			
 
				+   * @license MIT
			
 
				+   *)
			
 
				+
			
 
				+vue-router/dist/vue-router.mjs:
			
 
				+  (*!
			
 
				+   * vue-router v4.6.4
			
 
				+   * (c) 2025 Eduardo San Martin Morote
			
 
				+   * @license MIT
			
 
				+   *)
			
 
				+*/
			
 
				+//# sourceMappingURL=vue-router.js.map
			
--- a/ui/node_modules/.vite/deps/vue-router.js.map
+++ b/ui/node_modules/.vite/deps/vue-router.js.map
--- a/ui/node_modules/.vite/deps/vue.js
+++ b/ui/node_modules/.vite/deps/vue.js
@@ -0,0 +1,347 @@
 
				+import {
			
 
				+  BaseTransition,
			
 
				+  BaseTransitionPropsValidators,
			
 
				+  Comment,
			
 
				+  DeprecationTypes,
			
 
				+  EffectScope,
			
 
				+  ErrorCodes,
			
 
				+  ErrorTypeStrings,
			
 
				+  Fragment,
			
 
				+  KeepAlive,
			
 
				+  ReactiveEffect,
			
 
				+  Static,
			
 
				+  Suspense,
			
 
				+  Teleport,
			
 
				+  Text,
			
 
				+  TrackOpTypes,
			
 
				+  Transition,
			
 
				+  TransitionGroup,
			
 
				+  TriggerOpTypes,
			
 
				+  VueElement,
			
 
				+  assertNumber,
			
 
				+  callWithAsyncErrorHandling,
			
 
				+  callWithErrorHandling,
			
 
				+  camelize,
			
 
				+  capitalize,
			
 
				+  cloneVNode,
			
 
				+  compatUtils,
			
 
				+  compile,
			
 
				+  computed,
			
 
				+  createApp,
			
 
				+  createBaseVNode,
			
 
				+  createBlock,
			
 
				+  createCommentVNode,
			
 
				+  createElementBlock,
			
 
				+  createHydrationRenderer,
			
 
				+  createPropsRestProxy,
			
 
				+  createRenderer,
			
 
				+  createSSRApp,
			
 
				+  createSlots,
			
 
				+  createStaticVNode,
			
 
				+  createTextVNode,
			
 
				+  createVNode,
			
 
				+  customRef,
			
 
				+  defineAsyncComponent,
			
 
				+  defineComponent,
			
 
				+  defineCustomElement,
			
 
				+  defineEmits,
			
 
				+  defineExpose,
			
 
				+  defineModel,
			
 
				+  defineOptions,
			
 
				+  defineProps,
			
 
				+  defineSSRCustomElement,
			
 
				+  defineSlots,
			
 
				+  devtools,
			
 
				+  effect,
			
 
				+  effectScope,
			
 
				+  getCurrentInstance,
			
 
				+  getCurrentScope,
			
 
				+  getCurrentWatcher,
			
 
				+  getTransitionRawChildren,
			
 
				+  guardReactiveProps,
			
 
				+  h,
			
 
				+  handleError,
			
 
				+  hasInjectionContext,
			
 
				+  hydrate,
			
 
				+  hydrateOnIdle,
			
 
				+  hydrateOnInteraction,
			
 
				+  hydrateOnMediaQuery,
			
 
				+  hydrateOnVisible,
			
 
				+  initCustomFormatter,
			
 
				+  initDirectivesForSSR,
			
 
				+  inject,
			
 
				+  isMemoSame,
			
 
				+  isProxy,
			
 
				+  isReactive,
			
 
				+  isReadonly,
			
 
				+  isRef,
			
 
				+  isRuntimeOnly,
			
 
				+  isShallow,
			
 
				+  isVNode,
			
 
				+  markRaw,
			
 
				+  mergeDefaults,
			
 
				+  mergeModels,
			
 
				+  mergeProps,
			
 
				+  nextTick,
			
 
				+  nodeOps,
			
 
				+  normalizeClass,
			
 
				+  normalizeProps,
			
 
				+  normalizeStyle,
			
 
				+  onActivated,
			
 
				+  onBeforeMount,
			
 
				+  onBeforeUnmount,
			
 
				+  onBeforeUpdate,
			
 
				+  onDeactivated,
			
 
				+  onErrorCaptured,
			
 
				+  onMounted,
			
 
				+  onRenderTracked,
			
 
				+  onRenderTriggered,
			
 
				+  onScopeDispose,
			
 
				+  onServerPrefetch,
			
 
				+  onUnmounted,
			
 
				+  onUpdated,
			
 
				+  onWatcherCleanup,
			
 
				+  openBlock,
			
 
				+  patchProp,
			
 
				+  popScopeId,
			
 
				+  provide,
			
 
				+  proxyRefs,
			
 
				+  pushScopeId,
			
 
				+  queuePostFlushCb,
			
 
				+  reactive,
			
 
				+  readonly,
			
 
				+  ref,
			
 
				+  registerRuntimeCompiler,
			
 
				+  render,
			
 
				+  renderList,
			
 
				+  renderSlot,
			
 
				+  resolveComponent,
			
 
				+  resolveDirective,
			
 
				+  resolveDynamicComponent,
			
 
				+  resolveFilter,
			
 
				+  resolveTransitionHooks,
			
 
				+  setBlockTracking,
			
 
				+  setDevtoolsHook,
			
 
				+  setTransitionHooks,
			
 
				+  shallowReactive,
			
 
				+  shallowReadonly,
			
 
				+  shallowRef,
			
 
				+  ssrContextKey,
			
 
				+  ssrUtils,
			
 
				+  stop,
			
 
				+  toDisplayString,
			
 
				+  toHandlerKey,
			
 
				+  toHandlers,
			
 
				+  toRaw,
			
 
				+  toRef,
			
 
				+  toRefs,
			
 
				+  toValue,
			
 
				+  transformVNodeArgs,
			
 
				+  triggerRef,
			
 
				+  unref,
			
 
				+  useAttrs,
			
 
				+  useCssModule,
			
 
				+  useCssVars,
			
 
				+  useHost,
			
 
				+  useId,
			
 
				+  useModel,
			
 
				+  useSSRContext,
			
 
				+  useShadowRoot,
			
 
				+  useSlots,
			
 
				+  useTemplateRef,
			
 
				+  useTransitionState,
			
 
				+  vModelCheckbox,
			
 
				+  vModelDynamic,
			
 
				+  vModelRadio,
			
 
				+  vModelSelect,
			
 
				+  vModelText,
			
 
				+  vShow,
			
 
				+  version,
			
 
				+  warn,
			
 
				+  watch,
			
 
				+  watchEffect,
			
 
				+  watchPostEffect,
			
 
				+  watchSyncEffect,
			
 
				+  withAsyncContext,
			
 
				+  withCtx,
			
 
				+  withDefaults,
			
 
				+  withDirectives,
			
 
				+  withKeys,
			
 
				+  withMemo,
			
 
				+  withModifiers,
			
 
				+  withScopeId
			
 
				+} from "./chunk-ZIH63DMU.js";
			
 
				+export {
			
 
				+  BaseTransition,
			
 
				+  BaseTransitionPropsValidators,
			
 
				+  Comment,
			
 
				+  DeprecationTypes,
			
 
				+  EffectScope,
			
 
				+  ErrorCodes,
			
 
				+  ErrorTypeStrings,
			
 
				+  Fragment,
			
 
				+  KeepAlive,
			
 
				+  ReactiveEffect,
			
 
				+  Static,
			
 
				+  Suspense,
			
 
				+  Teleport,
			
 
				+  Text,
			
 
				+  TrackOpTypes,
			
 
				+  Transition,
			
 
				+  TransitionGroup,
			
 
				+  TriggerOpTypes,
			
 
				+  VueElement,
			
 
				+  assertNumber,
			
 
				+  callWithAsyncErrorHandling,
			
 
				+  callWithErrorHandling,
			
 
				+  camelize,
			
 
				+  capitalize,
			
 
				+  cloneVNode,
			
 
				+  compatUtils,
			
 
				+  compile,
			
 
				+  computed,
			
 
				+  createApp,
			
 
				+  createBlock,
			
 
				+  createCommentVNode,
			
 
				+  createElementBlock,
			
 
				+  createBaseVNode as createElementVNode,
			
 
				+  createHydrationRenderer,
			
 
				+  createPropsRestProxy,
			
 
				+  createRenderer,
			
 
				+  createSSRApp,
			
 
				+  createSlots,
			
 
				+  createStaticVNode,
			
 
				+  createTextVNode,
			
 
				+  createVNode,
			
 
				+  customRef,
			
 
				+  defineAsyncComponent,
			
 
				+  defineComponent,
			
 
				+  defineCustomElement,
			
 
				+  defineEmits,
			
 
				+  defineExpose,
			
 
				+  defineModel,
			
 
				+  defineOptions,
			
 
				+  defineProps,
			
 
				+  defineSSRCustomElement,
			
 
				+  defineSlots,
			
 
				+  devtools,
			
 
				+  effect,
			
 
				+  effectScope,
			
 
				+  getCurrentInstance,
			
 
				+  getCurrentScope,
			
 
				+  getCurrentWatcher,
			
 
				+  getTransitionRawChildren,
			
 
				+  guardReactiveProps,
			
 
				+  h,
			
 
				+  handleError,
			
 
				+  hasInjectionContext,
			
 
				+  hydrate,
			
 
				+  hydrateOnIdle,
			
 
				+  hydrateOnInteraction,
			
 
				+  hydrateOnMediaQuery,
			
 
				+  hydrateOnVisible,
			
 
				+  initCustomFormatter,
			
 
				+  initDirectivesForSSR,
			
 
				+  inject,
			
 
				+  isMemoSame,
			
 
				+  isProxy,
			
 
				+  isReactive,
			
 
				+  isReadonly,
			
 
				+  isRef,
			
 
				+  isRuntimeOnly,
			
 
				+  isShallow,
			
 
				+  isVNode,
			
 
				+  markRaw,
			
 
				+  mergeDefaults,
			
 
				+  mergeModels,
			
 
				+  mergeProps,
			
 
				+  nextTick,
			
 
				+  nodeOps,
			
 
				+  normalizeClass,
			
 
				+  normalizeProps,
			
 
				+  normalizeStyle,
			
 
				+  onActivated,
			
 
				+  onBeforeMount,
			
 
				+  onBeforeUnmount,
			
 
				+  onBeforeUpdate,
			
 
				+  onDeactivated,
			
 
				+  onErrorCaptured,
			
 
				+  onMounted,
			
 
				+  onRenderTracked,
			
 
				+  onRenderTriggered,
			
 
				+  onScopeDispose,
			
 
				+  onServerPrefetch,
			
 
				+  onUnmounted,
			
 
				+  onUpdated,
			
 
				+  onWatcherCleanup,
			
 
				+  openBlock,
			
 
				+  patchProp,
			
 
				+  popScopeId,
			
 
				+  provide,
			
 
				+  proxyRefs,
			
 
				+  pushScopeId,
			
 
				+  queuePostFlushCb,
			
 
				+  reactive,
			
 
				+  readonly,
			
 
				+  ref,
			
 
				+  registerRuntimeCompiler,
			
 
				+  render,
			
 
				+  renderList,
			
 
				+  renderSlot,
			
 
				+  resolveComponent,
			
 
				+  resolveDirective,
			
 
				+  resolveDynamicComponent,
			
 
				+  resolveFilter,
			
 
				+  resolveTransitionHooks,
			
 
				+  setBlockTracking,
			
 
				+  setDevtoolsHook,
			
 
				+  setTransitionHooks,
			
 
				+  shallowReactive,
			
 
				+  shallowReadonly,
			
 
				+  shallowRef,
			
 
				+  ssrContextKey,
			
 
				+  ssrUtils,
			
 
				+  stop,
			
 
				+  toDisplayString,
			
 
				+  toHandlerKey,
			
 
				+  toHandlers,
			
 
				+  toRaw,
			
 
				+  toRef,
			
 
				+  toRefs,
			
 
				+  toValue,
			
 
				+  transformVNodeArgs,
			
 
				+  triggerRef,
			
 
				+  unref,
			
 
				+  useAttrs,
			
 
				+  useCssModule,
			
 
				+  useCssVars,
			
 
				+  useHost,
			
 
				+  useId,
			
 
				+  useModel,
			
 
				+  useSSRContext,
			
 
				+  useShadowRoot,
			
 
				+  useSlots,
			
 
				+  useTemplateRef,
			
 
				+  useTransitionState,
			
 
				+  vModelCheckbox,
			
 
				+  vModelDynamic,
			
 
				+  vModelRadio,
			
 
				+  vModelSelect,
			
 
				+  vModelText,
			
 
				+  vShow,
			
 
				+  version,
			
 
				+  warn,
			
 
				+  watch,
			
 
				+  watchEffect,
			
 
				+  watchPostEffect,
			
 
				+  watchSyncEffect,
			
 
				+  withAsyncContext,
			
 
				+  withCtx,
			
 
				+  withDefaults,
			
 
				+  withDirectives,
			
 
				+  withKeys,
			
 
				+  withMemo,
			
 
				+  withModifiers,
			
 
				+  withScopeId
			
 
				+};
			
 
				+//# sourceMappingURL=vue.js.map
			
--- a/ui/node_modules/.vite/deps/vue.js.map
+++ b/ui/node_modules/.vite/deps/vue.js.map
@@ -0,0 +1,7 @@
 
				+{
			
 
				+  "version": 3,
			
 
				+  "sources": [],
			
 
				+  "sourcesContent": [],
			
 
				+  "mappings": "",
			
 
				+  "names": []
			
 
				+}
			
--- a/ui/node_modules/@babel/helper-string-parser/LICENSE
+++ b/ui/node_modules/@babel/helper-string-parser/LICENSE
@@ -0,0 +1,22 @@
 
				+MIT License
			
 
				+
			
 
				+Copyright (c) 2014-present Sebastian McKenzie and other contributors
			
 
				+
			
 
				+Permission is hereby granted, free of charge, to any person obtaining
			
 
				+a copy of this software and associated documentation files (the
			
 
				+"Software"), to deal in the Software without restriction, including
			
 
				+without limitation the rights to use, copy, modify, merge, publish,
			
 
				+distribute, sublicense, and/or sell copies of the Software, and to
			
 
				+permit persons to whom the Software is furnished to do so, subject to
			
 
				+the following conditions:
			
 
				+
			
 
				+The above copyright notice and this permission notice shall be
			
 
				+included in all copies or substantial portions of the Software.
			
 
				+
			
 
				+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
			
 
				+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
			
 
				+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
			
 
				+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
			
 
				+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
			
 
				+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
			
 
				+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
			
--- a/ui/node_modules/@babel/helper-string-parser/README.md
+++ b/ui/node_modules/@babel/helper-string-parser/README.md
@@ -0,0 +1,19 @@
 
				+# @babel/helper-string-parser
			
 
				+
			
 
				+> A utility package to parse strings
			
 
				+
			
 
				+See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information.
			
 
				+
			
 
				+## Install
			
 
				+
			
 
				+Using npm:
			
 
				+
			
 
				+```sh
			
 
				+npm install --save @babel/helper-string-parser
			
 
				+```
			
 
				+
			
 
				+or using yarn:
			
 
				+
			
 
				+```sh
			
 
				+yarn add @babel/helper-string-parser
			
 
				+```
			
--- a/ui/node_modules/@babel/helper-string-parser/lib/index.js
+++ b/ui/node_modules/@babel/helper-string-parser/lib/index.js
@@ -0,0 +1,295 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.readCodePoint = readCodePoint;
			
 
				+exports.readInt = readInt;
			
 
				+exports.readStringContents = readStringContents;
			
 
				+var _isDigit = function isDigit(code) {
			
 
				+  return code >= 48 && code <= 57;
			
 
				+};
			
 
				+const forbiddenNumericSeparatorSiblings = {
			
 
				+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
			
 
				+  hex: new Set([46, 88, 95, 120])
			
 
				+};
			
 
				+const isAllowedNumericSeparatorSibling = {
			
 
				+  bin: ch => ch === 48 || ch === 49,
			
 
				+  oct: ch => ch >= 48 && ch <= 55,
			
 
				+  dec: ch => ch >= 48 && ch <= 57,
			
 
				+  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
			
 
				+};
			
 
				+function readStringContents(type, input, pos, lineStart, curLine, errors) {
			
 
				+  const initialPos = pos;
			
 
				+  const initialLineStart = lineStart;
			
 
				+  const initialCurLine = curLine;
			
 
				+  let out = "";
			
 
				+  let firstInvalidLoc = null;
			
 
				+  let chunkStart = pos;
			
 
				+  const {
			
 
				+    length
			
 
				+  } = input;
			
 
				+  for (;;) {
			
 
				+    if (pos >= length) {
			
 
				+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
			
 
				+      out += input.slice(chunkStart, pos);
			
 
				+      break;
			
 
				+    }
			
 
				+    const ch = input.charCodeAt(pos);
			
 
				+    if (isStringEnd(type, ch, input, pos)) {
			
 
				+      out += input.slice(chunkStart, pos);
			
 
				+      break;
			
 
				+    }
			
 
				+    if (ch === 92) {
			
 
				+      out += input.slice(chunkStart, pos);
			
 
				+      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
			
 
				+      if (res.ch === null && !firstInvalidLoc) {
			
 
				+        firstInvalidLoc = {
			
 
				+          pos,
			
 
				+          lineStart,
			
 
				+          curLine
			
 
				+        };
			
 
				+      } else {
			
 
				+        out += res.ch;
			
 
				+      }
			
 
				+      ({
			
 
				+        pos,
			
 
				+        lineStart,
			
 
				+        curLine
			
 
				+      } = res);
			
 
				+      chunkStart = pos;
			
 
				+    } else if (ch === 8232 || ch === 8233) {
			
 
				+      ++pos;
			
 
				+      ++curLine;
			
 
				+      lineStart = pos;
			
 
				+    } else if (ch === 10 || ch === 13) {
			
 
				+      if (type === "template") {
			
 
				+        out += input.slice(chunkStart, pos) + "\n";
			
 
				+        ++pos;
			
 
				+        if (ch === 13 && input.charCodeAt(pos) === 10) {
			
 
				+          ++pos;
			
 
				+        }
			
 
				+        ++curLine;
			
 
				+        chunkStart = lineStart = pos;
			
 
				+      } else {
			
 
				+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
			
 
				+      }
			
 
				+    } else {
			
 
				+      ++pos;
			
 
				+    }
			
 
				+  }
			
 
				+  return {
			
 
				+    pos,
			
 
				+    str: out,
			
 
				+    firstInvalidLoc,
			
 
				+    lineStart,
			
 
				+    curLine,
			
 
				+    containsInvalid: !!firstInvalidLoc
			
 
				+  };
			
 
				+}
			
 
				+function isStringEnd(type, ch, input, pos) {
			
 
				+  if (type === "template") {
			
 
				+    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
			
 
				+  }
			
 
				+  return ch === (type === "double" ? 34 : 39);
			
 
				+}
			
 
				+function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
			
 
				+  const throwOnInvalid = !inTemplate;
			
 
				+  pos++;
			
 
				+  const res = ch => ({
			
 
				+    pos,
			
 
				+    ch,
			
 
				+    lineStart,
			
 
				+    curLine
			
 
				+  });
			
 
				+  const ch = input.charCodeAt(pos++);
			
 
				+  switch (ch) {
			
 
				+    case 110:
			
 
				+      return res("\n");
			
 
				+    case 114:
			
 
				+      return res("\r");
			
 
				+    case 120:
			
 
				+      {
			
 
				+        let code;
			
 
				+        ({
			
 
				+          code,
			
 
				+          pos
			
 
				+        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
			
 
				+        return res(code === null ? null : String.fromCharCode(code));
			
 
				+      }
			
 
				+    case 117:
			
 
				+      {
			
 
				+        let code;
			
 
				+        ({
			
 
				+          code,
			
 
				+          pos
			
 
				+        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
			
 
				+        return res(code === null ? null : String.fromCodePoint(code));
			
 
				+      }
			
 
				+    case 116:
			
 
				+      return res("\t");
			
 
				+    case 98:
			
 
				+      return res("\b");
			
 
				+    case 118:
			
 
				+      return res("\u000b");
			
 
				+    case 102:
			
 
				+      return res("\f");
			
 
				+    case 13:
			
 
				+      if (input.charCodeAt(pos) === 10) {
			
 
				+        ++pos;
			
 
				+      }
			
 
				+    case 10:
			
 
				+      lineStart = pos;
			
 
				+      ++curLine;
			
 
				+    case 8232:
			
 
				+    case 8233:
			
 
				+      return res("");
			
 
				+    case 56:
			
 
				+    case 57:
			
 
				+      if (inTemplate) {
			
 
				+        return res(null);
			
 
				+      } else {
			
 
				+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
			
 
				+      }
			
 
				+    default:
			
 
				+      if (ch >= 48 && ch <= 55) {
			
 
				+        const startPos = pos - 1;
			
 
				+        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
			
 
				+        let octalStr = match[0];
			
 
				+        let octal = parseInt(octalStr, 8);
			
 
				+        if (octal > 255) {
			
 
				+          octalStr = octalStr.slice(0, -1);
			
 
				+          octal = parseInt(octalStr, 8);
			
 
				+        }
			
 
				+        pos += octalStr.length - 1;
			
 
				+        const next = input.charCodeAt(pos);
			
 
				+        if (octalStr !== "0" || next === 56 || next === 57) {
			
 
				+          if (inTemplate) {
			
 
				+            return res(null);
			
 
				+          } else {
			
 
				+            errors.strictNumericEscape(startPos, lineStart, curLine);
			
 
				+          }
			
 
				+        }
			
 
				+        return res(String.fromCharCode(octal));
			
 
				+      }
			
 
				+      return res(String.fromCharCode(ch));
			
 
				+  }
			
 
				+}
			
 
				+function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
			
 
				+  const initialPos = pos;
			
 
				+  let n;
			
 
				+  ({
			
 
				+    n,
			
 
				+    pos
			
 
				+  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
			
 
				+  if (n === null) {
			
 
				+    if (throwOnInvalid) {
			
 
				+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
			
 
				+    } else {
			
 
				+      pos = initialPos - 1;
			
 
				+    }
			
 
				+  }
			
 
				+  return {
			
 
				+    code: n,
			
 
				+    pos
			
 
				+  };
			
 
				+}
			
 
				+function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
			
 
				+  const start = pos;
			
 
				+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
			
 
				+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
			
 
				+  let invalid = false;
			
 
				+  let total = 0;
			
 
				+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
			
 
				+    const code = input.charCodeAt(pos);
			
 
				+    let val;
			
 
				+    if (code === 95 && allowNumSeparator !== "bail") {
			
 
				+      const prev = input.charCodeAt(pos - 1);
			
 
				+      const next = input.charCodeAt(pos + 1);
			
 
				+      if (!allowNumSeparator) {
			
 
				+        if (bailOnError) return {
			
 
				+          n: null,
			
 
				+          pos
			
 
				+        };
			
 
				+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
			
 
				+      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
			
 
				+        if (bailOnError) return {
			
 
				+          n: null,
			
 
				+          pos
			
 
				+        };
			
 
				+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
			
 
				+      }
			
 
				+      ++pos;
			
 
				+      continue;
			
 
				+    }
			
 
				+    if (code >= 97) {
			
 
				+      val = code - 97 + 10;
			
 
				+    } else if (code >= 65) {
			
 
				+      val = code - 65 + 10;
			
 
				+    } else if (_isDigit(code)) {
			
 
				+      val = code - 48;
			
 
				+    } else {
			
 
				+      val = Infinity;
			
 
				+    }
			
 
				+    if (val >= radix) {
			
 
				+      if (val <= 9 && bailOnError) {
			
 
				+        return {
			
 
				+          n: null,
			
 
				+          pos
			
 
				+        };
			
 
				+      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
			
 
				+        val = 0;
			
 
				+      } else if (forceLen) {
			
 
				+        val = 0;
			
 
				+        invalid = true;
			
 
				+      } else {
			
 
				+        break;
			
 
				+      }
			
 
				+    }
			
 
				+    ++pos;
			
 
				+    total = total * radix + val;
			
 
				+  }
			
 
				+  if (pos === start || len != null && pos - start !== len || invalid) {
			
 
				+    return {
			
 
				+      n: null,
			
 
				+      pos
			
 
				+    };
			
 
				+  }
			
 
				+  return {
			
 
				+    n: total,
			
 
				+    pos
			
 
				+  };
			
 
				+}
			
 
				+function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
			
 
				+  const ch = input.charCodeAt(pos);
			
 
				+  let code;
			
 
				+  if (ch === 123) {
			
 
				+    ++pos;
			
 
				+    ({
			
 
				+      code,
			
 
				+      pos
			
 
				+    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
			
 
				+    ++pos;
			
 
				+    if (code !== null && code > 0x10ffff) {
			
 
				+      if (throwOnInvalid) {
			
 
				+        errors.invalidCodePoint(pos, lineStart, curLine);
			
 
				+      } else {
			
 
				+        return {
			
 
				+          code: null,
			
 
				+          pos
			
 
				+        };
			
 
				+      }
			
 
				+    }
			
 
				+  } else {
			
 
				+    ({
			
 
				+      code,
			
 
				+      pos
			
 
				+    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
			
 
				+  }
			
 
				+  return {
			
 
				+    code,
			
 
				+    pos
			
 
				+  };
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=index.js.map
			
--- a/ui/node_modules/@babel/helper-string-parser/lib/index.js.map
+++ b/ui/node_modules/@babel/helper-string-parser/lib/index.js.map
--- a/ui/node_modules/@babel/helper-string-parser/package.json
+++ b/ui/node_modules/@babel/helper-string-parser/package.json
@@ -0,0 +1,31 @@
 
				+{
			
 
				+  "name": "@babel/helper-string-parser",
			
 
				+  "version": "7.27.1",
			
 
				+  "description": "A utility package to parse strings",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/babel/babel.git",
			
 
				+    "directory": "packages/babel-helper-string-parser"
			
 
				+  },
			
 
				+  "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser",
			
 
				+  "license": "MIT",
			
 
				+  "publishConfig": {
			
 
				+    "access": "public"
			
 
				+  },
			
 
				+  "main": "./lib/index.js",
			
 
				+  "devDependencies": {
			
 
				+    "charcodes": "^0.2.0"
			
 
				+  },
			
 
				+  "engines": {
			
 
				+    "node": ">=6.9.0"
			
 
				+  },
			
 
				+  "author": "The Babel Team (https://babel.dev/team)",
			
 
				+  "exports": {
			
 
				+    ".": {
			
 
				+      "types": "./lib/index.d.ts",
			
 
				+      "default": "./lib/index.js"
			
 
				+    },
			
 
				+    "./package.json": "./package.json"
			
 
				+  },
			
 
				+  "type": "commonjs"
			
 
				+}
			
--- a/ui/node_modules/@babel/helper-validator-identifier/LICENSE
+++ b/ui/node_modules/@babel/helper-validator-identifier/LICENSE
@@ -0,0 +1,22 @@
 
				+MIT License
			
 
				+
			
 
				+Copyright (c) 2014-present Sebastian McKenzie and other contributors
			
 
				+
			
 
				+Permission is hereby granted, free of charge, to any person obtaining
			
 
				+a copy of this software and associated documentation files (the
			
 
				+"Software"), to deal in the Software without restriction, including
			
 
				+without limitation the rights to use, copy, modify, merge, publish,
			
 
				+distribute, sublicense, and/or sell copies of the Software, and to
			
 
				+permit persons to whom the Software is furnished to do so, subject to
			
 
				+the following conditions:
			
 
				+
			
 
				+The above copyright notice and this permission notice shall be
			
 
				+included in all copies or substantial portions of the Software.
			
 
				+
			
 
				+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
			
 
				+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
			
 
				+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
			
 
				+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
			
 
				+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
			
 
				+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
			
 
				+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
			
--- a/ui/node_modules/@babel/helper-validator-identifier/README.md
+++ b/ui/node_modules/@babel/helper-validator-identifier/README.md
@@ -0,0 +1,19 @@
 
				+# @babel/helper-validator-identifier
			
 
				+
			
 
				+> Validate identifier/keywords name
			
 
				+
			
 
				+See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/babel-helper-validator-identifier) for more information.
			
 
				+
			
 
				+## Install
			
 
				+
			
 
				+Using npm:
			
 
				+
			
 
				+```sh
			
 
				+npm install --save @babel/helper-validator-identifier
			
 
				+```
			
 
				+
			
 
				+or using yarn:
			
 
				+
			
 
				+```sh
			
 
				+yarn add @babel/helper-validator-identifier
			
 
				+```
			
--- a/ui/node_modules/@babel/helper-validator-identifier/lib/identifier.js
+++ b/ui/node_modules/@babel/helper-validator-identifier/lib/identifier.js
--- a/ui/node_modules/@babel/helper-validator-identifier/lib/identifier.js.map
+++ b/ui/node_modules/@babel/helper-validator-identifier/lib/identifier.js.map
--- a/ui/node_modules/@babel/helper-validator-identifier/lib/index.js
+++ b/ui/node_modules/@babel/helper-validator-identifier/lib/index.js
@@ -0,0 +1,57 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+Object.defineProperty(exports, "isIdentifierChar", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _identifier.isIdentifierChar;
			
 
				+  }
			
 
				+});
			
 
				+Object.defineProperty(exports, "isIdentifierName", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _identifier.isIdentifierName;
			
 
				+  }
			
 
				+});
			
 
				+Object.defineProperty(exports, "isIdentifierStart", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _identifier.isIdentifierStart;
			
 
				+  }
			
 
				+});
			
 
				+Object.defineProperty(exports, "isKeyword", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _keyword.isKeyword;
			
 
				+  }
			
 
				+});
			
 
				+Object.defineProperty(exports, "isReservedWord", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _keyword.isReservedWord;
			
 
				+  }
			
 
				+});
			
 
				+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _keyword.isStrictBindOnlyReservedWord;
			
 
				+  }
			
 
				+});
			
 
				+Object.defineProperty(exports, "isStrictBindReservedWord", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _keyword.isStrictBindReservedWord;
			
 
				+  }
			
 
				+});
			
 
				+Object.defineProperty(exports, "isStrictReservedWord", {
			
 
				+  enumerable: true,
			
 
				+  get: function () {
			
 
				+    return _keyword.isStrictReservedWord;
			
 
				+  }
			
 
				+});
			
 
				+var _identifier = require("./identifier.js");
			
 
				+var _keyword = require("./keyword.js");
			
 
				+
			
 
				+//# sourceMappingURL=index.js.map
			
--- a/ui/node_modules/@babel/helper-validator-identifier/lib/index.js.map
+++ b/ui/node_modules/@babel/helper-validator-identifier/lib/index.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_identifier","require","_keyword"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  isIdentifierName,\n  isIdentifierChar,\n  isIdentifierStart,\n} from \"./identifier.ts\";\nexport {\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"./keyword.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAKA,IAAAC,QAAA,GAAAD,OAAA","ignoreList":[]}
			
--- a/ui/node_modules/@babel/helper-validator-identifier/lib/keyword.js
+++ b/ui/node_modules/@babel/helper-validator-identifier/lib/keyword.js
@@ -0,0 +1,35 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.isKeyword = isKeyword;
			
 
				+exports.isReservedWord = isReservedWord;
			
 
				+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
			
 
				+exports.isStrictBindReservedWord = isStrictBindReservedWord;
			
 
				+exports.isStrictReservedWord = isStrictReservedWord;
			
 
				+const reservedWords = {
			
 
				+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
			
 
				+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
			
 
				+  strictBind: ["eval", "arguments"]
			
 
				+};
			
 
				+const keywords = new Set(reservedWords.keyword);
			
 
				+const reservedWordsStrictSet = new Set(reservedWords.strict);
			
 
				+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
			
 
				+function isReservedWord(word, inModule) {
			
 
				+  return inModule && word === "await" || word === "enum";
			
 
				+}
			
 
				+function isStrictReservedWord(word, inModule) {
			
 
				+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
			
 
				+}
			
 
				+function isStrictBindOnlyReservedWord(word) {
			
 
				+  return reservedWordsStrictBindSet.has(word);
			
 
				+}
			
 
				+function isStrictBindReservedWord(word, inModule) {
			
 
				+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
			
 
				+}
			
 
				+function isKeyword(word) {
			
 
				+  return keywords.has(word);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=keyword.js.map
			
--- a/ui/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map
+++ b/ui/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map
--- a/ui/node_modules/@babel/helper-validator-identifier/package.json
+++ b/ui/node_modules/@babel/helper-validator-identifier/package.json
@@ -0,0 +1,31 @@
 
				+{
			
 
				+  "name": "@babel/helper-validator-identifier",
			
 
				+  "version": "7.28.5",
			
 
				+  "description": "Validate identifier/keywords name",
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/babel/babel.git",
			
 
				+    "directory": "packages/babel-helper-validator-identifier"
			
 
				+  },
			
 
				+  "license": "MIT",
			
 
				+  "publishConfig": {
			
 
				+    "access": "public"
			
 
				+  },
			
 
				+  "main": "./lib/index.js",
			
 
				+  "exports": {
			
 
				+    ".": {
			
 
				+      "types": "./lib/index.d.ts",
			
 
				+      "default": "./lib/index.js"
			
 
				+    },
			
 
				+    "./package.json": "./package.json"
			
 
				+  },
			
 
				+  "devDependencies": {
			
 
				+    "@unicode/unicode-17.0.0": "^1.6.10",
			
 
				+    "charcodes": "^0.2.0"
			
 
				+  },
			
 
				+  "engines": {
			
 
				+    "node": ">=6.9.0"
			
 
				+  },
			
 
				+  "author": "The Babel Team (https://babel.dev/team)",
			
 
				+  "type": "commonjs"
			
 
				+}
			
--- a/ui/node_modules/@babel/parser/CHANGELOG.md
+++ b/ui/node_modules/@babel/parser/CHANGELOG.md
@@ -0,0 +1,1073 @@
 
				+# Changelog
			
 
				+
			
 
				+> **Tags:**
			
 
				+> - :boom:       [Breaking Change]
			
 
				+> - :eyeglasses: [Spec Compliance]
			
 
				+> - :rocket:     [New Feature]
			
 
				+> - :bug:        [Bug Fix]
			
 
				+> - :memo:       [Documentation]
			
 
				+> - :house:      [Internal]
			
 
				+> - :nail_care:  [Polish]
			
 
				+
			
 
				+> Semver Policy: https://github.com/babel/babel/tree/main/packages/babel-parser#semver
			
 
				+
			
 
				+_Note: Gaps between patch versions are faulty, broken or test releases._
			
 
				+
			
 
				+See the [Babel Changelog](https://github.com/babel/babel/blob/main/CHANGELOG.md) for the pre-6.8.0 version Changelog.
			
 
				+
			
 
				+## 6.17.1 (2017-05-10)
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+ * Fix typo in flow spread operator error (Brian Ng)
			
 
				+ * Fixed invalid number literal parsing ([#473](https://github.com/babel/babylon/pull/473)) (Alex Kuzmenko)
			
 
				+ * Fix number parser ([#433](https://github.com/babel/babylon/pull/433)) (Alex Kuzmenko)
			
 
				+ * Ensure non pattern shorthand props are checked for reserved words ([#479](https://github.com/babel/babylon/pull/479)) (Brian Ng)
			
 
				+ * Remove jsx context when parsing arrow functions ([#475](https://github.com/babel/babylon/pull/475)) (Brian Ng)
			
 
				+ * Allow super in class properties ([#499](https://github.com/babel/babylon/pull/499)) (Brian Ng)
			
 
				+ * Allow flow class field to be named constructor ([#510](https://github.com/babel/babylon/pull/510)) (Brian Ng)
			
 
				+
			
 
				+## 6.17.0 (2017-04-20)
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+ * Cherry-pick #418 to 6.x ([#476](https://github.com/babel/babylon/pull/476)) (Sebastian McKenzie)
			
 
				+ * Add support for invalid escapes in tagged templates ([#274](https://github.com/babel/babylon/pull/274)) (Kevin Gibbons)
			
 
				+ * Throw error if new.target is used outside of a function ([#402](https://github.com/babel/babylon/pull/402)) (Brian Ng)
			
 
				+ * Fix parsing of class properties ([#351](https://github.com/babel/babylon/pull/351)) (Kevin Gibbons)
			
 
				+ * Fix parsing yield with dynamicImport ([#383](https://github.com/babel/babylon/pull/383)) (Brian Ng)
			
 
				+ * Ensure consistent start args for parseParenItem ([#386](https://github.com/babel/babylon/pull/386)) (Brian Ng)
			
 
				+
			
 
				+## 7.0.0-beta.8 (2017-04-04)
			
 
				+
			
 
				+### New Feature
			
 
				+* Add support for flow type spread (#418) (Conrad Buck)
			
 
				+* Allow statics in flow interfaces (#427) (Brian Ng)
			
 
				+
			
 
				+### Bug Fix
			
 
				+* Fix predicate attachment to match flow parser (#428) (Brian Ng)
			
 
				+* Add extra.raw back to JSXText and JSXAttribute (#344) (Alex Rattray)
			
 
				+* Fix rest parameters with array and objects (#424) (Brian Ng)
			
 
				+* Fix number parser (#433) (Alex Kuzmenko)
			
 
				+
			
 
				+### Docs
			
 
				+* Fix CONTRIBUTING.md [skip ci] (#432) (Alex Kuzmenko)
			
 
				+
			
 
				+### Internal
			
 
				+* Use babel-register script when running babel smoke tests (#442) (Brian Ng)
			
 
				+
			
 
				+## 7.0.0-beta.7 (2017-03-22)
			
 
				+
			
 
				+### Spec Compliance
			
 
				+* Remove babylon plugin for template revision since it's stage-4 (#426) (Henry Zhu)
			
 
				+
			
 
				+### Bug Fix
			
 
				+
			
 
				+* Fix push-pop logic in flow (#405) (Daniel Tschinder)
			
 
				+
			
 
				+## 7.0.0-beta.6 (2017-03-21)
			
 
				+
			
 
				+### New Feature
			
 
				+* Add support for invalid escapes in tagged templates (#274) (Kevin Gibbons)
			
 
				+
			
 
				+### Polish
			
 
				+* Improves error message when super is called outside of constructor (#408) (Arshabh Kumar Agarwal)
			
 
				+
			
 
				+### Docs
			
 
				+
			
 
				+* [7.0] Moved value field in spec from ObjectMember to ObjectProperty as ObjectMethod's don't have it (#415) [skip ci] (James Browning)
			
 
				+
			
 
				+## 7.0.0-beta.5 (2017-03-21)
			
 
				+
			
 
				+### Bug Fix
			
 
				+* Throw error if new.target is used outside of a function (#402) (Brian Ng)
			
 
				+* Fix parsing of class properties (#351) (Kevin Gibbons)
			
 
				+
			
 
				+### Other
			
 
				+ * Test runner: Detect extra property in 'actual' but not in 'expected'. (#407) (Andy)
			
 
				+ * Optimize travis builds (#419) (Daniel Tschinder)
			
 
				+ * Update codecov to 2.0 (#412) (Daniel Tschinder)
			
 
				+ * Fix spec for ClassMethod: It doesn't have a function, it *is* a function. (#406) [skip ci] (Andy)
			
 
				+ * Changed Non-existent RestPattern to RestElement which is what is actually parsed (#409) [skip ci] (James Browning)
			
 
				+ * Upgrade flow to 0.41 (Daniel Tschinder)
			
 
				+ * Fix watch command (#403) (Brian Ng)
			
 
				+ * Update yarn lock (Daniel Tschinder)
			
 
				+ * Fix watch command (#403) (Brian Ng)
			
 
				+ * chore(package): update flow-bin to version 0.41.0 (#395) (greenkeeper[bot])
			
 
				+ * Add estree test for correct order of directives (Daniel Tschinder)
			
 
				+ * Add DoExpression to spec (#364) (Alex Kuzmenko)
			
 
				+ * Mention cloning of repository in CONTRIBUTING.md (#391) [skip ci] (Sumedh Nimkarde)
			
 
				+ * Explain how to run only one test (#389) [skip ci] (Aaron Ang)
			
 
				+
			
 
				+ ## 7.0.0-beta.4 (2017-03-01)
			
 
				+
			
 
				+* Don't consume async when checking for async func decl (#377) (Brian Ng)
			
 
				+* add `ranges` option [skip ci] (Henry Zhu)
			
 
				+* Don't parse class properties without initializers when classProperties is disabled and Flow is enabled (#300) (Andrew Levine)
			
 
				+
			
 
				+## 7.0.0-beta.3 (2017-02-28)
			
 
				+
			
 
				+- [7.0] Change RestProperty/SpreadProperty to RestElement/SpreadElement (#384)
			
 
				+- Merge changes from 6.x
			
 
				+
			
 
				+## 7.0.0-beta.2 (2017-02-20)
			
 
				+
			
 
				+- estree: correctly change literals in all cases (#368) (Daniel Tschinder)
			
 
				+
			
 
				+## 7.0.0-beta.1 (2017-02-20)
			
 
				+
			
 
				+- Fix negative number literal typeannotations (#366) (Daniel Tschinder)
			
 
				+- Update contributing with more test info [skip ci] (#355) (Brian Ng)
			
 
				+
			
 
				+## 7.0.0-beta.0 (2017-02-15)
			
 
				+
			
 
				+- Reintroduce Variance node (#333) (Daniel Tschinder)
			
 
				+- Rename NumericLiteralTypeAnnotation to NumberLiteralTypeAnnotation (#332) (Charles Pick)
			
 
				+- [7.0] Remove ForAwaitStatement, add await flag to ForOfStatement (#349) (Brandon Dail)
			
 
				+- chore(package): update ava to version 0.18.0 (#345) (greenkeeper[bot])
			
 
				+- chore(package): update babel-plugin-istanbul to version 4.0.0 (#350) (greenkeeper[bot])
			
 
				+- Change location of ObjectTypeIndexer to match flow (#228) (Daniel Tschinder)
			
 
				+- Rename flow AST Type ExistentialTypeParam to ExistsTypeAnnotation (#322) (Toru Kobayashi)
			
 
				+- Revert "Temporary rollback for erroring on trailing comma with spread (#154)" (#290) (Daniel Tschinder)
			
 
				+- Remove classConstructorCall plugin (#291) (Brian Ng)
			
 
				+- Update yarn.lock (Daniel Tschinder)
			
 
				+- Update cross-env to 3.x (Daniel Tschinder)
			
 
				+- [7.0] Remove node 0.10, 0.12 and 5 from Travis (#284) (Sergey Rubanov)
			
 
				+- Remove `String.fromCodePoint` shim (#279) (Mathias Bynens)
			
 
				+
			
 
				+## 6.16.1 (2017-02-23)
			
 
				+
			
 
				+### :bug: Regression
			
 
				+
			
 
				+- Revert "Fix export default async function to be FunctionDeclaration" ([#375](https://github.com/babel/babylon/pull/375))
			
 
				+
			
 
				+Need to modify Babel for this AST node change, so moving to 7.0.
			
 
				+
			
 
				+- Revert "Don't parse class properties without initializers when classProperties plugin is disabled, and Flow is enabled" ([#376](https://github.com/babel/babylon/pull/376))
			
 
				+
			
 
				+[react-native](https://github.com/facebook/react-native/issues/12542) broke with this so we reverted.
			
 
				+
			
 
				+## 6.16.0 (2017-02-23)
			
 
				+
			
 
				+### :rocket: New Feature
			
 
				+
			
 
				+***ESTree*** compatibility as plugin ([#277](https://github.com/babel/babylon/pull/277)) (Daniel Tschinder)
			
 
				+
			
 
				+We finally introduce a new compatibility layer for ESTree. To put babylon into ESTree-compatible mode the new plugin `estree` can be enabled. In this mode the parser will output an AST that is compliant to the specs of [ESTree](https://github.com/estree/estree/)
			
 
				+
			
 
				+We highly recommend everyone who uses babylon outside of babel to use this plugin. This will make it much easier for users to switch between different ESTree-compatible parsers. We so far tested several projects with different parsers and exchanged their parser to babylon and in nearly all cases it worked out of the box. Some other estree-compatible parsers include `acorn`, `esprima`, `espree`, `flow-parser`, etc.
			
 
				+
			
 
				+To enable `estree` mode simply add the plugin in the config:
			
 
				+```json
			
 
				+{
			
 
				+  "plugins": [ "estree" ]
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+If you want to migrate your project from non-ESTree mode to ESTree, have a look at our [Readme](https://github.com/babel/babylon/#output), where all deviations are mentioned.
			
 
				+
			
 
				+Add a parseExpression public method ([#213](https://github.com/babel/babylon/pull/213)) (jeromew)
			
 
				+
			
 
				+Babylon exports a new function to parse a single expression
			
 
				+
			
 
				+```js
			
 
				+import { parseExpression } from 'babylon';
			
 
				+
			
 
				+const ast = parseExpression('x || y && z', options);
			
 
				+```
			
 
				+
			
 
				+The returned AST will only consist of the expression. The options are the same as for `parse()`
			
 
				+
			
 
				+Add startLine option ([#346](https://github.com/babel/babylon/pull/346)) (Raphael Mu)
			
 
				+
			
 
				+A new option was added to babylon allowing to change the initial linenumber for the first line which is usually `1`.
			
 
				+Changing this for example to `100` will make line `1` of the input source to be marked as line `100`, line `2` as `101`, line `3` as `102`, ...
			
 
				+
			
 
				+Function predicate declaration ([#103](https://github.com/babel/babylon/pull/103)) (Panagiotis Vekris)
			
 
				+
			
 
				+Added support for function predicates which flow introduced in version 0.33.0
			
 
				+
			
 
				+```js
			
 
				+declare function is_number(x: mixed): boolean %checks(typeof x === "number");
			
 
				+```
			
 
				+
			
 
				+Allow imports in declare module ([#315](https://github.com/babel/babylon/pull/315)) (Daniel Tschinder)
			
 
				+
			
 
				+Added support for imports within module declarations which flow introduced in version 0.37.0
			
 
				+
			
 
				+```js
			
 
				+declare module "C" {
			
 
				+  import type { DT } from "D";
			
 
				+  declare export type CT = { D: DT };
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+### :eyeglasses: Spec Compliance
			
 
				+
			
 
				+Forbid semicolons after decorators in classes ([#352](https://github.com/babel/babylon/pull/352)) (Kevin Gibbons)
			
 
				+
			
 
				+This example now correctly throws an error when there is a semicolon after the decorator:
			
 
				+
			
 
				+```js
			
 
				+class A {
			
 
				+@a;
			
 
				+foo(){}
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+Keywords are not allowed as local specifier ([#307](https://github.com/babel/babylon/pull/307)) (Daniel Tschinder)
			
 
				+
			
 
				+Using keywords in imports is not allowed anymore:
			
 
				+
			
 
				+```js
			
 
				+import { default } from "foo";
			
 
				+import { a as debugger } from "foo";
			
 
				+```
			
 
				+
			
 
				+Do not allow overwritting of primitive types ([#314](https://github.com/babel/babylon/pull/314)) (Daniel Tschinder)
			
 
				+
			
 
				+In flow it is now forbidden to overwrite the primitive types `"any"`, `"mixed"`, `"empty"`, `"bool"`, `"boolean"`, `"number"`, `"string"`, `"void"` and `"null"` with your own type declaration.
			
 
				+
			
 
				+Disallow import type { type a } from … ([#305](https://github.com/babel/babylon/pull/305)) (Daniel Tschinder)
			
 
				+
			
 
				+The following code now correctly throws an error
			
 
				+
			
 
				+```js
			
 
				+import type { type a } from "foo";
			
 
				+```
			
 
				+
			
 
				+Don't parse class properties without initializers when classProperties is disabled and Flow is enabled ([#300](https://github.com/babel/babylon/pull/300)) (Andrew Levine)
			
 
				+
			
 
				+Ensure that you enable the `classProperties` plugin in order to enable correct parsing of class properties. Prior to this version it was possible to parse them by enabling the `flow` plugin but this was not intended the behaviour.
			
 
				+
			
 
				+If you enable the flow plugin you can only define the type of the class properties, but not initialize them.
			
 
				+
			
 
				+Fix export default async function to be FunctionDeclaration ([#324](https://github.com/babel/babylon/pull/324)) (Daniel Tschinder)
			
 
				+
			
 
				+Parsing the following code now returns a `FunctionDeclaration` AST node instead of `FunctionExpression`.
			
 
				+
			
 
				+```js
			
 
				+export default async function bar() {};
			
 
				+```
			
 
				+
			
 
				+### :nail_care: Polish
			
 
				+
			
 
				+Improve error message on attempt to destructure named import ([#288](https://github.com/babel/babylon/pull/288)) (Brian Ng)
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+
			
 
				+Fix negative number literal typeannotations ([#366](https://github.com/babel/babylon/pull/366)) (Daniel Tschinder)
			
 
				+
			
 
				+Ensure takeDecorators is called on exported class ([#358](https://github.com/babel/babylon/pull/358)) (Brian Ng)
			
 
				+
			
 
				+ESTree: correctly change literals in all cases ([#368](https://github.com/babel/babylon/pull/368)) (Daniel Tschinder)
			
 
				+
			
 
				+Correctly convert RestProperty to Assignable ([#339](https://github.com/babel/babylon/pull/339)) (Daniel Tschinder)
			
 
				+
			
 
				+Fix #321 by allowing question marks in type params ([#338](https://github.com/babel/babylon/pull/338)) (Daniel Tschinder)
			
 
				+
			
 
				+Fix #336 by correctly setting arrow-param ([#337](https://github.com/babel/babylon/pull/337)) (Daniel Tschinder)
			
 
				+
			
 
				+Fix parse error when destructuring `set` with default value ([#317](https://github.com/babel/babylon/pull/317)) (Brian Ng)
			
 
				+
			
 
				+Fix ObjectTypeCallProperty static ([#298](https://github.com/babel/babylon/pull/298)) (Dan Harper)
			
 
				+
			
 
				+
			
 
				+### :house: Internal
			
 
				+
			
 
				+Fix generator-method-with-computed-name spec ([#360](https://github.com/babel/babylon/pull/360)) (Alex Rattray)
			
 
				+
			
 
				+Fix flow type-parameter-declaration test with unintended semantic ([#361](https://github.com/babel/babylon/pull/361)) (Alex Rattray)
			
 
				+
			
 
				+Cleanup and splitup parser functions ([#295](https://github.com/babel/babylon/pull/295)) (Daniel Tschinder)
			
 
				+
			
 
				+chore(package): update flow-bin to version 0.38.0 ([#313](https://github.com/babel/babylon/pull/313)) (greenkeeper[bot])
			
 
				+
			
 
				+Call inner function instead of 1:1 copy to plugin ([#294](https://github.com/babel/babylon/pull/294)) (Daniel Tschinder)
			
 
				+
			
 
				+Update eslint-config-babel to the latest version 🚀 ([#299](https://github.com/babel/babylon/pull/299)) (greenkeeper[bot])
			
 
				+
			
 
				+Update eslint-config-babel to the latest version 🚀 ([#293](https://github.com/babel/babylon/pull/293)) (greenkeeper[bot])
			
 
				+
			
 
				+devDeps: remove eslint-plugin-babel ([#292](https://github.com/babel/babylon/pull/292)) (Kai Cataldo)
			
 
				+
			
 
				+Correct indent eslint rule config ([#276](https://github.com/babel/babylon/pull/276)) (Daniel Tschinder)
			
 
				+
			
 
				+Fail tests that have expected.json and throws-option ([#285](https://github.com/babel/babylon/pull/285)) (Daniel Tschinder)
			
 
				+
			
 
				+### :memo: Documentation
			
 
				+
			
 
				+Update contributing with more test info [skip ci] ([#355](https://github.com/babel/babylon/pull/355)) (Brian Ng)
			
 
				+
			
 
				+Update API documentation ([#330](https://github.com/babel/babylon/pull/330)) (Timothy Gu)
			
 
				+
			
 
				+Added keywords to package.json ([#323](https://github.com/babel/babylon/pull/323)) (Dmytro)
			
 
				+
			
 
				+AST spec: fix casing of `RegExpLiteral` ([#318](https://github.com/babel/babylon/pull/318)) (Mathias Bynens)
			
 
				+
			
 
				+## 6.15.0 (2017-01-10)
			
 
				+
			
 
				+### :eyeglasses: Spec Compliance
			
 
				+
			
 
				+Add support for Flow shorthand import type ([#267](https://github.com/babel/babylon/pull/267)) (Jeff Morrison)
			
 
				+
			
 
				+This change implements flows new shorthand import syntax
			
 
				+and where previously you had to write this code:
			
 
				+
			
 
				+```js
			
 
				+import {someValue} from "blah";
			
 
				+import type {someType} from "blah";
			
 
				+import typeof {someOtherValue} from "blah";
			
 
				+```
			
 
				+
			
 
				+you can now write it like this:
			
 
				+
			
 
				+```js
			
 
				+import {
			
 
				+  someValue,
			
 
				+  type someType,
			
 
				+  typeof someOtherValue,
			
 
				+} from "blah";
			
 
				+```
			
 
				+
			
 
				+For more information look at [this](https://github.com/facebook/flow/pull/2890) pull request.
			
 
				+
			
 
				+flow: allow leading pipes in all positions ([#256](https://github.com/babel/babylon/pull/256)) (Vladimir Kurchatkin)
			
 
				+
			
 
				+This change now allows a leading pipe everywhere types can be used:
			
 
				+```js
			
 
				+var f = (x): | 1 | 2 => 1;
			
 
				+```
			
 
				+
			
 
				+Throw error when exporting non-declaration ([#241](https://github.com/babel/babylon/pull/241)) (Kai Cataldo)
			
 
				+
			
 
				+Previously babylon parsed the following exports, although they are not valid:
			
 
				+```js
			
 
				+export typeof foo;
			
 
				+export new Foo();
			
 
				+export function() {};
			
 
				+export for (;;);
			
 
				+export while(foo);
			
 
				+```
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+
			
 
				+Don't set inType flag when parsing property names ([#266](https://github.com/babel/babylon/pull/266)) (Vladimir Kurchatkin)
			
 
				+
			
 
				+This fixes parsing of this case:
			
 
				+
			
 
				+```js
			
 
				+const map = {
			
 
				+  [age <= 17] : 'Too young'
			
 
				+};
			
 
				+```
			
 
				+
			
 
				+Fix source location for JSXEmptyExpression nodes (fixes #248) ([#249](https://github.com/babel/babylon/pull/249)) (James Long)
			
 
				+
			
 
				+The following case produced an invalid AST
			
 
				+```js
			
 
				+<div>{/* foo */}</div>
			
 
				+```
			
 
				+
			
 
				+Use fromCodePoint to convert high value unicode entities ([#243](https://github.com/babel/babylon/pull/243)) (Ryan Duffy)
			
 
				+
			
 
				+When high value unicode entities (e.g. 💩) were used in the input source code they are now correctly encoded in the resulting AST.
			
 
				+
			
 
				+Rename folder to avoid Windows-illegal characters ([#281](https://github.com/babel/babylon/pull/281)) (Ryan Plant)
			
 
				+
			
 
				+Allow this.state.clone() when parsing decorators ([#262](https://github.com/babel/babylon/pull/262)) (Alex Rattray)
			
 
				+
			
 
				+### :house: Internal
			
 
				+
			
 
				+User external-helpers ([#254](https://github.com/babel/babylon/pull/254)) (Daniel Tschinder)
			
 
				+
			
 
				+Add watch script for dev ([#234](https://github.com/babel/babylon/pull/234)) (Kai Cataldo)
			
 
				+
			
 
				+Freeze current plugins list for "*" option, and remove from README.md ([#245](https://github.com/babel/babylon/pull/245)) (Andrew Levine)
			
 
				+
			
 
				+Prepare tests for multiple fixture runners. ([#240](https://github.com/babel/babylon/pull/240)) (Daniel Tschinder)
			
 
				+
			
 
				+Add some test coverage for decorators stage-0 plugin ([#250](https://github.com/babel/babylon/pull/250)) (Andrew Levine)
			
 
				+
			
 
				+Refactor tokenizer types file ([#263](https://github.com/babel/babylon/pull/263)) (Sven SAULEAU)
			
 
				+
			
 
				+Update eslint-config-babel to the latest version 🚀 ([#273](https://github.com/babel/babylon/pull/273)) (greenkeeper[bot])
			
 
				+
			
 
				+chore(package): update rollup to version 0.41.0 ([#272](https://github.com/babel/babylon/pull/272)) (greenkeeper[bot])
			
 
				+
			
 
				+chore(package): update flow-bin to version 0.37.0 ([#255](https://github.com/babel/babylon/pull/255)) (greenkeeper[bot])
			
 
				+
			
 
				+## 6.14.1 (2016-11-17)
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+
			
 
				+Allow `"plugins": ["*"]` ([#229](https://github.com/babel/babylon/pull/229)) (Daniel Tschinder)
			
 
				+
			
 
				+```js
			
 
				+{
			
 
				+  "plugins": ["*"]
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+Will include all parser plugins instead of specifying each one individually. Useful for tools like babel-eslint, jscodeshift, and ast-explorer.
			
 
				+
			
 
				+## 6.14.0 (2016-11-16)
			
 
				+
			
 
				+### :eyeglasses: Spec Compliance
			
 
				+
			
 
				+Throw error for reserved words `enum` and `await` ([#195](https://github.com/babel/babylon/pull/195)) (Kai Cataldo)
			
 
				+
			
 
				+[11.6.2.2 Future Reserved Words](http://www.ecma-international.org/ecma-262/6.0/#sec-future-reserved-words)
			
 
				+
			
 
				+Babylon will throw for more reserved words such as `enum` or `await` (in strict mode).
			
 
				+
			
 
				+```
			
 
				+class enum {} // throws
			
 
				+class await {} // throws in strict mode (module)
			
 
				+```
			
 
				+
			
 
				+Optional names for function types and object type indexers ([#197](https://github.com/babel/babylon/pull/197)) (Gabe Levi)
			
 
				+
			
 
				+So where you used to have to write
			
 
				+
			
 
				+```js
			
 
				+type A = (x: string, y: boolean) => number;
			
 
				+type B = (z: string) => number;
			
 
				+type C = { [key: string]: number };
			
 
				+```
			
 
				+
			
 
				+you can now write (with flow 0.34.0)
			
 
				+
			
 
				+```js
			
 
				+type A = (string, boolean) => number;
			
 
				+type B = string => number;
			
 
				+type C = { [string]: number };
			
 
				+```
			
 
				+
			
 
				+Parse flow nested array type annotations like `number[][]` ([#219](https://github.com/babel/babylon/pull/219)) (Bernhard Häussner)
			
 
				+
			
 
				+Supports these form now of specifying array types:
			
 
				+
			
 
				+```js
			
 
				+var a: number[][][][];
			
 
				+var b: string[][];
			
 
				+```
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+
			
 
				+Correctly eat semicolon at the end of `DelcareModuleExports` ([#223](https://github.com/babel/babylon/pull/223))  (Daniel Tschinder)
			
 
				+
			
 
				+```
			
 
				+declare module "foo" { declare module.exports: number }
			
 
				+declare module "foo" { declare module.exports: number; }  // also allowed now
			
 
				+```
			
 
				+
			
 
				+### :house: Internal
			
 
				+
			
 
				+ * Count Babel tests towards Babylon code coverage ([#182](https://github.com/babel/babylon/pull/182)) (Moti Zilberman)
			
 
				+ * Fix strange line endings ([#214](https://github.com/babel/babylon/pull/214)) (Thomas Grainger)
			
 
				+ * Add node 7 (Daniel Tschinder)
			
 
				+ * chore(package): update flow-bin to version 0.34.0 ([#204](https://github.com/babel/babylon/pull/204)) (Greenkeeper)
			
 
				+
			
 
				+## v6.13.1 (2016-10-26)
			
 
				+
			
 
				+### :nail_care: Polish
			
 
				+
			
 
				+- Use rollup for bundling to speed up startup time ([#190](https://github.com/babel/babylon/pull/190)) ([@drewml](https://github.com/DrewML))
			
 
				+
			
 
				+```js
			
 
				+const babylon = require('babylon');
			
 
				+const ast = babylon.parse('var foo = "lol";');
			
 
				+```
			
 
				+
			
 
				+With that test case, there was a ~95ms savings by removing the need for node to build/traverse the dependency graph.
			
 
				+
			
 
				+**Without bundling**
			
 
				+![image](https://cloud.githubusercontent.com/assets/5233399/19420264/3133497e-93ad-11e6-9a6a-2da59c4f5c13.png)
			
 
				+
			
 
				+**With bundling**
			
 
				+![image](https://cloud.githubusercontent.com/assets/5233399/19420267/388f556e-93ad-11e6-813e-7c5c396be322.png)
			
 
				+
			
 
				+- add clean command [skip ci] ([#201](https://github.com/babel/babylon/pull/201)) (Henry Zhu)
			
 
				+- add ForAwaitStatement (async generator already added) [skip ci] ([#196](https://github.com/babel/babylon/pull/196)) (Henry Zhu)
			
 
				+
			
 
				+## v6.13.0 (2016-10-21)
			
 
				+
			
 
				+### :eyeglasses: Spec Compliance
			
 
				+
			
 
				+Property variance type annotations for Flow plugin ([#161](https://github.com/babel/babylon/pull/161)) (Sam Goldman)
			
 
				+
			
 
				+> See https://flowtype.org/docs/variance.html for more information
			
 
				+
			
 
				+```js
			
 
				+type T = { +p: T };
			
 
				+interface T { -p: T };
			
 
				+declare class T { +[k:K]: V };
			
 
				+class T { -[k:K]: V };
			
 
				+class C2 { +p: T = e };
			
 
				+```
			
 
				+
			
 
				+Raise error on duplicate definition of __proto__ ([#183](https://github.com/babel/babylon/pull/183)) (Moti Zilberman)
			
 
				+
			
 
				+```js
			
 
				+({ __proto__: 1, __proto__: 2 }) // Throws an error now
			
 
				+```
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+
			
 
				+Flow: Allow class properties to be named `static` ([#184](https://github.com/babel/babylon/pull/184)) (Moti Zilberman)
			
 
				+
			
 
				+```js
			
 
				+declare class A {
			
 
				+  static: T;
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+Allow "async" as identifier for object literal property shorthand ([#187](https://github.com/babel/babylon/pull/187)) (Andrew Levine)
			
 
				+
			
 
				+```js
			
 
				+var foo = { async, bar };
			
 
				+```
			
 
				+
			
 
				+### :nail_care: Polish
			
 
				+
			
 
				+Fix flowtype and add inType to state ([#189](https://github.com/babel/babylon/pull/189)) (Daniel Tschinder)
			
 
				+
			
 
				+> This improves the performance slightly (because of hidden classes)
			
 
				+
			
 
				+### :house: Internal
			
 
				+
			
 
				+Fix .gitattributes line ending setting ([#191](https://github.com/babel/babylon/pull/191)) (Moti Zilberman)
			
 
				+
			
 
				+Increase test coverage ([#175](https://github.com/babel/babylon/pull/175) (Moti Zilberman)
			
 
				+
			
 
				+Readd missin .eslinignore for IDEs (Daniel Tschinder)
			
 
				+
			
 
				+Error on missing expected.json fixture in CI ([#188](https://github.com/babel/babylon/pull/188)) (Moti Zilberman)
			
 
				+
			
 
				+Add .gitattributes and .editorconfig for LF line endings ([#179](https://github.com/babel/babylon/pull/179)) (Moti Zilberman)
			
 
				+
			
 
				+Fixes two tests that are failing after the merge of #172 ([#177](https://github.com/babel/babylon/pull/177)) (Moti Zilberman)
			
 
				+
			
 
				+## v6.12.0 (2016-10-14)
			
 
				+
			
 
				+### :eyeglasses: Spec Compliance
			
 
				+
			
 
				+Implement import() syntax ([#163](https://github.com/babel/babylon/pull/163)) (Jordan Gensler)
			
 
				+
			
 
				+#### Dynamic Import
			
 
				+
			
 
				+- Proposal Repo: https://github.com/domenic/proposal-dynamic-import
			
 
				+- Championed by [@domenic](https://github.com/domenic)
			
 
				+- stage-2
			
 
				+- [sept-28 tc39 notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2016-09/sept-28.md#113a-import)
			
 
				+
			
 
				+> This repository contains a proposal for adding a "function-like" import() module loading syntactic form to JavaScript
			
 
				+
			
 
				+```js
			
 
				+import(`./section-modules/${link.dataset.entryModule}.js`)
			
 
				+.then(module => {
			
 
				+  module.loadPageInto(main);
			
 
				+})
			
 
				+```
			
 
				+
			
 
				+Add EmptyTypeAnnotation ([#171](https://github.com/babel/babylon/pull/171)) (Sam Goldman)
			
 
				+
			
 
				+#### EmptyTypeAnnotation
			
 
				+
			
 
				+Just wasn't covered before.
			
 
				+
			
 
				+```js
			
 
				+type T = empty;
			
 
				+```
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+
			
 
				+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
			
 
				+
			
 
				+```js
			
 
				+// was failing due to sparse array
			
 
				+export const { foo: [ ,, qux7 ] } = bar;
			
 
				+```
			
 
				+
			
 
				+Allow keyword in Flow object declaration property names with type parameters ([#146](https://github.com/babel/babylon/pull/146)) (Dan Harper)
			
 
				+
			
 
				+```js
			
 
				+declare class X {
			
 
				+  foobar<T>(): void;
			
 
				+  static foobar<T>(): void;
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+Allow keyword in object/class property names with Flow type parameters ([#145](https://github.com/babel/babylon/pull/145)) (Dan Harper)
			
 
				+
			
 
				+```js
			
 
				+class Foo {
			
 
				+  delete<T>(item: T): T {
			
 
				+    return item;
			
 
				+  }
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+Allow typeAnnotations for yield expressions ([#174](https://github.com/babel/babylon/pull/174))) (Daniel Tschinder)
			
 
				+
			
 
				+```js
			
 
				+function *foo() {
			
 
				+  const x = (yield 5: any);
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+### :nail_care: Polish
			
 
				+
			
 
				+Annotate more errors with expected token ([#172](https://github.com/babel/babylon/pull/172))) (Moti Zilberman)
			
 
				+
			
 
				+```js
			
 
				+// Unexpected token, expected ; (1:6)
			
 
				+{ set 1 }
			
 
				+```
			
 
				+
			
 
				+### :house: Internal
			
 
				+
			
 
				+Remove kcheck ([#173](https://github.com/babel/babylon/pull/173)))  (Daniel Tschinder)
			
 
				+
			
 
				+Also run flow, linting, babel tests on separate instances (add back node 0.10)
			
 
				+
			
 
				+## v6.11.6 (2016-10-12)
			
 
				+
			
 
				+### :bug: Bug Fix/Regression
			
 
				+
			
 
				+Fix crash when exporting with destructuring and sparse array ([#170](https://github.com/babel/babylon/pull/170)) (Jeroen Engels)
			
 
				+
			
 
				+```js
			
 
				+// was failing with `Cannot read property 'type' of null` because of null identifiers
			
 
				+export const { foo: [ ,, qux7 ] } = bar;
			
 
				+```
			
 
				+
			
 
				+## v6.11.5 (2016-10-12)
			
 
				+
			
 
				+### :eyeglasses: Spec Compliance
			
 
				+
			
 
				+Fix: Check for duplicate named exports in exported destructuring assignments ([#144](https://github.com/babel/babylon/pull/144)) (Kai Cataldo)
			
 
				+
			
 
				+```js
			
 
				+// `foo` has already been exported. Exported identifiers must be unique. (2:20)
			
 
				+export function foo() {};
			
 
				+export const { a: [{foo}] } = bar;
			
 
				+```
			
 
				+
			
 
				+Fix: Check for duplicate named exports in exported rest elements/properties ([#164](https://github.com/babel/babylon/pull/164)) (Kai Cataldo)
			
 
				+
			
 
				+```js
			
 
				+// `foo` has already been exported. Exported identifiers must be unique. (2:22)
			
 
				+export const foo = 1;
			
 
				+export const [bar, ...foo] = baz;
			
 
				+```
			
 
				+
			
 
				+### :bug: Bug Fix
			
 
				+
			
 
				+Fix: Allow identifier `async` for default param in arrow expression ([#165](https://github.com/babel/babylon/pull/165)) (Kai Cataldo)
			
 
				+
			
 
				+```js
			
 
				+// this is ok now
			
 
				+const test = ({async = true}) => {};
			
 
				+```
			
 
				+
			
 
				+### :nail_care: Polish
			
 
				+
			
 
				+Babylon will now print out the token it's expecting if there's a `SyntaxError` ([#150](https://github.com/babel/babylon/pull/150)) (Daniel Tschinder)
			
 
				+
			
 
				+```bash
			
 
				+# So in the case of a missing ending curly (`}`)
			
 
				+Module build failed: SyntaxError: Unexpected token, expected } (30:0)
			
 
				+  28 |   }
			
 
				+  29 |
			
 
				+> 30 |
			
 
				+     | ^
			
 
				+```
			
 
				+
			
 
				+## v6.11.4 (2016-10-03)
			
 
				+
			
 
				+Temporary rollback for erroring on trailing comma with spread (#154) (Henry Zhu)
			
 
				+
			
 
				+## v6.11.3 (2016-10-01)
			
 
				+
			
 
				+### :eyeglasses: Spec Compliance
			
 
				+
			
 
				+Add static errors for object rest (#149) ([@danez](https://github.com/danez))
			
 
				+
			
 
				+> https://github.com/sebmarkbage/ecmascript-rest-spread
			
 
				+
			
 
				+Object rest copies the *rest* of properties from the right hand side `obj` starting from the left to right.
			
 
				+
			
 
				+```js
			
 
				+let { x, y, ...z } =  { x: 1, y: 2, z: 3 };
			
 
				+// x = 1
			
 
				+// y = 2
			
 
				+// z = { z: 3 }
			
 
				+```
			
 
				+
			
 
				+#### New Syntax Errors:
			
 
				+
			
 
				+**SyntaxError**: The rest element has to be the last element when destructuring (1:10)
			
 
				+```bash
			
 
				+> 1 | let { ...x, y, z } = { x: 1, y: 2, z: 3};
			
 
				+    |           ^
			
 
				+# Previous behavior:
			
 
				+# x = { x: 1, y: 2, z: 3 }
			
 
				+# y = 2
			
 
				+# z = 3
			
 
				+```
			
 
				+
			
 
				+Before, this was just a more verbose way of shallow copying `obj` since it doesn't actually do what you think.
			
 
				+
			
 
				+**SyntaxError**: Cannot have multiple rest elements when destructuring (1:13)
			
 
				+
			
 
				+```bash
			
 
				+> 1 | let { x, ...y, ...z } = { x: 1, y: 2, z: 3};
			
 
				+    |              ^
			
 
				+# Previous behavior:
			
 
				+# x = 1
			
 
				+# y = { y: 2, z: 3 }
			
 
				+# z = { y: 2, z: 3 }
			
 
				+```
			
 
				+
			
 
				+Before y and z would just be the same value anyway so there is no reason to need to have both.
			
 
				+
			
 
				+**SyntaxError**: A trailing comma is not permitted after the rest element (1:16)
			
 
				+
			
 
				+```js
			
 
				+let { x, y, ...z, } = obj;
			
 
				+```
			
 
				+
			
 
				+The rationale for this is that the use case for trailing comma is that you can add something at the end without affecting the line above. Since a RestProperty always has to be the last property it doesn't make sense.
			
 
				+
			
 
				+---
			
 
				+
			
 
				+get / set are valid property names in default assignment (#142) ([@jezell](https://github.com/jezell))
			
 
				+
			
 
				+```js
			
 
				+// valid
			
 
				+function something({ set = null, get = null }) {}
			
 
				+```
			
 
				+
			
 
				+## v6.11.2 (2016-09-23)
			
 
				+
			
 
				+### Bug Fix
			
 
				+
			
 
				+- [#139](https://github.com/babel/babylon/issues/139) Don't do the duplicate check if not an identifier (#140) @hzoo
			
 
				+
			
 
				+```js
			
 
				+// regression with duplicate export check
			
 
				+SyntaxError: ./typography.js: `undefined` has already been exported. Exported identifiers must be unique. (22:13)
			
 
				+  20 |
			
 
				+  21 | export const { rhythm } = typography;
			
 
				+> 22 | export const { TypographyStyle } = typography
			
 
				+```
			
 
				+
			
 
				+Bail out for now, and make a change to account for destructuring in the next release.
			
 
				+
			
 
				+## 6.11.1 (2016-09-22)
			
 
				+
			
 
				+### Bug Fix
			
 
				+- [#137](https://github.com/babel/babylon/pull/137) - Fix a regression with duplicate exports - it was erroring on all keys in `Object.prototype`. @danez
			
 
				+
			
 
				+```javascript
			
 
				+export toString from './toString';
			
 
				+```
			
 
				+
			
 
				+```bash
			
 
				+`toString` has already been exported. Exported identifiers must be unique. (1:7)
			
 
				+> 1 | export toString from './toString';
			
 
				+    |        ^
			
 
				+  2 |
			
 
				+```
			
 
				+
			
 
				+## 6.11.0 (2016-09-22)
			
 
				+
			
 
				+### Spec Compliance (will break CI)
			
 
				+
			
 
				+- Disallow duplicate named exports ([#107](https://github.com/babel/babylon/pull/107)) @kaicataldo
			
 
				+
			
 
				+```js
			
 
				+// Only one default export allowed per module. (2:9)
			
 
				+export default function() {};
			
 
				+export { foo as default };
			
 
				+
			
 
				+// Only one default export allowed per module. (2:0)
			
 
				+export default {};
			
 
				+export default function() {};
			
 
				+
			
 
				+// `Foo` has already been exported. Exported identifiers must be unique. (2:0)
			
 
				+export { Foo };
			
 
				+export class Foo {};
			
 
				+```
			
 
				+
			
 
				+### New Feature (Syntax)
			
 
				+
			
 
				+- Add support for computed class property names ([#121](https://github.com/babel/babylon/pull/121)) @motiz88
			
 
				+
			
 
				+```js
			
 
				+// AST
			
 
				+interface ClassProperty <: Node {
			
 
				+  type: "ClassProperty";
			
 
				+  key: Identifier;
			
 
				+  value: Expression;
			
 
				+  computed: boolean; // added
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+```js
			
 
				+// with "plugins": ["classProperties"]
			
 
				+class Foo {
			
 
				+  [x]
			
 
				+  ['y']
			
 
				+}
			
 
				+
			
 
				+class Bar {
			
 
				+  [p]
			
 
				+  [m] () {}
			
 
				+}
			
 
				+ ```
			
 
				+
			
 
				+### Bug Fix
			
 
				+
			
 
				+- Fix `static` property falling through in the declare class Flow AST ([#135](https://github.com/babel/babylon/pull/135)) @danharper
			
 
				+
			
 
				+```js
			
 
				+declare class X {
			
 
				+    a: number;
			
 
				+    static b: number; // static
			
 
				+    c: number; // this was being marked as static in the AST as well
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+### Polish
			
 
				+
			
 
				+- Rephrase "assigning/binding to rvalue" errors to include context ([#119](https://github.com/babel/babylon/pull/119)) @motiz88
			
 
				+
			
 
				+```js
			
 
				+// Used to error with:
			
 
				+// SyntaxError: Assigning to rvalue (1:0)
			
 
				+
			
 
				+// Now:
			
 
				+// Invalid left-hand side in assignment expression (1:0)
			
 
				+3 = 4
			
 
				+
			
 
				+// Invalid left-hand side in for-in statement (1:5)
			
 
				+for (+i in {});
			
 
				+```
			
 
				+
			
 
				+### Internal
			
 
				+
			
 
				+- Fix call to `this.parseMaybeAssign` with correct arguments ([#133](https://github.com/babel/babylon/pull/133)) @danez
			
 
				+- Add semver note to changelog ([#131](https://github.com/babel/babylon/pull/131)) @hzoo
			
 
				+
			
 
				+## 6.10.0 (2016-09-19)
			
 
				+
			
 
				+> We plan to include some spec compliance bugs in patch versions. An example was the multiple default exports issue.
			
 
				+
			
 
				+### Spec Compliance
			
 
				+
			
 
				+* Implement ES2016 check for simple parameter list in strict mode ([#106](https://github.com/babel/babylon/pull/106)) (Timothy Gu)
			
 
				+
			
 
				+> It is a Syntax Error if ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false. https://tc39.github.io/ecma262/2016/#sec-function-definitions-static-semantics-early-errors
			
 
				+
			
 
				+More Context: [tc39-notes](https://github.com/rwaldron/tc39-notes/blob/master/es7/2015-07/july-29.md#611-the-scope-of-use-strict-with-respect-to-destructuring-in-parameter-lists)
			
 
				+
			
 
				+For example:
			
 
				+
			
 
				+```js
			
 
				+// this errors because it uses destructuring and default parameters
			
 
				+// in a function with a "use strict" directive
			
 
				+function a([ option1, option2 ] = []) {
			
 
				+  "use strict";
			
 
				+}
			
 
				+ ```
			
 
				+
			
 
				+The solution would be to use a top level "use strict" or to remove the destructuring or default parameters when using a function + "use strict" or to.
			
 
				+
			
 
				+### New Feature
			
 
				+
			
 
				+* Exact object type annotations for Flow plugin ([#104](https://github.com/babel/babylon/pull/104)) (Basil Hosmer)
			
 
				+
			
 
				+Added to flow in https://github.com/facebook/flow/commit/c710c40aa2a115435098d6c0dfeaadb023cd39b8
			
 
				+
			
 
				+Looks like:
			
 
				+
			
 
				+```js
			
 
				+var a : {| x: number, y: string |} = { x: 0, y: 'foo' };
			
 
				+```
			
 
				+
			
 
				+### Bug Fixes
			
 
				+
			
 
				+* Include `typeParameter` location in `ArrowFunctionExpression` ([#126](https://github.com/babel/babylon/pull/126)) (Daniel Tschinder)
			
 
				+* Error on invalid flow type annotation with default assignment ([#122](https://github.com/babel/babylon/pull/122)) (Dan Harper)
			
 
				+* Fix Flow return types on arrow functions ([#124](https://github.com/babel/babylon/pull/124)) (Dan Harper)
			
 
				+
			
 
				+### Misc
			
 
				+
			
 
				+* Add tests for export extensions ([#127](https://github.com/babel/babylon/pull/127)) (Daniel Tschinder)
			
 
				+* Fix Contributing guidelines [skip ci] (Daniel Tschinder)
			
 
				+
			
 
				+## 6.9.2 (2016-09-09)
			
 
				+
			
 
				+The only change is to remove the `babel-runtime` dependency by compiling with Babel's ES2015 loose mode. So using babylon standalone should be smaller.
			
 
				+
			
 
				+## 6.9.1 (2016-08-23)
			
 
				+
			
 
				+This release contains mainly small bugfixes but also updates babylons default mode to es2017. The features for `exponentiationOperator`, `asyncFunctions` and `trailingFunctionCommas` which previously needed to be activated via plugin are now enabled by default and the plugins are now no-ops.
			
 
				+
			
 
				+### Bug Fixes
			
 
				+
			
 
				+- Fix issues with default object params in async functions ([#96](https://github.com/babel/babylon/pull/96)) @danez
			
 
				+- Fix issues with flow-types and async function ([#95](https://github.com/babel/babylon/pull/95)) @danez
			
 
				+- Fix arrow functions with destructuring, types & default value ([#94](https://github.com/babel/babylon/pull/94)) @danharper
			
 
				+- Fix declare class with qualified type identifier ([#97](https://github.com/babel/babylon/pull/97)) @danez
			
 
				+- Remove exponentiationOperator, asyncFunctions, trailingFunctionCommas plugins and enable them by default ([#98](https://github.com/babel/babylon/pull/98)) @danez
			
 
				+
			
 
				+## 6.9.0 (2016-08-16)
			
 
				+
			
 
				+### New syntax support
			
 
				+
			
 
				+- Add JSX spread children ([#42](https://github.com/babel/babylon/pull/42)) @calebmer
			
 
				+
			
 
				+(Be aware that React is not going to support this syntax)
			
 
				+
			
 
				+```js
			
 
				+<div>
			
 
				+  {...todos.map(todo => <Todo key={todo.id} todo={todo}/>)}
			
 
				+</div>
			
 
				+```
			
 
				+
			
 
				+- Add support for declare module.exports ([#72](https://github.com/babel/babylon/pull/72)) @danez
			
 
				+
			
 
				+```js
			
 
				+declare module "foo" {
			
 
				+  declare module.exports: {}
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+### New Features
			
 
				+
			
 
				+- If supplied, attach filename property to comment node loc. ([#80](https://github.com/babel/babylon/pull/80)) @divmain
			
 
				+- Add identifier name to node loc field ([#90](https://github.com/babel/babylon/pull/90)) @kittens
			
 
				+
			
 
				+### Bug Fixes
			
 
				+
			
 
				+- Fix exponential operator to behave according to spec ([#75](https://github.com/babel/babylon/pull/75)) @danez
			
 
				+- Fix lookahead to not add comments to arrays which are not cloned ([#76](https://github.com/babel/babylon/pull/76)) @danez
			
 
				+- Fix accidental fall-through in Flow type parsing. ([#82](https://github.com/babel/babylon/pull/82)) @xiemaisi
			
 
				+- Only allow declares inside declare module ([#73](https://github.com/babel/babylon/pull/73)) @danez
			
 
				+- Small fix for parsing type parameter declarations ([#83](https://github.com/babel/babylon/pull/83)) @gabelevi
			
 
				+- Fix arrow param locations with flow types ([#57](https://github.com/babel/babylon/pull/57)) @danez
			
 
				+- Fixes SyntaxError position with flow optional type ([#65](https://github.com/babel/babylon/pull/65)) @danez
			
 
				+
			
 
				+### Internal
			
 
				+
			
 
				+- Add codecoverage to tests @danez
			
 
				+- Fix tests to not save expected output if we expect the test to fail @danez
			
 
				+- Make a shallow clone of babel for testing @danez
			
 
				+- chore(package): update cross-env to version 2.0.0 ([#77](https://github.com/babel/babylon/pull/77)) @greenkeeperio-bot
			
 
				+- chore(package): update ava to version 0.16.0 ([#86](https://github.com/babel/babylon/pull/86)) @greenkeeperio-bot
			
 
				+- chore(package): update babel-plugin-istanbul to version 2.0.0 ([#89](https://github.com/babel/babylon/pull/89)) @greenkeeperio-bot
			
 
				+- chore(package): update nyc to version 8.0.0 ([#88](https://github.com/babel/babylon/pull/88)) @greenkeeperio-bot
			
 
				+
			
 
				+## 6.8.4 (2016-07-06)
			
 
				+
			
 
				+### Bug Fixes
			
 
				+
			
 
				+- Fix the location of params, when flow and default value used ([#68](https://github.com/babel/babylon/pull/68)) @danez
			
 
				+
			
 
				+## 6.8.3 (2016-07-02)
			
 
				+
			
 
				+### Bug Fixes
			
 
				+
			
 
				+- Fix performance regression introduced in 6.8.2 with conditionals ([#63](https://github.com/babel/babylon/pull/63)) @danez
			
 
				+
			
 
				+## 6.8.2 (2016-06-24)
			
 
				+
			
 
				+### Bug Fixes
			
 
				+
			
 
				+- Fix parse error with yielding jsx elements in generators `function* it() { yield <a></a>; }` ([#31](https://github.com/babel/babylon/pull/31)) @eldereal
			
 
				+- When cloning nodes do not clone its comments ([#24](https://github.com/babel/babylon/pull/24)) @danez
			
 
				+- Fix parse errors when using arrow functions with an spread element and return type `(...props): void => {}` ([#10](https://github.com/babel/babylon/pull/10)) @danez
			
 
				+- Fix leading comments added from previous node ([#23](https://github.com/babel/babylon/pull/23)) @danez
			
 
				+- Fix parse errors with flow's optional arguments `(arg?) => {}` ([#19](https://github.com/babel/babylon/pull/19)) @danez
			
 
				+- Support negative numeric type literals @kittens
			
 
				+- Remove line terminator restriction after await keyword @kittens
			
 
				+- Remove grouped type arrow restriction as it seems flow no longer has it @kittens
			
 
				+- Fix parse error with generic methods that have the name `get` or `set` `class foo { get() {} }` ([#55](https://github.com/babel/babylon/pull/55)) @vkurchatkin
			
 
				+- Fix parse error with arrow functions that have flow type parameter declarations `<T>(x: T): T => x;` ([#54](https://github.com/babel/babylon/pull/54)) @gabelevi
			
 
				+
			
 
				+### Documentation
			
 
				+
			
 
				+- Document AST differences from ESTree ([#41](https://github.com/babel/babylon/pull/41)) @nene
			
 
				+- Move ast spec from babel/babel ([#46](https://github.com/babel/babylon/pull/46)) @hzoo
			
 
				+
			
 
				+### Internal
			
 
				+
			
 
				+- Enable skipped tests ([#16](https://github.com/babel/babylon/pull/16)) @danez
			
 
				+- Add script to test latest version of babylon with babel ([#21](https://github.com/babel/babylon/pull/21)) @danez
			
 
				+- Upgrade test runner ava @kittens
			
 
				+- Add missing generate-identifier-regex script @kittens
			
 
				+- Rename parser context types @kittens
			
 
				+- Add node v6 to travis testing @hzoo
			
 
				+- Update to Unicode v9 ([#45](https://github.com/babel/babylon/pull/45)) @mathiasbynens
			
 
				+
			
 
				+## 6.8.1 (2016-06-06)
			
 
				+
			
 
				+### New Feature
			
 
				+
			
 
				+- Parse type parameter declarations with defaults like `type Foo<T = string> = T`
			
 
				+
			
 
				+### Bug Fixes
			
 
				+- Type parameter declarations need 1 or more type parameters.
			
 
				+- The existential type `*` is not a valid type parameter.
			
 
				+- The existential type `*` is a primary type
			
 
				+
			
 
				+### Spec Compliance
			
 
				+- The param list for type parameter declarations now consists of `TypeParameter` nodes
			
 
				+- New `TypeParameter` AST Node (replaces using the `Identifier` node before)
			
 
				+
			
 
				+```
			
 
				+interface TypeParameter <: Node {
			
 
				+  bound: TypeAnnotation;
			
 
				+  default: TypeAnnotation;
			
 
				+  name: string;
			
 
				+  variance: "plus" | "minus";
			
 
				+}
			
 
				+```
			
 
				+
			
 
				+## 6.8.0 (2016-05-02)
			
 
				+
			
 
				+#### New Feature
			
 
				+
			
 
				+##### Parse Method Parameter Decorators ([#12](https://github.com/babel/babylon/pull/12))
			
 
				+
			
 
				+> [Method Parameter Decorators](https://goo.gl/8MmCMG) is now a TC39 [stage 0 proposal](https://github.com/tc39/ecma262/blob/master/stage0.md).
			
 
				+
			
 
				+Examples:
			
 
				+
			
 
				+```js
			
 
				+class Foo {
			
 
				+  constructor(@foo() x, @bar({ a: 123 }) @baz() y) {}
			
 
				+}
			
 
				+
			
 
				+export default function func(@foo() x, @bar({ a: 123 }) @baz() y) {}
			
 
				+
			
 
				+var obj = {
			
 
				+  method(@foo() x, @bar({ a: 123 }) @baz() y) {}
			
 
				+};
			
 
				+```
			
 
				+
			
 
				+##### Parse for-await statements (w/ `asyncGenerators` plugin) ([#17](https://github.com/babel/babylon/pull/17))
			
 
				+
			
 
				+There is also a new node type, `ForAwaitStatement`.
			
 
				+
			
 
				+> [Async generators and for-await](https://github.com/tc39/proposal-async-iteration) are now a [stage 2 proposal](https://github.com/tc39/ecma262#current-proposals).
			
 
				+
			
 
				+Example:
			
 
				+
			
 
				+```js
			
 
				+async function f() {
			
 
				+  for await (let x of y);
			
 
				+}
			
 
				+```
			
--- a/ui/node_modules/@babel/parser/LICENSE
+++ b/ui/node_modules/@babel/parser/LICENSE
@@ -0,0 +1,19 @@
 
				+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
			
 
				+
			
 
				+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/ui/node_modules/@babel/parser/README.md
+++ b/ui/node_modules/@babel/parser/README.md
@@ -0,0 +1,19 @@
 
				+# @babel/parser
			
 
				+
			
 
				+> A JavaScript parser
			
 
				+
			
 
				+See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package.
			
 
				+
			
 
				+## Install
			
 
				+
			
 
				+Using npm:
			
 
				+
			
 
				+```sh
			
 
				+npm install --save-dev @babel/parser
			
 
				+```
			
 
				+
			
 
				+or using yarn:
			
 
				+
			
 
				+```sh
			
 
				+yarn add @babel/parser --dev
			
 
				+```
			
--- a/ui/node_modules/@babel/parser/bin/babel-parser.js
+++ b/ui/node_modules/@babel/parser/bin/babel-parser.js
@@ -0,0 +1,15 @@
 
				+#!/usr/bin/env node
			
 
				+/* eslint-disable no-var, unicorn/prefer-node-protocol */
			
 
				+
			
 
				+var parser = require("..");
			
 
				+var fs = require("fs");
			
 
				+
			
 
				+var filename = process.argv[2];
			
 
				+if (!filename) {
			
 
				+  console.error("no filename specified");
			
 
				+} else {
			
 
				+  var file = fs.readFileSync(filename, "utf8");
			
 
				+  var ast = parser.parse(file);
			
 
				+
			
 
				+  console.log(JSON.stringify(ast, null, "  "));
			
 
				+}
			
--- a/ui/node_modules/@babel/parser/lib/index.js
+++ b/ui/node_modules/@babel/parser/lib/index.js
--- a/ui/node_modules/@babel/parser/lib/index.js.map
+++ b/ui/node_modules/@babel/parser/lib/index.js.map
--- a/ui/node_modules/@babel/parser/package.json
+++ b/ui/node_modules/@babel/parser/package.json
@@ -0,0 +1,50 @@
 
				+{
			
 
				+  "name": "@babel/parser",
			
 
				+  "version": "7.29.2",
			
 
				+  "description": "A JavaScript parser",
			
 
				+  "author": "The Babel Team (https://babel.dev/team)",
			
 
				+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
			
 
				+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
			
 
				+  "license": "MIT",
			
 
				+  "publishConfig": {
			
 
				+    "access": "public"
			
 
				+  },
			
 
				+  "keywords": [
			
 
				+    "babel",
			
 
				+    "javascript",
			
 
				+    "parser",
			
 
				+    "tc39",
			
 
				+    "ecmascript",
			
 
				+    "@babel/parser"
			
 
				+  ],
			
 
				+  "repository": {
			
 
				+    "type": "git",
			
 
				+    "url": "https://github.com/babel/babel.git",
			
 
				+    "directory": "packages/babel-parser"
			
 
				+  },
			
 
				+  "main": "./lib/index.js",
			
 
				+  "types": "./typings/babel-parser.d.ts",
			
 
				+  "files": [
			
 
				+    "bin",
			
 
				+    "lib",
			
 
				+    "typings/babel-parser.d.ts",
			
 
				+    "index.cjs"
			
 
				+  ],
			
 
				+  "engines": {
			
 
				+    "node": ">=6.0.0"
			
 
				+  },
			
 
				+  "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
			
 
				+  "dependencies": {
			
 
				+    "@babel/types": "^7.29.0"
			
 
				+  },
			
 
				+  "devDependencies": {
			
 
				+    "@babel/code-frame": "^7.29.0",
			
 
				+    "@babel/helper-check-duplicate-nodes": "^7.28.6",
			
 
				+    "@babel/helper-fixtures": "^7.28.6",
			
 
				+    "@babel/helper-string-parser": "^7.27.1",
			
 
				+    "@babel/helper-validator-identifier": "^7.28.5",
			
 
				+    "charcodes": "^0.2.0"
			
 
				+  },
			
 
				+  "bin": "./bin/babel-parser.js",
			
 
				+  "type": "commonjs"
			
 
				+}
			
--- a/ui/node_modules/@babel/parser/typings/babel-parser.d.ts
+++ b/ui/node_modules/@babel/parser/typings/babel-parser.d.ts
@@ -0,0 +1,262 @@
 
				+// This file is auto-generated! Do not modify it directly.
			
 
				+// Run `yarn gulp bundle-dts` to re-generate it.
			
 
				+/* eslint-disable @typescript-eslint/consistent-type-imports, @typescript-eslint/no-redundant-type-constituents */
			
 
				+import { File, Expression } from '@babel/types';
			
 
				+
			
 
				+declare class Position {
			
 
				+    line: number;
			
 
				+    column: number;
			
 
				+    index: number;
			
 
				+    constructor(line: number, col: number, index: number);
			
 
				+}
			
 
				+
			
 
				+type SyntaxPlugin = "flow" | "typescript" | "jsx" | "pipelineOperator" | "placeholders";
			
 
				+type ParseErrorCode = "BABEL_PARSER_SYNTAX_ERROR" | "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
			
 
				+interface ParseErrorSpecification<ErrorDetails> {
			
 
				+    code: ParseErrorCode;
			
 
				+    reasonCode: string;
			
 
				+    syntaxPlugin?: SyntaxPlugin;
			
 
				+    missingPlugin?: string | string[];
			
 
				+    loc: Position;
			
 
				+    details: ErrorDetails;
			
 
				+    pos: number;
			
 
				+}
			
 
				+type ParseError$1<ErrorDetails> = SyntaxError & ParseErrorSpecification<ErrorDetails>;
			
 
				+
			
 
				+type BABEL_8_BREAKING = false;
			
 
				+type IF_BABEL_7<V> = false extends BABEL_8_BREAKING ? V : never;
			
 
				+
			
 
				+type Plugin$1 =
			
 
				+  | "asyncDoExpressions"
			
 
				+  | IF_BABEL_7<"asyncGenerators">
			
 
				+  | IF_BABEL_7<"bigInt">
			
 
				+  | IF_BABEL_7<"classPrivateMethods">
			
 
				+  | IF_BABEL_7<"classPrivateProperties">
			
 
				+  | IF_BABEL_7<"classProperties">
			
 
				+  | IF_BABEL_7<"classStaticBlock">
			
 
				+  | IF_BABEL_7<"decimal">
			
 
				+  | "decorators-legacy"
			
 
				+  | "deferredImportEvaluation"
			
 
				+  | "decoratorAutoAccessors"
			
 
				+  | "destructuringPrivate"
			
 
				+  | IF_BABEL_7<"deprecatedImportAssert">
			
 
				+  | "doExpressions"
			
 
				+  | IF_BABEL_7<"dynamicImport">
			
 
				+  | IF_BABEL_7<"explicitResourceManagement">
			
 
				+  | "exportDefaultFrom"
			
 
				+  | IF_BABEL_7<"exportNamespaceFrom">
			
 
				+  | "flow"
			
 
				+  | "flowComments"
			
 
				+  | "functionBind"
			
 
				+  | "functionSent"
			
 
				+  | "importMeta"
			
 
				+  | "jsx"
			
 
				+  | IF_BABEL_7<"jsonStrings">
			
 
				+  | IF_BABEL_7<"logicalAssignment">
			
 
				+  | IF_BABEL_7<"importAssertions">
			
 
				+  | IF_BABEL_7<"importReflection">
			
 
				+  | "moduleBlocks"
			
 
				+  | IF_BABEL_7<"moduleStringNames">
			
 
				+  | IF_BABEL_7<"nullishCoalescingOperator">
			
 
				+  | IF_BABEL_7<"numericSeparator">
			
 
				+  | IF_BABEL_7<"objectRestSpread">
			
 
				+  | IF_BABEL_7<"optionalCatchBinding">
			
 
				+  | IF_BABEL_7<"optionalChaining">
			
 
				+  | "partialApplication"
			
 
				+  | "placeholders"
			
 
				+  | IF_BABEL_7<"privateIn">
			
 
				+  | IF_BABEL_7<"regexpUnicodeSets">
			
 
				+  | "sourcePhaseImports"
			
 
				+  | "throwExpressions"
			
 
				+  | IF_BABEL_7<"topLevelAwait">
			
 
				+  | "v8intrinsic"
			
 
				+  | ParserPluginWithOptions[0];
			
 
				+
			
 
				+type ParserPluginWithOptions =
			
 
				+  | ["decorators", DecoratorsPluginOptions]
			
 
				+  | ["discardBinding", { syntaxType: "void" }]
			
 
				+  | ["estree", { classFeatures?: boolean }]
			
 
				+  | IF_BABEL_7<["importAttributes", { deprecatedAssertSyntax: boolean }]>
			
 
				+  | IF_BABEL_7<["moduleAttributes", { version: "may-2020" }]>
			
 
				+  | ["optionalChainingAssign", { version: "2023-07" }]
			
 
				+  | ["pipelineOperator", PipelineOperatorPluginOptions]
			
 
				+  | ["recordAndTuple", RecordAndTuplePluginOptions]
			
 
				+  | ["flow", FlowPluginOptions]
			
 
				+  | ["typescript", TypeScriptPluginOptions];
			
 
				+
			
 
				+type PluginConfig = Plugin$1 | ParserPluginWithOptions;
			
 
				+
			
 
				+interface DecoratorsPluginOptions {
			
 
				+  decoratorsBeforeExport?: boolean;
			
 
				+  allowCallParenthesized?: boolean;
			
 
				+}
			
 
				+
			
 
				+interface PipelineOperatorPluginOptions {
			
 
				+  proposal: BABEL_8_BREAKING extends false
			
 
				+    ? "minimal" | "fsharp" | "hack" | "smart"
			
 
				+    : "fsharp" | "hack";
			
 
				+  topicToken?: "%" | "#" | "@@" | "^^" | "^";
			
 
				+}
			
 
				+
			
 
				+interface RecordAndTuplePluginOptions {
			
 
				+  syntaxType: "bar" | "hash";
			
 
				+}
			
 
				+
			
 
				+type FlowPluginOptions = BABEL_8_BREAKING extends true
			
 
				+  ? {
			
 
				+      all?: boolean;
			
 
				+      enums?: boolean;
			
 
				+    }
			
 
				+  : {
			
 
				+      all?: boolean;
			
 
				+    };
			
 
				+
			
 
				+interface TypeScriptPluginOptions {
			
 
				+  dts?: boolean;
			
 
				+  disallowAmbiguousJSXLike?: boolean;
			
 
				+}
			
 
				+
			
 
				+type Plugin = PluginConfig;
			
 
				+
			
 
				+type SourceType = "script" | "commonjs" | "module" | "unambiguous";
			
 
				+interface Options {
			
 
				+    /**
			
 
				+     * By default, import and export declarations can only appear at a program's top level.
			
 
				+     * Setting this option to true allows them anywhere where a statement is allowed.
			
 
				+     */
			
 
				+    allowImportExportEverywhere?: boolean;
			
 
				+    /**
			
 
				+     * By default, await use is not allowed outside of an async function.
			
 
				+     * Set this to true to accept such code.
			
 
				+     */
			
 
				+    allowAwaitOutsideFunction?: boolean;
			
 
				+    /**
			
 
				+     * By default, a return statement at the top level raises an error.
			
 
				+     * Set this to true to accept such code.
			
 
				+     */
			
 
				+    allowReturnOutsideFunction?: boolean;
			
 
				+    /**
			
 
				+     * By default, new.target use is not allowed outside of a function or class.
			
 
				+     * Set this to true to accept such code.
			
 
				+     */
			
 
				+    allowNewTargetOutsideFunction?: boolean;
			
 
				+    /**
			
 
				+     * By default, super calls are not allowed outside of a method.
			
 
				+     * Set this to true to accept such code.
			
 
				+     */
			
 
				+    allowSuperOutsideMethod?: boolean;
			
 
				+    /**
			
 
				+     * By default, exported identifiers must refer to a declared variable.
			
 
				+     * Set this to true to allow export statements to reference undeclared variables.
			
 
				+     */
			
 
				+    allowUndeclaredExports?: boolean;
			
 
				+    /**
			
 
				+     * By default, yield use is not allowed outside of a generator function.
			
 
				+     * Set this to true to accept such code.
			
 
				+     */
			
 
				+    allowYieldOutsideFunction?: boolean;
			
 
				+    /**
			
 
				+     * By default, Babel parser JavaScript code according to Annex B syntax.
			
 
				+     * Set this to `false` to disable such behavior.
			
 
				+     */
			
 
				+    annexB?: boolean;
			
 
				+    /**
			
 
				+     * By default, Babel attaches comments to adjacent AST nodes.
			
 
				+     * When this option is set to false, comments are not attached.
			
 
				+     * It can provide up to 30% performance improvement when the input code has many comments.
			
 
				+     * @babel/eslint-parser will set it for you.
			
 
				+     * It is not recommended to use attachComment: false with Babel transform,
			
 
				+     * as doing so removes all the comments in output code, and renders annotations such as
			
 
				+     * /* istanbul ignore next *\/ nonfunctional.
			
 
				+     */
			
 
				+    attachComment?: boolean;
			
 
				+    /**
			
 
				+     * By default, Babel always throws an error when it finds some invalid code.
			
 
				+     * When this option is set to true, it will store the parsing error and
			
 
				+     * try to continue parsing the invalid input file.
			
 
				+     */
			
 
				+    errorRecovery?: boolean;
			
 
				+    /**
			
 
				+     * Indicate the mode the code should be parsed in.
			
 
				+     * Can be one of "script", "commonjs", "module", or "unambiguous". Defaults to "script".
			
 
				+     * "unambiguous" will make @babel/parser attempt to guess, based on the presence
			
 
				+     * of ES6 import or export statements.
			
 
				+     * Files with ES6 imports and exports are considered "module" and are otherwise "script".
			
 
				+     *
			
 
				+     * Use "commonjs" to parse code that is intended to be run in a CommonJS environment such as Node.js.
			
 
				+     */
			
 
				+    sourceType?: SourceType;
			
 
				+    /**
			
 
				+     * Correlate output AST nodes with their source filename.
			
 
				+     * Useful when generating code and source maps from the ASTs of multiple input files.
			
 
				+     */
			
 
				+    sourceFilename?: string;
			
 
				+    /**
			
 
				+     * By default, all source indexes start from 0.
			
 
				+     * You can provide a start index to alternatively start with.
			
 
				+     * Useful for integration with other source tools.
			
 
				+     */
			
 
				+    startIndex?: number;
			
 
				+    /**
			
 
				+     * By default, the first line of code parsed is treated as line 1.
			
 
				+     * You can provide a line number to alternatively start with.
			
 
				+     * Useful for integration with other source tools.
			
 
				+     */
			
 
				+    startLine?: number;
			
 
				+    /**
			
 
				+     * By default, the parsed code is treated as if it starts from line 1, column 0.
			
 
				+     * You can provide a column number to alternatively start with.
			
 
				+     * Useful for integration with other source tools.
			
 
				+     */
			
 
				+    startColumn?: number;
			
 
				+    /**
			
 
				+     * Array containing the plugins that you want to enable.
			
 
				+     */
			
 
				+    plugins?: Plugin[];
			
 
				+    /**
			
 
				+     * Should the parser work in strict mode.
			
 
				+     * Defaults to true if sourceType === 'module'. Otherwise, false.
			
 
				+     */
			
 
				+    strictMode?: boolean;
			
 
				+    /**
			
 
				+     * Adds a ranges property to each node: [node.start, node.end]
			
 
				+     */
			
 
				+    ranges?: boolean;
			
 
				+    /**
			
 
				+     * Adds all parsed tokens to a tokens property on the File node.
			
 
				+     */
			
 
				+    tokens?: boolean;
			
 
				+    /**
			
 
				+     * By default, the parser adds information about parentheses by setting
			
 
				+     * `extra.parenthesized` to `true` as needed.
			
 
				+     * When this option is `true` the parser creates `ParenthesizedExpression`
			
 
				+     * AST nodes instead of using the `extra` property.
			
 
				+     */
			
 
				+    createParenthesizedExpressions?: boolean;
			
 
				+    /**
			
 
				+     * The default is false in Babel 7 and true in Babel 8
			
 
				+     * Set this to true to parse it as an `ImportExpression` node.
			
 
				+     * Otherwise `import(foo)` is parsed as `CallExpression(Import, [Identifier(foo)])`.
			
 
				+     */
			
 
				+    createImportExpressions?: boolean;
			
 
				+}
			
 
				+
			
 
				+type ParserOptions = Partial<Options>;
			
 
				+type ParseError = ParseError$1<object>;
			
 
				+type ParseResult<Result extends File | Expression = File> = Result & {
			
 
				+    comments: File["comments"];
			
 
				+    errors: null | ParseError[];
			
 
				+    tokens?: File["tokens"];
			
 
				+};
			
 
				+/**
			
 
				+ * Parse the provided code as an entire ECMAScript program.
			
 
				+ */
			
 
				+declare function parse(input: string, options?: ParserOptions): ParseResult<File>;
			
 
				+declare function parseExpression(input: string, options?: ParserOptions): ParseResult<Expression>;
			
 
				+
			
 
				+declare const tokTypes: {
			
 
				+  // todo(flow->ts) real token type
			
 
				+  [name: string]: any;
			
 
				+};
			
 
				+
			
 
				+export { DecoratorsPluginOptions, FlowPluginOptions, ParseError, ParseResult, ParserOptions, PluginConfig as ParserPlugin, ParserPluginWithOptions, PipelineOperatorPluginOptions, RecordAndTuplePluginOptions, TypeScriptPluginOptions, parse, parseExpression, tokTypes };
			
--- a/ui/node_modules/@babel/types/LICENSE
+++ b/ui/node_modules/@babel/types/LICENSE
@@ -0,0 +1,22 @@
 
				+MIT License
			
 
				+
			
 
				+Copyright (c) 2014-present Sebastian McKenzie and other contributors
			
 
				+
			
 
				+Permission is hereby granted, free of charge, to any person obtaining
			
 
				+a copy of this software and associated documentation files (the
			
 
				+"Software"), to deal in the Software without restriction, including
			
 
				+without limitation the rights to use, copy, modify, merge, publish,
			
 
				+distribute, sublicense, and/or sell copies of the Software, and to
			
 
				+permit persons to whom the Software is furnished to do so, subject to
			
 
				+the following conditions:
			
 
				+
			
 
				+The above copyright notice and this permission notice shall be
			
 
				+included in all copies or substantial portions of the Software.
			
 
				+
			
 
				+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
			
 
				+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
			
 
				+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
			
 
				+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
			
 
				+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
			
 
				+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
			
 
				+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
			
--- a/ui/node_modules/@babel/types/README.md
+++ b/ui/node_modules/@babel/types/README.md
@@ -0,0 +1,19 @@
 
				+# @babel/types
			
 
				+
			
 
				+> Babel Types is a Lodash-esque utility library for AST nodes
			
 
				+
			
 
				+See our website [@babel/types](https://babeljs.io/docs/babel-types) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20types%22+is%3Aopen) associated with this package.
			
 
				+
			
 
				+## Install
			
 
				+
			
 
				+Using npm:
			
 
				+
			
 
				+```sh
			
 
				+npm install --save-dev @babel/types
			
 
				+```
			
 
				+
			
 
				+or using yarn:
			
 
				+
			
 
				+```sh
			
 
				+yarn add @babel/types --dev
			
 
				+```
			
--- a/ui/node_modules/@babel/types/lib/asserts/assertNode.js
+++ b/ui/node_modules/@babel/types/lib/asserts/assertNode.js
@@ -0,0 +1,16 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = assertNode;
			
 
				+var _isNode = require("../validators/isNode.js");
			
 
				+function assertNode(node) {
			
 
				+  if (!(0, _isNode.default)(node)) {
			
 
				+    var _node$type;
			
 
				+    const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
			
 
				+    throw new TypeError(`Not a valid node of type "${type}"`);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=assertNode.js.map
			
--- a/ui/node_modules/@babel/types/lib/asserts/assertNode.js.map
+++ b/ui/node_modules/@babel/types/lib/asserts/assertNode.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_isNode","require","assertNode","node","isNode","_node$type","type","JSON","stringify","TypeError"],"sources":["../../src/asserts/assertNode.ts"],"sourcesContent":["import isNode from \"../validators/isNode.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function assertNode(node?: any): asserts node is t.Node {\n  if (!isNode(node)) {\n    const type = node?.type ?? JSON.stringify(node);\n    throw new TypeError(`Not a valid node of type \"${type}\"`);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAGe,SAASC,UAAUA,CAACC,IAAU,EAA0B;EACrE,IAAI,CAAC,IAAAC,eAAM,EAACD,IAAI,CAAC,EAAE;IAAA,IAAAE,UAAA;IACjB,MAAMC,IAAI,IAAAD,UAAA,GAAGF,IAAI,oBAAJA,IAAI,CAAEG,IAAI,YAAAD,UAAA,GAAIE,IAAI,CAACC,SAAS,CAACL,IAAI,CAAC;IAC/C,MAAM,IAAIM,SAAS,CAAC,6BAA6BH,IAAI,GAAG,CAAC;EAC3D;AACF","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/asserts/generated/index.js
+++ b/ui/node_modules/@babel/types/lib/asserts/generated/index.js
@@ -0,0 +1,1251 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.assertAccessor = assertAccessor;
			
 
				+exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
			
 
				+exports.assertArgumentPlaceholder = assertArgumentPlaceholder;
			
 
				+exports.assertArrayExpression = assertArrayExpression;
			
 
				+exports.assertArrayPattern = assertArrayPattern;
			
 
				+exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
			
 
				+exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
			
 
				+exports.assertAssignmentExpression = assertAssignmentExpression;
			
 
				+exports.assertAssignmentPattern = assertAssignmentPattern;
			
 
				+exports.assertAwaitExpression = assertAwaitExpression;
			
 
				+exports.assertBigIntLiteral = assertBigIntLiteral;
			
 
				+exports.assertBinary = assertBinary;
			
 
				+exports.assertBinaryExpression = assertBinaryExpression;
			
 
				+exports.assertBindExpression = assertBindExpression;
			
 
				+exports.assertBlock = assertBlock;
			
 
				+exports.assertBlockParent = assertBlockParent;
			
 
				+exports.assertBlockStatement = assertBlockStatement;
			
 
				+exports.assertBooleanLiteral = assertBooleanLiteral;
			
 
				+exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
			
 
				+exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
			
 
				+exports.assertBreakStatement = assertBreakStatement;
			
 
				+exports.assertCallExpression = assertCallExpression;
			
 
				+exports.assertCatchClause = assertCatchClause;
			
 
				+exports.assertClass = assertClass;
			
 
				+exports.assertClassAccessorProperty = assertClassAccessorProperty;
			
 
				+exports.assertClassBody = assertClassBody;
			
 
				+exports.assertClassDeclaration = assertClassDeclaration;
			
 
				+exports.assertClassExpression = assertClassExpression;
			
 
				+exports.assertClassImplements = assertClassImplements;
			
 
				+exports.assertClassMethod = assertClassMethod;
			
 
				+exports.assertClassPrivateMethod = assertClassPrivateMethod;
			
 
				+exports.assertClassPrivateProperty = assertClassPrivateProperty;
			
 
				+exports.assertClassProperty = assertClassProperty;
			
 
				+exports.assertCompletionStatement = assertCompletionStatement;
			
 
				+exports.assertConditional = assertConditional;
			
 
				+exports.assertConditionalExpression = assertConditionalExpression;
			
 
				+exports.assertContinueStatement = assertContinueStatement;
			
 
				+exports.assertDebuggerStatement = assertDebuggerStatement;
			
 
				+exports.assertDecimalLiteral = assertDecimalLiteral;
			
 
				+exports.assertDeclaration = assertDeclaration;
			
 
				+exports.assertDeclareClass = assertDeclareClass;
			
 
				+exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
			
 
				+exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
			
 
				+exports.assertDeclareFunction = assertDeclareFunction;
			
 
				+exports.assertDeclareInterface = assertDeclareInterface;
			
 
				+exports.assertDeclareModule = assertDeclareModule;
			
 
				+exports.assertDeclareModuleExports = assertDeclareModuleExports;
			
 
				+exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
			
 
				+exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
			
 
				+exports.assertDeclareVariable = assertDeclareVariable;
			
 
				+exports.assertDeclaredPredicate = assertDeclaredPredicate;
			
 
				+exports.assertDecorator = assertDecorator;
			
 
				+exports.assertDirective = assertDirective;
			
 
				+exports.assertDirectiveLiteral = assertDirectiveLiteral;
			
 
				+exports.assertDoExpression = assertDoExpression;
			
 
				+exports.assertDoWhileStatement = assertDoWhileStatement;
			
 
				+exports.assertEmptyStatement = assertEmptyStatement;
			
 
				+exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
			
 
				+exports.assertEnumBody = assertEnumBody;
			
 
				+exports.assertEnumBooleanBody = assertEnumBooleanBody;
			
 
				+exports.assertEnumBooleanMember = assertEnumBooleanMember;
			
 
				+exports.assertEnumDeclaration = assertEnumDeclaration;
			
 
				+exports.assertEnumDefaultedMember = assertEnumDefaultedMember;
			
 
				+exports.assertEnumMember = assertEnumMember;
			
 
				+exports.assertEnumNumberBody = assertEnumNumberBody;
			
 
				+exports.assertEnumNumberMember = assertEnumNumberMember;
			
 
				+exports.assertEnumStringBody = assertEnumStringBody;
			
 
				+exports.assertEnumStringMember = assertEnumStringMember;
			
 
				+exports.assertEnumSymbolBody = assertEnumSymbolBody;
			
 
				+exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
			
 
				+exports.assertExportAllDeclaration = assertExportAllDeclaration;
			
 
				+exports.assertExportDeclaration = assertExportDeclaration;
			
 
				+exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
			
 
				+exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
			
 
				+exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
			
 
				+exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
			
 
				+exports.assertExportSpecifier = assertExportSpecifier;
			
 
				+exports.assertExpression = assertExpression;
			
 
				+exports.assertExpressionStatement = assertExpressionStatement;
			
 
				+exports.assertExpressionWrapper = assertExpressionWrapper;
			
 
				+exports.assertFile = assertFile;
			
 
				+exports.assertFlow = assertFlow;
			
 
				+exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
			
 
				+exports.assertFlowDeclaration = assertFlowDeclaration;
			
 
				+exports.assertFlowPredicate = assertFlowPredicate;
			
 
				+exports.assertFlowType = assertFlowType;
			
 
				+exports.assertFor = assertFor;
			
 
				+exports.assertForInStatement = assertForInStatement;
			
 
				+exports.assertForOfStatement = assertForOfStatement;
			
 
				+exports.assertForStatement = assertForStatement;
			
 
				+exports.assertForXStatement = assertForXStatement;
			
 
				+exports.assertFunction = assertFunction;
			
 
				+exports.assertFunctionDeclaration = assertFunctionDeclaration;
			
 
				+exports.assertFunctionExpression = assertFunctionExpression;
			
 
				+exports.assertFunctionParameter = assertFunctionParameter;
			
 
				+exports.assertFunctionParent = assertFunctionParent;
			
 
				+exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
			
 
				+exports.assertFunctionTypeParam = assertFunctionTypeParam;
			
 
				+exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
			
 
				+exports.assertIdentifier = assertIdentifier;
			
 
				+exports.assertIfStatement = assertIfStatement;
			
 
				+exports.assertImmutable = assertImmutable;
			
 
				+exports.assertImport = assertImport;
			
 
				+exports.assertImportAttribute = assertImportAttribute;
			
 
				+exports.assertImportDeclaration = assertImportDeclaration;
			
 
				+exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
			
 
				+exports.assertImportExpression = assertImportExpression;
			
 
				+exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
			
 
				+exports.assertImportOrExportDeclaration = assertImportOrExportDeclaration;
			
 
				+exports.assertImportSpecifier = assertImportSpecifier;
			
 
				+exports.assertIndexedAccessType = assertIndexedAccessType;
			
 
				+exports.assertInferredPredicate = assertInferredPredicate;
			
 
				+exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
			
 
				+exports.assertInterfaceExtends = assertInterfaceExtends;
			
 
				+exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
			
 
				+exports.assertInterpreterDirective = assertInterpreterDirective;
			
 
				+exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
			
 
				+exports.assertJSX = assertJSX;
			
 
				+exports.assertJSXAttribute = assertJSXAttribute;
			
 
				+exports.assertJSXClosingElement = assertJSXClosingElement;
			
 
				+exports.assertJSXClosingFragment = assertJSXClosingFragment;
			
 
				+exports.assertJSXElement = assertJSXElement;
			
 
				+exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
			
 
				+exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
			
 
				+exports.assertJSXFragment = assertJSXFragment;
			
 
				+exports.assertJSXIdentifier = assertJSXIdentifier;
			
 
				+exports.assertJSXMemberExpression = assertJSXMemberExpression;
			
 
				+exports.assertJSXNamespacedName = assertJSXNamespacedName;
			
 
				+exports.assertJSXOpeningElement = assertJSXOpeningElement;
			
 
				+exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
			
 
				+exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
			
 
				+exports.assertJSXSpreadChild = assertJSXSpreadChild;
			
 
				+exports.assertJSXText = assertJSXText;
			
 
				+exports.assertLVal = assertLVal;
			
 
				+exports.assertLabeledStatement = assertLabeledStatement;
			
 
				+exports.assertLiteral = assertLiteral;
			
 
				+exports.assertLogicalExpression = assertLogicalExpression;
			
 
				+exports.assertLoop = assertLoop;
			
 
				+exports.assertMemberExpression = assertMemberExpression;
			
 
				+exports.assertMetaProperty = assertMetaProperty;
			
 
				+exports.assertMethod = assertMethod;
			
 
				+exports.assertMiscellaneous = assertMiscellaneous;
			
 
				+exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
			
 
				+exports.assertModuleDeclaration = assertModuleDeclaration;
			
 
				+exports.assertModuleExpression = assertModuleExpression;
			
 
				+exports.assertModuleSpecifier = assertModuleSpecifier;
			
 
				+exports.assertNewExpression = assertNewExpression;
			
 
				+exports.assertNoop = assertNoop;
			
 
				+exports.assertNullLiteral = assertNullLiteral;
			
 
				+exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
			
 
				+exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
			
 
				+exports.assertNumberLiteral = assertNumberLiteral;
			
 
				+exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
			
 
				+exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
			
 
				+exports.assertNumericLiteral = assertNumericLiteral;
			
 
				+exports.assertObjectExpression = assertObjectExpression;
			
 
				+exports.assertObjectMember = assertObjectMember;
			
 
				+exports.assertObjectMethod = assertObjectMethod;
			
 
				+exports.assertObjectPattern = assertObjectPattern;
			
 
				+exports.assertObjectProperty = assertObjectProperty;
			
 
				+exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
			
 
				+exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
			
 
				+exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
			
 
				+exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
			
 
				+exports.assertObjectTypeProperty = assertObjectTypeProperty;
			
 
				+exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
			
 
				+exports.assertOpaqueType = assertOpaqueType;
			
 
				+exports.assertOptionalCallExpression = assertOptionalCallExpression;
			
 
				+exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType;
			
 
				+exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
			
 
				+exports.assertParenthesizedExpression = assertParenthesizedExpression;
			
 
				+exports.assertPattern = assertPattern;
			
 
				+exports.assertPatternLike = assertPatternLike;
			
 
				+exports.assertPipelineBareFunction = assertPipelineBareFunction;
			
 
				+exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
			
 
				+exports.assertPipelineTopicExpression = assertPipelineTopicExpression;
			
 
				+exports.assertPlaceholder = assertPlaceholder;
			
 
				+exports.assertPrivate = assertPrivate;
			
 
				+exports.assertPrivateName = assertPrivateName;
			
 
				+exports.assertProgram = assertProgram;
			
 
				+exports.assertProperty = assertProperty;
			
 
				+exports.assertPureish = assertPureish;
			
 
				+exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
			
 
				+exports.assertRecordExpression = assertRecordExpression;
			
 
				+exports.assertRegExpLiteral = assertRegExpLiteral;
			
 
				+exports.assertRegexLiteral = assertRegexLiteral;
			
 
				+exports.assertRestElement = assertRestElement;
			
 
				+exports.assertRestProperty = assertRestProperty;
			
 
				+exports.assertReturnStatement = assertReturnStatement;
			
 
				+exports.assertScopable = assertScopable;
			
 
				+exports.assertSequenceExpression = assertSequenceExpression;
			
 
				+exports.assertSpreadElement = assertSpreadElement;
			
 
				+exports.assertSpreadProperty = assertSpreadProperty;
			
 
				+exports.assertStandardized = assertStandardized;
			
 
				+exports.assertStatement = assertStatement;
			
 
				+exports.assertStaticBlock = assertStaticBlock;
			
 
				+exports.assertStringLiteral = assertStringLiteral;
			
 
				+exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
			
 
				+exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
			
 
				+exports.assertSuper = assertSuper;
			
 
				+exports.assertSwitchCase = assertSwitchCase;
			
 
				+exports.assertSwitchStatement = assertSwitchStatement;
			
 
				+exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
			
 
				+exports.assertTSAnyKeyword = assertTSAnyKeyword;
			
 
				+exports.assertTSArrayType = assertTSArrayType;
			
 
				+exports.assertTSAsExpression = assertTSAsExpression;
			
 
				+exports.assertTSBaseType = assertTSBaseType;
			
 
				+exports.assertTSBigIntKeyword = assertTSBigIntKeyword;
			
 
				+exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
			
 
				+exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
			
 
				+exports.assertTSConditionalType = assertTSConditionalType;
			
 
				+exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
			
 
				+exports.assertTSConstructorType = assertTSConstructorType;
			
 
				+exports.assertTSDeclareFunction = assertTSDeclareFunction;
			
 
				+exports.assertTSDeclareMethod = assertTSDeclareMethod;
			
 
				+exports.assertTSEntityName = assertTSEntityName;
			
 
				+exports.assertTSEnumBody = assertTSEnumBody;
			
 
				+exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
			
 
				+exports.assertTSEnumMember = assertTSEnumMember;
			
 
				+exports.assertTSExportAssignment = assertTSExportAssignment;
			
 
				+exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
			
 
				+exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
			
 
				+exports.assertTSFunctionType = assertTSFunctionType;
			
 
				+exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
			
 
				+exports.assertTSImportType = assertTSImportType;
			
 
				+exports.assertTSIndexSignature = assertTSIndexSignature;
			
 
				+exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
			
 
				+exports.assertTSInferType = assertTSInferType;
			
 
				+exports.assertTSInstantiationExpression = assertTSInstantiationExpression;
			
 
				+exports.assertTSInterfaceBody = assertTSInterfaceBody;
			
 
				+exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
			
 
				+exports.assertTSIntersectionType = assertTSIntersectionType;
			
 
				+exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;
			
 
				+exports.assertTSLiteralType = assertTSLiteralType;
			
 
				+exports.assertTSMappedType = assertTSMappedType;
			
 
				+exports.assertTSMethodSignature = assertTSMethodSignature;
			
 
				+exports.assertTSModuleBlock = assertTSModuleBlock;
			
 
				+exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
			
 
				+exports.assertTSNamedTupleMember = assertTSNamedTupleMember;
			
 
				+exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
			
 
				+exports.assertTSNeverKeyword = assertTSNeverKeyword;
			
 
				+exports.assertTSNonNullExpression = assertTSNonNullExpression;
			
 
				+exports.assertTSNullKeyword = assertTSNullKeyword;
			
 
				+exports.assertTSNumberKeyword = assertTSNumberKeyword;
			
 
				+exports.assertTSObjectKeyword = assertTSObjectKeyword;
			
 
				+exports.assertTSOptionalType = assertTSOptionalType;
			
 
				+exports.assertTSParameterProperty = assertTSParameterProperty;
			
 
				+exports.assertTSParenthesizedType = assertTSParenthesizedType;
			
 
				+exports.assertTSPropertySignature = assertTSPropertySignature;
			
 
				+exports.assertTSQualifiedName = assertTSQualifiedName;
			
 
				+exports.assertTSRestType = assertTSRestType;
			
 
				+exports.assertTSSatisfiesExpression = assertTSSatisfiesExpression;
			
 
				+exports.assertTSStringKeyword = assertTSStringKeyword;
			
 
				+exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
			
 
				+exports.assertTSTemplateLiteralType = assertTSTemplateLiteralType;
			
 
				+exports.assertTSThisType = assertTSThisType;
			
 
				+exports.assertTSTupleType = assertTSTupleType;
			
 
				+exports.assertTSType = assertTSType;
			
 
				+exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
			
 
				+exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
			
 
				+exports.assertTSTypeAssertion = assertTSTypeAssertion;
			
 
				+exports.assertTSTypeElement = assertTSTypeElement;
			
 
				+exports.assertTSTypeLiteral = assertTSTypeLiteral;
			
 
				+exports.assertTSTypeOperator = assertTSTypeOperator;
			
 
				+exports.assertTSTypeParameter = assertTSTypeParameter;
			
 
				+exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
			
 
				+exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
			
 
				+exports.assertTSTypePredicate = assertTSTypePredicate;
			
 
				+exports.assertTSTypeQuery = assertTSTypeQuery;
			
 
				+exports.assertTSTypeReference = assertTSTypeReference;
			
 
				+exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
			
 
				+exports.assertTSUnionType = assertTSUnionType;
			
 
				+exports.assertTSUnknownKeyword = assertTSUnknownKeyword;
			
 
				+exports.assertTSVoidKeyword = assertTSVoidKeyword;
			
 
				+exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
			
 
				+exports.assertTemplateElement = assertTemplateElement;
			
 
				+exports.assertTemplateLiteral = assertTemplateLiteral;
			
 
				+exports.assertTerminatorless = assertTerminatorless;
			
 
				+exports.assertThisExpression = assertThisExpression;
			
 
				+exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
			
 
				+exports.assertThrowStatement = assertThrowStatement;
			
 
				+exports.assertTopicReference = assertTopicReference;
			
 
				+exports.assertTryStatement = assertTryStatement;
			
 
				+exports.assertTupleExpression = assertTupleExpression;
			
 
				+exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
			
 
				+exports.assertTypeAlias = assertTypeAlias;
			
 
				+exports.assertTypeAnnotation = assertTypeAnnotation;
			
 
				+exports.assertTypeCastExpression = assertTypeCastExpression;
			
 
				+exports.assertTypeParameter = assertTypeParameter;
			
 
				+exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
			
 
				+exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
			
 
				+exports.assertTypeScript = assertTypeScript;
			
 
				+exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
			
 
				+exports.assertUnaryExpression = assertUnaryExpression;
			
 
				+exports.assertUnaryLike = assertUnaryLike;
			
 
				+exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
			
 
				+exports.assertUpdateExpression = assertUpdateExpression;
			
 
				+exports.assertUserWhitespacable = assertUserWhitespacable;
			
 
				+exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;
			
 
				+exports.assertVariableDeclaration = assertVariableDeclaration;
			
 
				+exports.assertVariableDeclarator = assertVariableDeclarator;
			
 
				+exports.assertVariance = assertVariance;
			
 
				+exports.assertVoidPattern = assertVoidPattern;
			
 
				+exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
			
 
				+exports.assertWhile = assertWhile;
			
 
				+exports.assertWhileStatement = assertWhileStatement;
			
 
				+exports.assertWithStatement = assertWithStatement;
			
 
				+exports.assertYieldExpression = assertYieldExpression;
			
 
				+var _is = require("../../validators/is.js");
			
 
				+var _deprecationWarning = require("../../utils/deprecationWarning.js");
			
 
				+function assert(type, node, opts) {
			
 
				+  if (!(0, _is.default)(type, node, opts)) {
			
 
				+    throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`);
			
 
				+  }
			
 
				+}
			
 
				+function assertArrayExpression(node, opts) {
			
 
				+  assert("ArrayExpression", node, opts);
			
 
				+}
			
 
				+function assertAssignmentExpression(node, opts) {
			
 
				+  assert("AssignmentExpression", node, opts);
			
 
				+}
			
 
				+function assertBinaryExpression(node, opts) {
			
 
				+  assert("BinaryExpression", node, opts);
			
 
				+}
			
 
				+function assertInterpreterDirective(node, opts) {
			
 
				+  assert("InterpreterDirective", node, opts);
			
 
				+}
			
 
				+function assertDirective(node, opts) {
			
 
				+  assert("Directive", node, opts);
			
 
				+}
			
 
				+function assertDirectiveLiteral(node, opts) {
			
 
				+  assert("DirectiveLiteral", node, opts);
			
 
				+}
			
 
				+function assertBlockStatement(node, opts) {
			
 
				+  assert("BlockStatement", node, opts);
			
 
				+}
			
 
				+function assertBreakStatement(node, opts) {
			
 
				+  assert("BreakStatement", node, opts);
			
 
				+}
			
 
				+function assertCallExpression(node, opts) {
			
 
				+  assert("CallExpression", node, opts);
			
 
				+}
			
 
				+function assertCatchClause(node, opts) {
			
 
				+  assert("CatchClause", node, opts);
			
 
				+}
			
 
				+function assertConditionalExpression(node, opts) {
			
 
				+  assert("ConditionalExpression", node, opts);
			
 
				+}
			
 
				+function assertContinueStatement(node, opts) {
			
 
				+  assert("ContinueStatement", node, opts);
			
 
				+}
			
 
				+function assertDebuggerStatement(node, opts) {
			
 
				+  assert("DebuggerStatement", node, opts);
			
 
				+}
			
 
				+function assertDoWhileStatement(node, opts) {
			
 
				+  assert("DoWhileStatement", node, opts);
			
 
				+}
			
 
				+function assertEmptyStatement(node, opts) {
			
 
				+  assert("EmptyStatement", node, opts);
			
 
				+}
			
 
				+function assertExpressionStatement(node, opts) {
			
 
				+  assert("ExpressionStatement", node, opts);
			
 
				+}
			
 
				+function assertFile(node, opts) {
			
 
				+  assert("File", node, opts);
			
 
				+}
			
 
				+function assertForInStatement(node, opts) {
			
 
				+  assert("ForInStatement", node, opts);
			
 
				+}
			
 
				+function assertForStatement(node, opts) {
			
 
				+  assert("ForStatement", node, opts);
			
 
				+}
			
 
				+function assertFunctionDeclaration(node, opts) {
			
 
				+  assert("FunctionDeclaration", node, opts);
			
 
				+}
			
 
				+function assertFunctionExpression(node, opts) {
			
 
				+  assert("FunctionExpression", node, opts);
			
 
				+}
			
 
				+function assertIdentifier(node, opts) {
			
 
				+  assert("Identifier", node, opts);
			
 
				+}
			
 
				+function assertIfStatement(node, opts) {
			
 
				+  assert("IfStatement", node, opts);
			
 
				+}
			
 
				+function assertLabeledStatement(node, opts) {
			
 
				+  assert("LabeledStatement", node, opts);
			
 
				+}
			
 
				+function assertStringLiteral(node, opts) {
			
 
				+  assert("StringLiteral", node, opts);
			
 
				+}
			
 
				+function assertNumericLiteral(node, opts) {
			
 
				+  assert("NumericLiteral", node, opts);
			
 
				+}
			
 
				+function assertNullLiteral(node, opts) {
			
 
				+  assert("NullLiteral", node, opts);
			
 
				+}
			
 
				+function assertBooleanLiteral(node, opts) {
			
 
				+  assert("BooleanLiteral", node, opts);
			
 
				+}
			
 
				+function assertRegExpLiteral(node, opts) {
			
 
				+  assert("RegExpLiteral", node, opts);
			
 
				+}
			
 
				+function assertLogicalExpression(node, opts) {
			
 
				+  assert("LogicalExpression", node, opts);
			
 
				+}
			
 
				+function assertMemberExpression(node, opts) {
			
 
				+  assert("MemberExpression", node, opts);
			
 
				+}
			
 
				+function assertNewExpression(node, opts) {
			
 
				+  assert("NewExpression", node, opts);
			
 
				+}
			
 
				+function assertProgram(node, opts) {
			
 
				+  assert("Program", node, opts);
			
 
				+}
			
 
				+function assertObjectExpression(node, opts) {
			
 
				+  assert("ObjectExpression", node, opts);
			
 
				+}
			
 
				+function assertObjectMethod(node, opts) {
			
 
				+  assert("ObjectMethod", node, opts);
			
 
				+}
			
 
				+function assertObjectProperty(node, opts) {
			
 
				+  assert("ObjectProperty", node, opts);
			
 
				+}
			
 
				+function assertRestElement(node, opts) {
			
 
				+  assert("RestElement", node, opts);
			
 
				+}
			
 
				+function assertReturnStatement(node, opts) {
			
 
				+  assert("ReturnStatement", node, opts);
			
 
				+}
			
 
				+function assertSequenceExpression(node, opts) {
			
 
				+  assert("SequenceExpression", node, opts);
			
 
				+}
			
 
				+function assertParenthesizedExpression(node, opts) {
			
 
				+  assert("ParenthesizedExpression", node, opts);
			
 
				+}
			
 
				+function assertSwitchCase(node, opts) {
			
 
				+  assert("SwitchCase", node, opts);
			
 
				+}
			
 
				+function assertSwitchStatement(node, opts) {
			
 
				+  assert("SwitchStatement", node, opts);
			
 
				+}
			
 
				+function assertThisExpression(node, opts) {
			
 
				+  assert("ThisExpression", node, opts);
			
 
				+}
			
 
				+function assertThrowStatement(node, opts) {
			
 
				+  assert("ThrowStatement", node, opts);
			
 
				+}
			
 
				+function assertTryStatement(node, opts) {
			
 
				+  assert("TryStatement", node, opts);
			
 
				+}
			
 
				+function assertUnaryExpression(node, opts) {
			
 
				+  assert("UnaryExpression", node, opts);
			
 
				+}
			
 
				+function assertUpdateExpression(node, opts) {
			
 
				+  assert("UpdateExpression", node, opts);
			
 
				+}
			
 
				+function assertVariableDeclaration(node, opts) {
			
 
				+  assert("VariableDeclaration", node, opts);
			
 
				+}
			
 
				+function assertVariableDeclarator(node, opts) {
			
 
				+  assert("VariableDeclarator", node, opts);
			
 
				+}
			
 
				+function assertWhileStatement(node, opts) {
			
 
				+  assert("WhileStatement", node, opts);
			
 
				+}
			
 
				+function assertWithStatement(node, opts) {
			
 
				+  assert("WithStatement", node, opts);
			
 
				+}
			
 
				+function assertAssignmentPattern(node, opts) {
			
 
				+  assert("AssignmentPattern", node, opts);
			
 
				+}
			
 
				+function assertArrayPattern(node, opts) {
			
 
				+  assert("ArrayPattern", node, opts);
			
 
				+}
			
 
				+function assertArrowFunctionExpression(node, opts) {
			
 
				+  assert("ArrowFunctionExpression", node, opts);
			
 
				+}
			
 
				+function assertClassBody(node, opts) {
			
 
				+  assert("ClassBody", node, opts);
			
 
				+}
			
 
				+function assertClassExpression(node, opts) {
			
 
				+  assert("ClassExpression", node, opts);
			
 
				+}
			
 
				+function assertClassDeclaration(node, opts) {
			
 
				+  assert("ClassDeclaration", node, opts);
			
 
				+}
			
 
				+function assertExportAllDeclaration(node, opts) {
			
 
				+  assert("ExportAllDeclaration", node, opts);
			
 
				+}
			
 
				+function assertExportDefaultDeclaration(node, opts) {
			
 
				+  assert("ExportDefaultDeclaration", node, opts);
			
 
				+}
			
 
				+function assertExportNamedDeclaration(node, opts) {
			
 
				+  assert("ExportNamedDeclaration", node, opts);
			
 
				+}
			
 
				+function assertExportSpecifier(node, opts) {
			
 
				+  assert("ExportSpecifier", node, opts);
			
 
				+}
			
 
				+function assertForOfStatement(node, opts) {
			
 
				+  assert("ForOfStatement", node, opts);
			
 
				+}
			
 
				+function assertImportDeclaration(node, opts) {
			
 
				+  assert("ImportDeclaration", node, opts);
			
 
				+}
			
 
				+function assertImportDefaultSpecifier(node, opts) {
			
 
				+  assert("ImportDefaultSpecifier", node, opts);
			
 
				+}
			
 
				+function assertImportNamespaceSpecifier(node, opts) {
			
 
				+  assert("ImportNamespaceSpecifier", node, opts);
			
 
				+}
			
 
				+function assertImportSpecifier(node, opts) {
			
 
				+  assert("ImportSpecifier", node, opts);
			
 
				+}
			
 
				+function assertImportExpression(node, opts) {
			
 
				+  assert("ImportExpression", node, opts);
			
 
				+}
			
 
				+function assertMetaProperty(node, opts) {
			
 
				+  assert("MetaProperty", node, opts);
			
 
				+}
			
 
				+function assertClassMethod(node, opts) {
			
 
				+  assert("ClassMethod", node, opts);
			
 
				+}
			
 
				+function assertObjectPattern(node, opts) {
			
 
				+  assert("ObjectPattern", node, opts);
			
 
				+}
			
 
				+function assertSpreadElement(node, opts) {
			
 
				+  assert("SpreadElement", node, opts);
			
 
				+}
			
 
				+function assertSuper(node, opts) {
			
 
				+  assert("Super", node, opts);
			
 
				+}
			
 
				+function assertTaggedTemplateExpression(node, opts) {
			
 
				+  assert("TaggedTemplateExpression", node, opts);
			
 
				+}
			
 
				+function assertTemplateElement(node, opts) {
			
 
				+  assert("TemplateElement", node, opts);
			
 
				+}
			
 
				+function assertTemplateLiteral(node, opts) {
			
 
				+  assert("TemplateLiteral", node, opts);
			
 
				+}
			
 
				+function assertYieldExpression(node, opts) {
			
 
				+  assert("YieldExpression", node, opts);
			
 
				+}
			
 
				+function assertAwaitExpression(node, opts) {
			
 
				+  assert("AwaitExpression", node, opts);
			
 
				+}
			
 
				+function assertImport(node, opts) {
			
 
				+  assert("Import", node, opts);
			
 
				+}
			
 
				+function assertBigIntLiteral(node, opts) {
			
 
				+  assert("BigIntLiteral", node, opts);
			
 
				+}
			
 
				+function assertExportNamespaceSpecifier(node, opts) {
			
 
				+  assert("ExportNamespaceSpecifier", node, opts);
			
 
				+}
			
 
				+function assertOptionalMemberExpression(node, opts) {
			
 
				+  assert("OptionalMemberExpression", node, opts);
			
 
				+}
			
 
				+function assertOptionalCallExpression(node, opts) {
			
 
				+  assert("OptionalCallExpression", node, opts);
			
 
				+}
			
 
				+function assertClassProperty(node, opts) {
			
 
				+  assert("ClassProperty", node, opts);
			
 
				+}
			
 
				+function assertClassAccessorProperty(node, opts) {
			
 
				+  assert("ClassAccessorProperty", node, opts);
			
 
				+}
			
 
				+function assertClassPrivateProperty(node, opts) {
			
 
				+  assert("ClassPrivateProperty", node, opts);
			
 
				+}
			
 
				+function assertClassPrivateMethod(node, opts) {
			
 
				+  assert("ClassPrivateMethod", node, opts);
			
 
				+}
			
 
				+function assertPrivateName(node, opts) {
			
 
				+  assert("PrivateName", node, opts);
			
 
				+}
			
 
				+function assertStaticBlock(node, opts) {
			
 
				+  assert("StaticBlock", node, opts);
			
 
				+}
			
 
				+function assertImportAttribute(node, opts) {
			
 
				+  assert("ImportAttribute", node, opts);
			
 
				+}
			
 
				+function assertAnyTypeAnnotation(node, opts) {
			
 
				+  assert("AnyTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertArrayTypeAnnotation(node, opts) {
			
 
				+  assert("ArrayTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertBooleanTypeAnnotation(node, opts) {
			
 
				+  assert("BooleanTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertBooleanLiteralTypeAnnotation(node, opts) {
			
 
				+  assert("BooleanLiteralTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertNullLiteralTypeAnnotation(node, opts) {
			
 
				+  assert("NullLiteralTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertClassImplements(node, opts) {
			
 
				+  assert("ClassImplements", node, opts);
			
 
				+}
			
 
				+function assertDeclareClass(node, opts) {
			
 
				+  assert("DeclareClass", node, opts);
			
 
				+}
			
 
				+function assertDeclareFunction(node, opts) {
			
 
				+  assert("DeclareFunction", node, opts);
			
 
				+}
			
 
				+function assertDeclareInterface(node, opts) {
			
 
				+  assert("DeclareInterface", node, opts);
			
 
				+}
			
 
				+function assertDeclareModule(node, opts) {
			
 
				+  assert("DeclareModule", node, opts);
			
 
				+}
			
 
				+function assertDeclareModuleExports(node, opts) {
			
 
				+  assert("DeclareModuleExports", node, opts);
			
 
				+}
			
 
				+function assertDeclareTypeAlias(node, opts) {
			
 
				+  assert("DeclareTypeAlias", node, opts);
			
 
				+}
			
 
				+function assertDeclareOpaqueType(node, opts) {
			
 
				+  assert("DeclareOpaqueType", node, opts);
			
 
				+}
			
 
				+function assertDeclareVariable(node, opts) {
			
 
				+  assert("DeclareVariable", node, opts);
			
 
				+}
			
 
				+function assertDeclareExportDeclaration(node, opts) {
			
 
				+  assert("DeclareExportDeclaration", node, opts);
			
 
				+}
			
 
				+function assertDeclareExportAllDeclaration(node, opts) {
			
 
				+  assert("DeclareExportAllDeclaration", node, opts);
			
 
				+}
			
 
				+function assertDeclaredPredicate(node, opts) {
			
 
				+  assert("DeclaredPredicate", node, opts);
			
 
				+}
			
 
				+function assertExistsTypeAnnotation(node, opts) {
			
 
				+  assert("ExistsTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertFunctionTypeAnnotation(node, opts) {
			
 
				+  assert("FunctionTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertFunctionTypeParam(node, opts) {
			
 
				+  assert("FunctionTypeParam", node, opts);
			
 
				+}
			
 
				+function assertGenericTypeAnnotation(node, opts) {
			
 
				+  assert("GenericTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertInferredPredicate(node, opts) {
			
 
				+  assert("InferredPredicate", node, opts);
			
 
				+}
			
 
				+function assertInterfaceExtends(node, opts) {
			
 
				+  assert("InterfaceExtends", node, opts);
			
 
				+}
			
 
				+function assertInterfaceDeclaration(node, opts) {
			
 
				+  assert("InterfaceDeclaration", node, opts);
			
 
				+}
			
 
				+function assertInterfaceTypeAnnotation(node, opts) {
			
 
				+  assert("InterfaceTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertIntersectionTypeAnnotation(node, opts) {
			
 
				+  assert("IntersectionTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertMixedTypeAnnotation(node, opts) {
			
 
				+  assert("MixedTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertEmptyTypeAnnotation(node, opts) {
			
 
				+  assert("EmptyTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertNullableTypeAnnotation(node, opts) {
			
 
				+  assert("NullableTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertNumberLiteralTypeAnnotation(node, opts) {
			
 
				+  assert("NumberLiteralTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertNumberTypeAnnotation(node, opts) {
			
 
				+  assert("NumberTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertObjectTypeAnnotation(node, opts) {
			
 
				+  assert("ObjectTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertObjectTypeInternalSlot(node, opts) {
			
 
				+  assert("ObjectTypeInternalSlot", node, opts);
			
 
				+}
			
 
				+function assertObjectTypeCallProperty(node, opts) {
			
 
				+  assert("ObjectTypeCallProperty", node, opts);
			
 
				+}
			
 
				+function assertObjectTypeIndexer(node, opts) {
			
 
				+  assert("ObjectTypeIndexer", node, opts);
			
 
				+}
			
 
				+function assertObjectTypeProperty(node, opts) {
			
 
				+  assert("ObjectTypeProperty", node, opts);
			
 
				+}
			
 
				+function assertObjectTypeSpreadProperty(node, opts) {
			
 
				+  assert("ObjectTypeSpreadProperty", node, opts);
			
 
				+}
			
 
				+function assertOpaqueType(node, opts) {
			
 
				+  assert("OpaqueType", node, opts);
			
 
				+}
			
 
				+function assertQualifiedTypeIdentifier(node, opts) {
			
 
				+  assert("QualifiedTypeIdentifier", node, opts);
			
 
				+}
			
 
				+function assertStringLiteralTypeAnnotation(node, opts) {
			
 
				+  assert("StringLiteralTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertStringTypeAnnotation(node, opts) {
			
 
				+  assert("StringTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertSymbolTypeAnnotation(node, opts) {
			
 
				+  assert("SymbolTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertThisTypeAnnotation(node, opts) {
			
 
				+  assert("ThisTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertTupleTypeAnnotation(node, opts) {
			
 
				+  assert("TupleTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertTypeofTypeAnnotation(node, opts) {
			
 
				+  assert("TypeofTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertTypeAlias(node, opts) {
			
 
				+  assert("TypeAlias", node, opts);
			
 
				+}
			
 
				+function assertTypeAnnotation(node, opts) {
			
 
				+  assert("TypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertTypeCastExpression(node, opts) {
			
 
				+  assert("TypeCastExpression", node, opts);
			
 
				+}
			
 
				+function assertTypeParameter(node, opts) {
			
 
				+  assert("TypeParameter", node, opts);
			
 
				+}
			
 
				+function assertTypeParameterDeclaration(node, opts) {
			
 
				+  assert("TypeParameterDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTypeParameterInstantiation(node, opts) {
			
 
				+  assert("TypeParameterInstantiation", node, opts);
			
 
				+}
			
 
				+function assertUnionTypeAnnotation(node, opts) {
			
 
				+  assert("UnionTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertVariance(node, opts) {
			
 
				+  assert("Variance", node, opts);
			
 
				+}
			
 
				+function assertVoidTypeAnnotation(node, opts) {
			
 
				+  assert("VoidTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertEnumDeclaration(node, opts) {
			
 
				+  assert("EnumDeclaration", node, opts);
			
 
				+}
			
 
				+function assertEnumBooleanBody(node, opts) {
			
 
				+  assert("EnumBooleanBody", node, opts);
			
 
				+}
			
 
				+function assertEnumNumberBody(node, opts) {
			
 
				+  assert("EnumNumberBody", node, opts);
			
 
				+}
			
 
				+function assertEnumStringBody(node, opts) {
			
 
				+  assert("EnumStringBody", node, opts);
			
 
				+}
			
 
				+function assertEnumSymbolBody(node, opts) {
			
 
				+  assert("EnumSymbolBody", node, opts);
			
 
				+}
			
 
				+function assertEnumBooleanMember(node, opts) {
			
 
				+  assert("EnumBooleanMember", node, opts);
			
 
				+}
			
 
				+function assertEnumNumberMember(node, opts) {
			
 
				+  assert("EnumNumberMember", node, opts);
			
 
				+}
			
 
				+function assertEnumStringMember(node, opts) {
			
 
				+  assert("EnumStringMember", node, opts);
			
 
				+}
			
 
				+function assertEnumDefaultedMember(node, opts) {
			
 
				+  assert("EnumDefaultedMember", node, opts);
			
 
				+}
			
 
				+function assertIndexedAccessType(node, opts) {
			
 
				+  assert("IndexedAccessType", node, opts);
			
 
				+}
			
 
				+function assertOptionalIndexedAccessType(node, opts) {
			
 
				+  assert("OptionalIndexedAccessType", node, opts);
			
 
				+}
			
 
				+function assertJSXAttribute(node, opts) {
			
 
				+  assert("JSXAttribute", node, opts);
			
 
				+}
			
 
				+function assertJSXClosingElement(node, opts) {
			
 
				+  assert("JSXClosingElement", node, opts);
			
 
				+}
			
 
				+function assertJSXElement(node, opts) {
			
 
				+  assert("JSXElement", node, opts);
			
 
				+}
			
 
				+function assertJSXEmptyExpression(node, opts) {
			
 
				+  assert("JSXEmptyExpression", node, opts);
			
 
				+}
			
 
				+function assertJSXExpressionContainer(node, opts) {
			
 
				+  assert("JSXExpressionContainer", node, opts);
			
 
				+}
			
 
				+function assertJSXSpreadChild(node, opts) {
			
 
				+  assert("JSXSpreadChild", node, opts);
			
 
				+}
			
 
				+function assertJSXIdentifier(node, opts) {
			
 
				+  assert("JSXIdentifier", node, opts);
			
 
				+}
			
 
				+function assertJSXMemberExpression(node, opts) {
			
 
				+  assert("JSXMemberExpression", node, opts);
			
 
				+}
			
 
				+function assertJSXNamespacedName(node, opts) {
			
 
				+  assert("JSXNamespacedName", node, opts);
			
 
				+}
			
 
				+function assertJSXOpeningElement(node, opts) {
			
 
				+  assert("JSXOpeningElement", node, opts);
			
 
				+}
			
 
				+function assertJSXSpreadAttribute(node, opts) {
			
 
				+  assert("JSXSpreadAttribute", node, opts);
			
 
				+}
			
 
				+function assertJSXText(node, opts) {
			
 
				+  assert("JSXText", node, opts);
			
 
				+}
			
 
				+function assertJSXFragment(node, opts) {
			
 
				+  assert("JSXFragment", node, opts);
			
 
				+}
			
 
				+function assertJSXOpeningFragment(node, opts) {
			
 
				+  assert("JSXOpeningFragment", node, opts);
			
 
				+}
			
 
				+function assertJSXClosingFragment(node, opts) {
			
 
				+  assert("JSXClosingFragment", node, opts);
			
 
				+}
			
 
				+function assertNoop(node, opts) {
			
 
				+  assert("Noop", node, opts);
			
 
				+}
			
 
				+function assertPlaceholder(node, opts) {
			
 
				+  assert("Placeholder", node, opts);
			
 
				+}
			
 
				+function assertV8IntrinsicIdentifier(node, opts) {
			
 
				+  assert("V8IntrinsicIdentifier", node, opts);
			
 
				+}
			
 
				+function assertArgumentPlaceholder(node, opts) {
			
 
				+  assert("ArgumentPlaceholder", node, opts);
			
 
				+}
			
 
				+function assertBindExpression(node, opts) {
			
 
				+  assert("BindExpression", node, opts);
			
 
				+}
			
 
				+function assertDecorator(node, opts) {
			
 
				+  assert("Decorator", node, opts);
			
 
				+}
			
 
				+function assertDoExpression(node, opts) {
			
 
				+  assert("DoExpression", node, opts);
			
 
				+}
			
 
				+function assertExportDefaultSpecifier(node, opts) {
			
 
				+  assert("ExportDefaultSpecifier", node, opts);
			
 
				+}
			
 
				+function assertRecordExpression(node, opts) {
			
 
				+  assert("RecordExpression", node, opts);
			
 
				+}
			
 
				+function assertTupleExpression(node, opts) {
			
 
				+  assert("TupleExpression", node, opts);
			
 
				+}
			
 
				+function assertDecimalLiteral(node, opts) {
			
 
				+  assert("DecimalLiteral", node, opts);
			
 
				+}
			
 
				+function assertModuleExpression(node, opts) {
			
 
				+  assert("ModuleExpression", node, opts);
			
 
				+}
			
 
				+function assertTopicReference(node, opts) {
			
 
				+  assert("TopicReference", node, opts);
			
 
				+}
			
 
				+function assertPipelineTopicExpression(node, opts) {
			
 
				+  assert("PipelineTopicExpression", node, opts);
			
 
				+}
			
 
				+function assertPipelineBareFunction(node, opts) {
			
 
				+  assert("PipelineBareFunction", node, opts);
			
 
				+}
			
 
				+function assertPipelinePrimaryTopicReference(node, opts) {
			
 
				+  assert("PipelinePrimaryTopicReference", node, opts);
			
 
				+}
			
 
				+function assertVoidPattern(node, opts) {
			
 
				+  assert("VoidPattern", node, opts);
			
 
				+}
			
 
				+function assertTSParameterProperty(node, opts) {
			
 
				+  assert("TSParameterProperty", node, opts);
			
 
				+}
			
 
				+function assertTSDeclareFunction(node, opts) {
			
 
				+  assert("TSDeclareFunction", node, opts);
			
 
				+}
			
 
				+function assertTSDeclareMethod(node, opts) {
			
 
				+  assert("TSDeclareMethod", node, opts);
			
 
				+}
			
 
				+function assertTSQualifiedName(node, opts) {
			
 
				+  assert("TSQualifiedName", node, opts);
			
 
				+}
			
 
				+function assertTSCallSignatureDeclaration(node, opts) {
			
 
				+  assert("TSCallSignatureDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSConstructSignatureDeclaration(node, opts) {
			
 
				+  assert("TSConstructSignatureDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSPropertySignature(node, opts) {
			
 
				+  assert("TSPropertySignature", node, opts);
			
 
				+}
			
 
				+function assertTSMethodSignature(node, opts) {
			
 
				+  assert("TSMethodSignature", node, opts);
			
 
				+}
			
 
				+function assertTSIndexSignature(node, opts) {
			
 
				+  assert("TSIndexSignature", node, opts);
			
 
				+}
			
 
				+function assertTSAnyKeyword(node, opts) {
			
 
				+  assert("TSAnyKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSBooleanKeyword(node, opts) {
			
 
				+  assert("TSBooleanKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSBigIntKeyword(node, opts) {
			
 
				+  assert("TSBigIntKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSIntrinsicKeyword(node, opts) {
			
 
				+  assert("TSIntrinsicKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSNeverKeyword(node, opts) {
			
 
				+  assert("TSNeverKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSNullKeyword(node, opts) {
			
 
				+  assert("TSNullKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSNumberKeyword(node, opts) {
			
 
				+  assert("TSNumberKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSObjectKeyword(node, opts) {
			
 
				+  assert("TSObjectKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSStringKeyword(node, opts) {
			
 
				+  assert("TSStringKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSSymbolKeyword(node, opts) {
			
 
				+  assert("TSSymbolKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSUndefinedKeyword(node, opts) {
			
 
				+  assert("TSUndefinedKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSUnknownKeyword(node, opts) {
			
 
				+  assert("TSUnknownKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSVoidKeyword(node, opts) {
			
 
				+  assert("TSVoidKeyword", node, opts);
			
 
				+}
			
 
				+function assertTSThisType(node, opts) {
			
 
				+  assert("TSThisType", node, opts);
			
 
				+}
			
 
				+function assertTSFunctionType(node, opts) {
			
 
				+  assert("TSFunctionType", node, opts);
			
 
				+}
			
 
				+function assertTSConstructorType(node, opts) {
			
 
				+  assert("TSConstructorType", node, opts);
			
 
				+}
			
 
				+function assertTSTypeReference(node, opts) {
			
 
				+  assert("TSTypeReference", node, opts);
			
 
				+}
			
 
				+function assertTSTypePredicate(node, opts) {
			
 
				+  assert("TSTypePredicate", node, opts);
			
 
				+}
			
 
				+function assertTSTypeQuery(node, opts) {
			
 
				+  assert("TSTypeQuery", node, opts);
			
 
				+}
			
 
				+function assertTSTypeLiteral(node, opts) {
			
 
				+  assert("TSTypeLiteral", node, opts);
			
 
				+}
			
 
				+function assertTSArrayType(node, opts) {
			
 
				+  assert("TSArrayType", node, opts);
			
 
				+}
			
 
				+function assertTSTupleType(node, opts) {
			
 
				+  assert("TSTupleType", node, opts);
			
 
				+}
			
 
				+function assertTSOptionalType(node, opts) {
			
 
				+  assert("TSOptionalType", node, opts);
			
 
				+}
			
 
				+function assertTSRestType(node, opts) {
			
 
				+  assert("TSRestType", node, opts);
			
 
				+}
			
 
				+function assertTSNamedTupleMember(node, opts) {
			
 
				+  assert("TSNamedTupleMember", node, opts);
			
 
				+}
			
 
				+function assertTSUnionType(node, opts) {
			
 
				+  assert("TSUnionType", node, opts);
			
 
				+}
			
 
				+function assertTSIntersectionType(node, opts) {
			
 
				+  assert("TSIntersectionType", node, opts);
			
 
				+}
			
 
				+function assertTSConditionalType(node, opts) {
			
 
				+  assert("TSConditionalType", node, opts);
			
 
				+}
			
 
				+function assertTSInferType(node, opts) {
			
 
				+  assert("TSInferType", node, opts);
			
 
				+}
			
 
				+function assertTSParenthesizedType(node, opts) {
			
 
				+  assert("TSParenthesizedType", node, opts);
			
 
				+}
			
 
				+function assertTSTypeOperator(node, opts) {
			
 
				+  assert("TSTypeOperator", node, opts);
			
 
				+}
			
 
				+function assertTSIndexedAccessType(node, opts) {
			
 
				+  assert("TSIndexedAccessType", node, opts);
			
 
				+}
			
 
				+function assertTSMappedType(node, opts) {
			
 
				+  assert("TSMappedType", node, opts);
			
 
				+}
			
 
				+function assertTSTemplateLiteralType(node, opts) {
			
 
				+  assert("TSTemplateLiteralType", node, opts);
			
 
				+}
			
 
				+function assertTSLiteralType(node, opts) {
			
 
				+  assert("TSLiteralType", node, opts);
			
 
				+}
			
 
				+function assertTSExpressionWithTypeArguments(node, opts) {
			
 
				+  assert("TSExpressionWithTypeArguments", node, opts);
			
 
				+}
			
 
				+function assertTSInterfaceDeclaration(node, opts) {
			
 
				+  assert("TSInterfaceDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSInterfaceBody(node, opts) {
			
 
				+  assert("TSInterfaceBody", node, opts);
			
 
				+}
			
 
				+function assertTSTypeAliasDeclaration(node, opts) {
			
 
				+  assert("TSTypeAliasDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSInstantiationExpression(node, opts) {
			
 
				+  assert("TSInstantiationExpression", node, opts);
			
 
				+}
			
 
				+function assertTSAsExpression(node, opts) {
			
 
				+  assert("TSAsExpression", node, opts);
			
 
				+}
			
 
				+function assertTSSatisfiesExpression(node, opts) {
			
 
				+  assert("TSSatisfiesExpression", node, opts);
			
 
				+}
			
 
				+function assertTSTypeAssertion(node, opts) {
			
 
				+  assert("TSTypeAssertion", node, opts);
			
 
				+}
			
 
				+function assertTSEnumBody(node, opts) {
			
 
				+  assert("TSEnumBody", node, opts);
			
 
				+}
			
 
				+function assertTSEnumDeclaration(node, opts) {
			
 
				+  assert("TSEnumDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSEnumMember(node, opts) {
			
 
				+  assert("TSEnumMember", node, opts);
			
 
				+}
			
 
				+function assertTSModuleDeclaration(node, opts) {
			
 
				+  assert("TSModuleDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSModuleBlock(node, opts) {
			
 
				+  assert("TSModuleBlock", node, opts);
			
 
				+}
			
 
				+function assertTSImportType(node, opts) {
			
 
				+  assert("TSImportType", node, opts);
			
 
				+}
			
 
				+function assertTSImportEqualsDeclaration(node, opts) {
			
 
				+  assert("TSImportEqualsDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSExternalModuleReference(node, opts) {
			
 
				+  assert("TSExternalModuleReference", node, opts);
			
 
				+}
			
 
				+function assertTSNonNullExpression(node, opts) {
			
 
				+  assert("TSNonNullExpression", node, opts);
			
 
				+}
			
 
				+function assertTSExportAssignment(node, opts) {
			
 
				+  assert("TSExportAssignment", node, opts);
			
 
				+}
			
 
				+function assertTSNamespaceExportDeclaration(node, opts) {
			
 
				+  assert("TSNamespaceExportDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSTypeAnnotation(node, opts) {
			
 
				+  assert("TSTypeAnnotation", node, opts);
			
 
				+}
			
 
				+function assertTSTypeParameterInstantiation(node, opts) {
			
 
				+  assert("TSTypeParameterInstantiation", node, opts);
			
 
				+}
			
 
				+function assertTSTypeParameterDeclaration(node, opts) {
			
 
				+  assert("TSTypeParameterDeclaration", node, opts);
			
 
				+}
			
 
				+function assertTSTypeParameter(node, opts) {
			
 
				+  assert("TSTypeParameter", node, opts);
			
 
				+}
			
 
				+function assertStandardized(node, opts) {
			
 
				+  assert("Standardized", node, opts);
			
 
				+}
			
 
				+function assertExpression(node, opts) {
			
 
				+  assert("Expression", node, opts);
			
 
				+}
			
 
				+function assertBinary(node, opts) {
			
 
				+  assert("Binary", node, opts);
			
 
				+}
			
 
				+function assertScopable(node, opts) {
			
 
				+  assert("Scopable", node, opts);
			
 
				+}
			
 
				+function assertBlockParent(node, opts) {
			
 
				+  assert("BlockParent", node, opts);
			
 
				+}
			
 
				+function assertBlock(node, opts) {
			
 
				+  assert("Block", node, opts);
			
 
				+}
			
 
				+function assertStatement(node, opts) {
			
 
				+  assert("Statement", node, opts);
			
 
				+}
			
 
				+function assertTerminatorless(node, opts) {
			
 
				+  assert("Terminatorless", node, opts);
			
 
				+}
			
 
				+function assertCompletionStatement(node, opts) {
			
 
				+  assert("CompletionStatement", node, opts);
			
 
				+}
			
 
				+function assertConditional(node, opts) {
			
 
				+  assert("Conditional", node, opts);
			
 
				+}
			
 
				+function assertLoop(node, opts) {
			
 
				+  assert("Loop", node, opts);
			
 
				+}
			
 
				+function assertWhile(node, opts) {
			
 
				+  assert("While", node, opts);
			
 
				+}
			
 
				+function assertExpressionWrapper(node, opts) {
			
 
				+  assert("ExpressionWrapper", node, opts);
			
 
				+}
			
 
				+function assertFor(node, opts) {
			
 
				+  assert("For", node, opts);
			
 
				+}
			
 
				+function assertForXStatement(node, opts) {
			
 
				+  assert("ForXStatement", node, opts);
			
 
				+}
			
 
				+function assertFunction(node, opts) {
			
 
				+  assert("Function", node, opts);
			
 
				+}
			
 
				+function assertFunctionParent(node, opts) {
			
 
				+  assert("FunctionParent", node, opts);
			
 
				+}
			
 
				+function assertPureish(node, opts) {
			
 
				+  assert("Pureish", node, opts);
			
 
				+}
			
 
				+function assertDeclaration(node, opts) {
			
 
				+  assert("Declaration", node, opts);
			
 
				+}
			
 
				+function assertFunctionParameter(node, opts) {
			
 
				+  assert("FunctionParameter", node, opts);
			
 
				+}
			
 
				+function assertPatternLike(node, opts) {
			
 
				+  assert("PatternLike", node, opts);
			
 
				+}
			
 
				+function assertLVal(node, opts) {
			
 
				+  assert("LVal", node, opts);
			
 
				+}
			
 
				+function assertTSEntityName(node, opts) {
			
 
				+  assert("TSEntityName", node, opts);
			
 
				+}
			
 
				+function assertLiteral(node, opts) {
			
 
				+  assert("Literal", node, opts);
			
 
				+}
			
 
				+function assertImmutable(node, opts) {
			
 
				+  assert("Immutable", node, opts);
			
 
				+}
			
 
				+function assertUserWhitespacable(node, opts) {
			
 
				+  assert("UserWhitespacable", node, opts);
			
 
				+}
			
 
				+function assertMethod(node, opts) {
			
 
				+  assert("Method", node, opts);
			
 
				+}
			
 
				+function assertObjectMember(node, opts) {
			
 
				+  assert("ObjectMember", node, opts);
			
 
				+}
			
 
				+function assertProperty(node, opts) {
			
 
				+  assert("Property", node, opts);
			
 
				+}
			
 
				+function assertUnaryLike(node, opts) {
			
 
				+  assert("UnaryLike", node, opts);
			
 
				+}
			
 
				+function assertPattern(node, opts) {
			
 
				+  assert("Pattern", node, opts);
			
 
				+}
			
 
				+function assertClass(node, opts) {
			
 
				+  assert("Class", node, opts);
			
 
				+}
			
 
				+function assertImportOrExportDeclaration(node, opts) {
			
 
				+  assert("ImportOrExportDeclaration", node, opts);
			
 
				+}
			
 
				+function assertExportDeclaration(node, opts) {
			
 
				+  assert("ExportDeclaration", node, opts);
			
 
				+}
			
 
				+function assertModuleSpecifier(node, opts) {
			
 
				+  assert("ModuleSpecifier", node, opts);
			
 
				+}
			
 
				+function assertAccessor(node, opts) {
			
 
				+  assert("Accessor", node, opts);
			
 
				+}
			
 
				+function assertPrivate(node, opts) {
			
 
				+  assert("Private", node, opts);
			
 
				+}
			
 
				+function assertFlow(node, opts) {
			
 
				+  assert("Flow", node, opts);
			
 
				+}
			
 
				+function assertFlowType(node, opts) {
			
 
				+  assert("FlowType", node, opts);
			
 
				+}
			
 
				+function assertFlowBaseAnnotation(node, opts) {
			
 
				+  assert("FlowBaseAnnotation", node, opts);
			
 
				+}
			
 
				+function assertFlowDeclaration(node, opts) {
			
 
				+  assert("FlowDeclaration", node, opts);
			
 
				+}
			
 
				+function assertFlowPredicate(node, opts) {
			
 
				+  assert("FlowPredicate", node, opts);
			
 
				+}
			
 
				+function assertEnumBody(node, opts) {
			
 
				+  assert("EnumBody", node, opts);
			
 
				+}
			
 
				+function assertEnumMember(node, opts) {
			
 
				+  assert("EnumMember", node, opts);
			
 
				+}
			
 
				+function assertJSX(node, opts) {
			
 
				+  assert("JSX", node, opts);
			
 
				+}
			
 
				+function assertMiscellaneous(node, opts) {
			
 
				+  assert("Miscellaneous", node, opts);
			
 
				+}
			
 
				+function assertTypeScript(node, opts) {
			
 
				+  assert("TypeScript", node, opts);
			
 
				+}
			
 
				+function assertTSTypeElement(node, opts) {
			
 
				+  assert("TSTypeElement", node, opts);
			
 
				+}
			
 
				+function assertTSType(node, opts) {
			
 
				+  assert("TSType", node, opts);
			
 
				+}
			
 
				+function assertTSBaseType(node, opts) {
			
 
				+  assert("TSBaseType", node, opts);
			
 
				+}
			
 
				+function assertNumberLiteral(node, opts) {
			
 
				+  (0, _deprecationWarning.default)("assertNumberLiteral", "assertNumericLiteral");
			
 
				+  assert("NumberLiteral", node, opts);
			
 
				+}
			
 
				+function assertRegexLiteral(node, opts) {
			
 
				+  (0, _deprecationWarning.default)("assertRegexLiteral", "assertRegExpLiteral");
			
 
				+  assert("RegexLiteral", node, opts);
			
 
				+}
			
 
				+function assertRestProperty(node, opts) {
			
 
				+  (0, _deprecationWarning.default)("assertRestProperty", "assertRestElement");
			
 
				+  assert("RestProperty", node, opts);
			
 
				+}
			
 
				+function assertSpreadProperty(node, opts) {
			
 
				+  (0, _deprecationWarning.default)("assertSpreadProperty", "assertSpreadElement");
			
 
				+  assert("SpreadProperty", node, opts);
			
 
				+}
			
 
				+function assertModuleDeclaration(node, opts) {
			
 
				+  (0, _deprecationWarning.default)("assertModuleDeclaration", "assertImportOrExportDeclaration");
			
 
				+  assert("ModuleDeclaration", node, opts);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=index.js.map
			
--- a/ui/node_modules/@babel/types/lib/asserts/generated/index.js.map
+++ b/ui/node_modules/@babel/types/lib/asserts/generated/index.js.map
--- a/ui/node_modules/@babel/types/lib/ast-types/generated/index.js
+++ b/ui/node_modules/@babel/types/lib/ast-types/generated/index.js
@@ -0,0 +1,3 @@
 
				+"use strict";
			
 
				+
			
 
				+//# sourceMappingURL=index.js.map
			
--- a/ui/node_modules/@babel/types/lib/ast-types/generated/index.js.map
+++ b/ui/node_modules/@babel/types/lib/ast-types/generated/index.js.map
--- a/ui/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
+++ b/ui/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js
@@ -0,0 +1,18 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = createFlowUnionType;
			
 
				+var _index = require("../generated/index.js");
			
 
				+var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates.js");
			
 
				+function createFlowUnionType(types) {
			
 
				+  const flattened = (0, _removeTypeDuplicates.default)(types);
			
 
				+  if (flattened.length === 1) {
			
 
				+    return flattened[0];
			
 
				+  } else {
			
 
				+    return (0, _index.unionTypeAnnotation)(flattened);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=createFlowUnionType.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_index","require","_removeTypeDuplicates","createFlowUnionType","types","flattened","removeTypeDuplicates","length","unionTypeAnnotation"],"sources":["../../../src/builders/flow/createFlowUnionType.ts"],"sourcesContent":["import { unionTypeAnnotation } from \"../generated/index.ts\";\nimport removeTypeDuplicates from \"../../modifications/flow/removeTypeDuplicates.ts\";\nimport type * as t from \"../../index.ts\";\n\n/**\n * Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createFlowUnionType<T extends t.FlowType>(\n  types: [T] | T[],\n): T | t.UnionTypeAnnotation {\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0] as T;\n  } else {\n    return unionTypeAnnotation(flattened);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AAOe,SAASE,mBAAmBA,CACzCC,KAAgB,EACW;EAC3B,MAAMC,SAAS,GAAG,IAAAC,6BAAoB,EAACF,KAAK,CAAC;EAE7C,IAAIC,SAAS,CAACE,MAAM,KAAK,CAAC,EAAE;IAC1B,OAAOF,SAAS,CAAC,CAAC,CAAC;EACrB,CAAC,MAAM;IACL,OAAO,IAAAG,0BAAmB,EAACH,SAAS,CAAC;EACvC;AACF","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
+++ b/ui/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js
@@ -0,0 +1,31 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = void 0;
			
 
				+var _index = require("../generated/index.js");
			
 
				+var _default = exports.default = createTypeAnnotationBasedOnTypeof;
			
 
				+function createTypeAnnotationBasedOnTypeof(type) {
			
 
				+  switch (type) {
			
 
				+    case "string":
			
 
				+      return (0, _index.stringTypeAnnotation)();
			
 
				+    case "number":
			
 
				+      return (0, _index.numberTypeAnnotation)();
			
 
				+    case "undefined":
			
 
				+      return (0, _index.voidTypeAnnotation)();
			
 
				+    case "boolean":
			
 
				+      return (0, _index.booleanTypeAnnotation)();
			
 
				+    case "function":
			
 
				+      return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Function"));
			
 
				+    case "object":
			
 
				+      return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Object"));
			
 
				+    case "symbol":
			
 
				+      return (0, _index.genericTypeAnnotation)((0, _index.identifier)("Symbol"));
			
 
				+    case "bigint":
			
 
				+      return (0, _index.anyTypeAnnotation)();
			
 
				+  }
			
 
				+  throw new Error("Invalid typeof value: " + type);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=createTypeAnnotationBasedOnTypeof.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js.map
--- a/ui/node_modules/@babel/types/lib/builders/generated/index.js
+++ b/ui/node_modules/@babel/types/lib/builders/generated/index.js
@@ -0,0 +1,29 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+var _lowercase = require("./lowercase.js");
			
 
				+Object.keys(_lowercase).forEach(function (key) {
			
 
				+  if (key === "default" || key === "__esModule") return;
			
 
				+  if (key in exports && exports[key] === _lowercase[key]) return;
			
 
				+  Object.defineProperty(exports, key, {
			
 
				+    enumerable: true,
			
 
				+    get: function () {
			
 
				+      return _lowercase[key];
			
 
				+    }
			
 
				+  });
			
 
				+});
			
 
				+var _uppercase = require("./uppercase.js");
			
 
				+Object.keys(_uppercase).forEach(function (key) {
			
 
				+  if (key === "default" || key === "__esModule") return;
			
 
				+  if (key in exports && exports[key] === _uppercase[key]) return;
			
 
				+  Object.defineProperty(exports, key, {
			
 
				+    enumerable: true,
			
 
				+    get: function () {
			
 
				+      return _uppercase[key];
			
 
				+    }
			
 
				+  });
			
 
				+});
			
 
				+
			
 
				+//# sourceMappingURL=index.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/generated/index.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/generated/index.js.map
--- a/ui/node_modules/@babel/types/lib/builders/generated/lowercase.js
+++ b/ui/node_modules/@babel/types/lib/builders/generated/lowercase.js
@@ -0,0 +1,2902 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.anyTypeAnnotation = anyTypeAnnotation;
			
 
				+exports.argumentPlaceholder = argumentPlaceholder;
			
 
				+exports.arrayExpression = arrayExpression;
			
 
				+exports.arrayPattern = arrayPattern;
			
 
				+exports.arrayTypeAnnotation = arrayTypeAnnotation;
			
 
				+exports.arrowFunctionExpression = arrowFunctionExpression;
			
 
				+exports.assignmentExpression = assignmentExpression;
			
 
				+exports.assignmentPattern = assignmentPattern;
			
 
				+exports.awaitExpression = awaitExpression;
			
 
				+exports.bigIntLiteral = bigIntLiteral;
			
 
				+exports.binaryExpression = binaryExpression;
			
 
				+exports.bindExpression = bindExpression;
			
 
				+exports.blockStatement = blockStatement;
			
 
				+exports.booleanLiteral = booleanLiteral;
			
 
				+exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
			
 
				+exports.booleanTypeAnnotation = booleanTypeAnnotation;
			
 
				+exports.breakStatement = breakStatement;
			
 
				+exports.callExpression = callExpression;
			
 
				+exports.catchClause = catchClause;
			
 
				+exports.classAccessorProperty = classAccessorProperty;
			
 
				+exports.classBody = classBody;
			
 
				+exports.classDeclaration = classDeclaration;
			
 
				+exports.classExpression = classExpression;
			
 
				+exports.classImplements = classImplements;
			
 
				+exports.classMethod = classMethod;
			
 
				+exports.classPrivateMethod = classPrivateMethod;
			
 
				+exports.classPrivateProperty = classPrivateProperty;
			
 
				+exports.classProperty = classProperty;
			
 
				+exports.conditionalExpression = conditionalExpression;
			
 
				+exports.continueStatement = continueStatement;
			
 
				+exports.debuggerStatement = debuggerStatement;
			
 
				+exports.decimalLiteral = decimalLiteral;
			
 
				+exports.declareClass = declareClass;
			
 
				+exports.declareExportAllDeclaration = declareExportAllDeclaration;
			
 
				+exports.declareExportDeclaration = declareExportDeclaration;
			
 
				+exports.declareFunction = declareFunction;
			
 
				+exports.declareInterface = declareInterface;
			
 
				+exports.declareModule = declareModule;
			
 
				+exports.declareModuleExports = declareModuleExports;
			
 
				+exports.declareOpaqueType = declareOpaqueType;
			
 
				+exports.declareTypeAlias = declareTypeAlias;
			
 
				+exports.declareVariable = declareVariable;
			
 
				+exports.declaredPredicate = declaredPredicate;
			
 
				+exports.decorator = decorator;
			
 
				+exports.directive = directive;
			
 
				+exports.directiveLiteral = directiveLiteral;
			
 
				+exports.doExpression = doExpression;
			
 
				+exports.doWhileStatement = doWhileStatement;
			
 
				+exports.emptyStatement = emptyStatement;
			
 
				+exports.emptyTypeAnnotation = emptyTypeAnnotation;
			
 
				+exports.enumBooleanBody = enumBooleanBody;
			
 
				+exports.enumBooleanMember = enumBooleanMember;
			
 
				+exports.enumDeclaration = enumDeclaration;
			
 
				+exports.enumDefaultedMember = enumDefaultedMember;
			
 
				+exports.enumNumberBody = enumNumberBody;
			
 
				+exports.enumNumberMember = enumNumberMember;
			
 
				+exports.enumStringBody = enumStringBody;
			
 
				+exports.enumStringMember = enumStringMember;
			
 
				+exports.enumSymbolBody = enumSymbolBody;
			
 
				+exports.existsTypeAnnotation = existsTypeAnnotation;
			
 
				+exports.exportAllDeclaration = exportAllDeclaration;
			
 
				+exports.exportDefaultDeclaration = exportDefaultDeclaration;
			
 
				+exports.exportDefaultSpecifier = exportDefaultSpecifier;
			
 
				+exports.exportNamedDeclaration = exportNamedDeclaration;
			
 
				+exports.exportNamespaceSpecifier = exportNamespaceSpecifier;
			
 
				+exports.exportSpecifier = exportSpecifier;
			
 
				+exports.expressionStatement = expressionStatement;
			
 
				+exports.file = file;
			
 
				+exports.forInStatement = forInStatement;
			
 
				+exports.forOfStatement = forOfStatement;
			
 
				+exports.forStatement = forStatement;
			
 
				+exports.functionDeclaration = functionDeclaration;
			
 
				+exports.functionExpression = functionExpression;
			
 
				+exports.functionTypeAnnotation = functionTypeAnnotation;
			
 
				+exports.functionTypeParam = functionTypeParam;
			
 
				+exports.genericTypeAnnotation = genericTypeAnnotation;
			
 
				+exports.identifier = identifier;
			
 
				+exports.ifStatement = ifStatement;
			
 
				+exports.import = _import;
			
 
				+exports.importAttribute = importAttribute;
			
 
				+exports.importDeclaration = importDeclaration;
			
 
				+exports.importDefaultSpecifier = importDefaultSpecifier;
			
 
				+exports.importExpression = importExpression;
			
 
				+exports.importNamespaceSpecifier = importNamespaceSpecifier;
			
 
				+exports.importSpecifier = importSpecifier;
			
 
				+exports.indexedAccessType = indexedAccessType;
			
 
				+exports.inferredPredicate = inferredPredicate;
			
 
				+exports.interfaceDeclaration = interfaceDeclaration;
			
 
				+exports.interfaceExtends = interfaceExtends;
			
 
				+exports.interfaceTypeAnnotation = interfaceTypeAnnotation;
			
 
				+exports.interpreterDirective = interpreterDirective;
			
 
				+exports.intersectionTypeAnnotation = intersectionTypeAnnotation;
			
 
				+exports.jSXAttribute = exports.jsxAttribute = jsxAttribute;
			
 
				+exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;
			
 
				+exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;
			
 
				+exports.jSXElement = exports.jsxElement = jsxElement;
			
 
				+exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;
			
 
				+exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;
			
 
				+exports.jSXFragment = exports.jsxFragment = jsxFragment;
			
 
				+exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier;
			
 
				+exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;
			
 
				+exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;
			
 
				+exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;
			
 
				+exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;
			
 
				+exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;
			
 
				+exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;
			
 
				+exports.jSXText = exports.jsxText = jsxText;
			
 
				+exports.labeledStatement = labeledStatement;
			
 
				+exports.logicalExpression = logicalExpression;
			
 
				+exports.memberExpression = memberExpression;
			
 
				+exports.metaProperty = metaProperty;
			
 
				+exports.mixedTypeAnnotation = mixedTypeAnnotation;
			
 
				+exports.moduleExpression = moduleExpression;
			
 
				+exports.newExpression = newExpression;
			
 
				+exports.noop = noop;
			
 
				+exports.nullLiteral = nullLiteral;
			
 
				+exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
			
 
				+exports.nullableTypeAnnotation = nullableTypeAnnotation;
			
 
				+exports.numberLiteral = NumberLiteral;
			
 
				+exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
			
 
				+exports.numberTypeAnnotation = numberTypeAnnotation;
			
 
				+exports.numericLiteral = numericLiteral;
			
 
				+exports.objectExpression = objectExpression;
			
 
				+exports.objectMethod = objectMethod;
			
 
				+exports.objectPattern = objectPattern;
			
 
				+exports.objectProperty = objectProperty;
			
 
				+exports.objectTypeAnnotation = objectTypeAnnotation;
			
 
				+exports.objectTypeCallProperty = objectTypeCallProperty;
			
 
				+exports.objectTypeIndexer = objectTypeIndexer;
			
 
				+exports.objectTypeInternalSlot = objectTypeInternalSlot;
			
 
				+exports.objectTypeProperty = objectTypeProperty;
			
 
				+exports.objectTypeSpreadProperty = objectTypeSpreadProperty;
			
 
				+exports.opaqueType = opaqueType;
			
 
				+exports.optionalCallExpression = optionalCallExpression;
			
 
				+exports.optionalIndexedAccessType = optionalIndexedAccessType;
			
 
				+exports.optionalMemberExpression = optionalMemberExpression;
			
 
				+exports.parenthesizedExpression = parenthesizedExpression;
			
 
				+exports.pipelineBareFunction = pipelineBareFunction;
			
 
				+exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
			
 
				+exports.pipelineTopicExpression = pipelineTopicExpression;
			
 
				+exports.placeholder = placeholder;
			
 
				+exports.privateName = privateName;
			
 
				+exports.program = program;
			
 
				+exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
			
 
				+exports.recordExpression = recordExpression;
			
 
				+exports.regExpLiteral = regExpLiteral;
			
 
				+exports.regexLiteral = RegexLiteral;
			
 
				+exports.restElement = restElement;
			
 
				+exports.restProperty = RestProperty;
			
 
				+exports.returnStatement = returnStatement;
			
 
				+exports.sequenceExpression = sequenceExpression;
			
 
				+exports.spreadElement = spreadElement;
			
 
				+exports.spreadProperty = SpreadProperty;
			
 
				+exports.staticBlock = staticBlock;
			
 
				+exports.stringLiteral = stringLiteral;
			
 
				+exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
			
 
				+exports.stringTypeAnnotation = stringTypeAnnotation;
			
 
				+exports.super = _super;
			
 
				+exports.switchCase = switchCase;
			
 
				+exports.switchStatement = switchStatement;
			
 
				+exports.symbolTypeAnnotation = symbolTypeAnnotation;
			
 
				+exports.taggedTemplateExpression = taggedTemplateExpression;
			
 
				+exports.templateElement = templateElement;
			
 
				+exports.templateLiteral = templateLiteral;
			
 
				+exports.thisExpression = thisExpression;
			
 
				+exports.thisTypeAnnotation = thisTypeAnnotation;
			
 
				+exports.throwStatement = throwStatement;
			
 
				+exports.topicReference = topicReference;
			
 
				+exports.tryStatement = tryStatement;
			
 
				+exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;
			
 
				+exports.tSArrayType = exports.tsArrayType = tsArrayType;
			
 
				+exports.tSAsExpression = exports.tsAsExpression = tsAsExpression;
			
 
				+exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;
			
 
				+exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;
			
 
				+exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
			
 
				+exports.tSConditionalType = exports.tsConditionalType = tsConditionalType;
			
 
				+exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
			
 
				+exports.tSConstructorType = exports.tsConstructorType = tsConstructorType;
			
 
				+exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;
			
 
				+exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;
			
 
				+exports.tSEnumBody = exports.tsEnumBody = tsEnumBody;
			
 
				+exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;
			
 
				+exports.tSEnumMember = exports.tsEnumMember = tsEnumMember;
			
 
				+exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;
			
 
				+exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
			
 
				+exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;
			
 
				+exports.tSFunctionType = exports.tsFunctionType = tsFunctionType;
			
 
				+exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
			
 
				+exports.tSImportType = exports.tsImportType = tsImportType;
			
 
				+exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;
			
 
				+exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;
			
 
				+exports.tSInferType = exports.tsInferType = tsInferType;
			
 
				+exports.tSInstantiationExpression = exports.tsInstantiationExpression = tsInstantiationExpression;
			
 
				+exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;
			
 
				+exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;
			
 
				+exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;
			
 
				+exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;
			
 
				+exports.tSLiteralType = exports.tsLiteralType = tsLiteralType;
			
 
				+exports.tSMappedType = exports.tsMappedType = tsMappedType;
			
 
				+exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;
			
 
				+exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;
			
 
				+exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;
			
 
				+exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;
			
 
				+exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
			
 
				+exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;
			
 
				+exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;
			
 
				+exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;
			
 
				+exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;
			
 
				+exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;
			
 
				+exports.tSOptionalType = exports.tsOptionalType = tsOptionalType;
			
 
				+exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;
			
 
				+exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;
			
 
				+exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;
			
 
				+exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;
			
 
				+exports.tSRestType = exports.tsRestType = tsRestType;
			
 
				+exports.tSSatisfiesExpression = exports.tsSatisfiesExpression = tsSatisfiesExpression;
			
 
				+exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;
			
 
				+exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;
			
 
				+exports.tSTemplateLiteralType = exports.tsTemplateLiteralType = tsTemplateLiteralType;
			
 
				+exports.tSThisType = exports.tsThisType = tsThisType;
			
 
				+exports.tSTupleType = exports.tsTupleType = tsTupleType;
			
 
				+exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
			
 
				+exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;
			
 
				+exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;
			
 
				+exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;
			
 
				+exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;
			
 
				+exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;
			
 
				+exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
			
 
				+exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
			
 
				+exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;
			
 
				+exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;
			
 
				+exports.tSTypeReference = exports.tsTypeReference = tsTypeReference;
			
 
				+exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;
			
 
				+exports.tSUnionType = exports.tsUnionType = tsUnionType;
			
 
				+exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;
			
 
				+exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;
			
 
				+exports.tupleExpression = tupleExpression;
			
 
				+exports.tupleTypeAnnotation = tupleTypeAnnotation;
			
 
				+exports.typeAlias = typeAlias;
			
 
				+exports.typeAnnotation = typeAnnotation;
			
 
				+exports.typeCastExpression = typeCastExpression;
			
 
				+exports.typeParameter = typeParameter;
			
 
				+exports.typeParameterDeclaration = typeParameterDeclaration;
			
 
				+exports.typeParameterInstantiation = typeParameterInstantiation;
			
 
				+exports.typeofTypeAnnotation = typeofTypeAnnotation;
			
 
				+exports.unaryExpression = unaryExpression;
			
 
				+exports.unionTypeAnnotation = unionTypeAnnotation;
			
 
				+exports.updateExpression = updateExpression;
			
 
				+exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
			
 
				+exports.variableDeclaration = variableDeclaration;
			
 
				+exports.variableDeclarator = variableDeclarator;
			
 
				+exports.variance = variance;
			
 
				+exports.voidPattern = voidPattern;
			
 
				+exports.voidTypeAnnotation = voidTypeAnnotation;
			
 
				+exports.whileStatement = whileStatement;
			
 
				+exports.withStatement = withStatement;
			
 
				+exports.yieldExpression = yieldExpression;
			
 
				+var _validate = require("../../validators/validate.js");
			
 
				+var _deprecationWarning = require("../../utils/deprecationWarning.js");
			
 
				+var utils = require("../../definitions/utils.js");
			
 
				+const {
			
 
				+  validateInternal: validate
			
 
				+} = _validate;
			
 
				+const {
			
 
				+  NODE_FIELDS
			
 
				+} = utils;
			
 
				+function bigIntLiteral(value) {
			
 
				+  if (typeof value === "bigint") {
			
 
				+    value = value.toString();
			
 
				+  }
			
 
				+  const node = {
			
 
				+    type: "BigIntLiteral",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.BigIntLiteral;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function arrayExpression(elements = []) {
			
 
				+  const node = {
			
 
				+    type: "ArrayExpression",
			
 
				+    elements
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ArrayExpression;
			
 
				+  validate(defs.elements, node, "elements", elements, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function assignmentExpression(operator, left, right) {
			
 
				+  const node = {
			
 
				+    type: "AssignmentExpression",
			
 
				+    operator,
			
 
				+    left,
			
 
				+    right
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.AssignmentExpression;
			
 
				+  validate(defs.operator, node, "operator", operator);
			
 
				+  validate(defs.left, node, "left", left, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function binaryExpression(operator, left, right) {
			
 
				+  const node = {
			
 
				+    type: "BinaryExpression",
			
 
				+    operator,
			
 
				+    left,
			
 
				+    right
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.BinaryExpression;
			
 
				+  validate(defs.operator, node, "operator", operator);
			
 
				+  validate(defs.left, node, "left", left, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function interpreterDirective(value) {
			
 
				+  const node = {
			
 
				+    type: "InterpreterDirective",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.InterpreterDirective;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function directive(value) {
			
 
				+  const node = {
			
 
				+    type: "Directive",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.Directive;
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function directiveLiteral(value) {
			
 
				+  const node = {
			
 
				+    type: "DirectiveLiteral",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DirectiveLiteral;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function blockStatement(body, directives = []) {
			
 
				+  const node = {
			
 
				+    type: "BlockStatement",
			
 
				+    body,
			
 
				+    directives
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.BlockStatement;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.directives, node, "directives", directives, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function breakStatement(label = null) {
			
 
				+  const node = {
			
 
				+    type: "BreakStatement",
			
 
				+    label
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.BreakStatement;
			
 
				+  validate(defs.label, node, "label", label, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function callExpression(callee, _arguments) {
			
 
				+  const node = {
			
 
				+    type: "CallExpression",
			
 
				+    callee,
			
 
				+    arguments: _arguments
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.CallExpression;
			
 
				+  validate(defs.callee, node, "callee", callee, 1);
			
 
				+  validate(defs.arguments, node, "arguments", _arguments, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function catchClause(param = null, body) {
			
 
				+  const node = {
			
 
				+    type: "CatchClause",
			
 
				+    param,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.CatchClause;
			
 
				+  validate(defs.param, node, "param", param, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function conditionalExpression(test, consequent, alternate) {
			
 
				+  const node = {
			
 
				+    type: "ConditionalExpression",
			
 
				+    test,
			
 
				+    consequent,
			
 
				+    alternate
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ConditionalExpression;
			
 
				+  validate(defs.test, node, "test", test, 1);
			
 
				+  validate(defs.consequent, node, "consequent", consequent, 1);
			
 
				+  validate(defs.alternate, node, "alternate", alternate, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function continueStatement(label = null) {
			
 
				+  const node = {
			
 
				+    type: "ContinueStatement",
			
 
				+    label
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ContinueStatement;
			
 
				+  validate(defs.label, node, "label", label, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function debuggerStatement() {
			
 
				+  return {
			
 
				+    type: "DebuggerStatement"
			
 
				+  };
			
 
				+}
			
 
				+function doWhileStatement(test, body) {
			
 
				+  const node = {
			
 
				+    type: "DoWhileStatement",
			
 
				+    test,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DoWhileStatement;
			
 
				+  validate(defs.test, node, "test", test, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function emptyStatement() {
			
 
				+  return {
			
 
				+    type: "EmptyStatement"
			
 
				+  };
			
 
				+}
			
 
				+function expressionStatement(expression) {
			
 
				+  const node = {
			
 
				+    type: "ExpressionStatement",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ExpressionStatement;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function file(program, comments = null, tokens = null) {
			
 
				+  const node = {
			
 
				+    type: "File",
			
 
				+    program,
			
 
				+    comments,
			
 
				+    tokens
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.File;
			
 
				+  validate(defs.program, node, "program", program, 1);
			
 
				+  validate(defs.comments, node, "comments", comments, 1);
			
 
				+  validate(defs.tokens, node, "tokens", tokens);
			
 
				+  return node;
			
 
				+}
			
 
				+function forInStatement(left, right, body) {
			
 
				+  const node = {
			
 
				+    type: "ForInStatement",
			
 
				+    left,
			
 
				+    right,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ForInStatement;
			
 
				+  validate(defs.left, node, "left", left, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function forStatement(init = null, test = null, update = null, body) {
			
 
				+  const node = {
			
 
				+    type: "ForStatement",
			
 
				+    init,
			
 
				+    test,
			
 
				+    update,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ForStatement;
			
 
				+  validate(defs.init, node, "init", init, 1);
			
 
				+  validate(defs.test, node, "test", test, 1);
			
 
				+  validate(defs.update, node, "update", update, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function functionDeclaration(id = null, params, body, generator = false, async = false) {
			
 
				+  const node = {
			
 
				+    type: "FunctionDeclaration",
			
 
				+    id,
			
 
				+    params,
			
 
				+    body,
			
 
				+    generator,
			
 
				+    async
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.FunctionDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.generator, node, "generator", generator);
			
 
				+  validate(defs.async, node, "async", async);
			
 
				+  return node;
			
 
				+}
			
 
				+function functionExpression(id = null, params, body, generator = false, async = false) {
			
 
				+  const node = {
			
 
				+    type: "FunctionExpression",
			
 
				+    id,
			
 
				+    params,
			
 
				+    body,
			
 
				+    generator,
			
 
				+    async
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.FunctionExpression;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.generator, node, "generator", generator);
			
 
				+  validate(defs.async, node, "async", async);
			
 
				+  return node;
			
 
				+}
			
 
				+function identifier(name) {
			
 
				+  const node = {
			
 
				+    type: "Identifier",
			
 
				+    name
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.Identifier;
			
 
				+  validate(defs.name, node, "name", name);
			
 
				+  return node;
			
 
				+}
			
 
				+function ifStatement(test, consequent, alternate = null) {
			
 
				+  const node = {
			
 
				+    type: "IfStatement",
			
 
				+    test,
			
 
				+    consequent,
			
 
				+    alternate
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.IfStatement;
			
 
				+  validate(defs.test, node, "test", test, 1);
			
 
				+  validate(defs.consequent, node, "consequent", consequent, 1);
			
 
				+  validate(defs.alternate, node, "alternate", alternate, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function labeledStatement(label, body) {
			
 
				+  const node = {
			
 
				+    type: "LabeledStatement",
			
 
				+    label,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.LabeledStatement;
			
 
				+  validate(defs.label, node, "label", label, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function stringLiteral(value) {
			
 
				+  const node = {
			
 
				+    type: "StringLiteral",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.StringLiteral;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function numericLiteral(value) {
			
 
				+  const node = {
			
 
				+    type: "NumericLiteral",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.NumericLiteral;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function nullLiteral() {
			
 
				+  return {
			
 
				+    type: "NullLiteral"
			
 
				+  };
			
 
				+}
			
 
				+function booleanLiteral(value) {
			
 
				+  const node = {
			
 
				+    type: "BooleanLiteral",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.BooleanLiteral;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function regExpLiteral(pattern, flags = "") {
			
 
				+  const node = {
			
 
				+    type: "RegExpLiteral",
			
 
				+    pattern,
			
 
				+    flags
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.RegExpLiteral;
			
 
				+  validate(defs.pattern, node, "pattern", pattern);
			
 
				+  validate(defs.flags, node, "flags", flags);
			
 
				+  return node;
			
 
				+}
			
 
				+function logicalExpression(operator, left, right) {
			
 
				+  const node = {
			
 
				+    type: "LogicalExpression",
			
 
				+    operator,
			
 
				+    left,
			
 
				+    right
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.LogicalExpression;
			
 
				+  validate(defs.operator, node, "operator", operator);
			
 
				+  validate(defs.left, node, "left", left, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function memberExpression(object, property, computed = false, optional = null) {
			
 
				+  const node = {
			
 
				+    type: "MemberExpression",
			
 
				+    object,
			
 
				+    property,
			
 
				+    computed,
			
 
				+    optional
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.MemberExpression;
			
 
				+  validate(defs.object, node, "object", object, 1);
			
 
				+  validate(defs.property, node, "property", property, 1);
			
 
				+  validate(defs.computed, node, "computed", computed);
			
 
				+  validate(defs.optional, node, "optional", optional);
			
 
				+  return node;
			
 
				+}
			
 
				+function newExpression(callee, _arguments) {
			
 
				+  const node = {
			
 
				+    type: "NewExpression",
			
 
				+    callee,
			
 
				+    arguments: _arguments
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.NewExpression;
			
 
				+  validate(defs.callee, node, "callee", callee, 1);
			
 
				+  validate(defs.arguments, node, "arguments", _arguments, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function program(body, directives = [], sourceType = "script", interpreter = null) {
			
 
				+  const node = {
			
 
				+    type: "Program",
			
 
				+    body,
			
 
				+    directives,
			
 
				+    sourceType,
			
 
				+    interpreter
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.Program;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.directives, node, "directives", directives, 1);
			
 
				+  validate(defs.sourceType, node, "sourceType", sourceType);
			
 
				+  validate(defs.interpreter, node, "interpreter", interpreter, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectExpression(properties) {
			
 
				+  const node = {
			
 
				+    type: "ObjectExpression",
			
 
				+    properties
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectExpression;
			
 
				+  validate(defs.properties, node, "properties", properties, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectMethod(kind = "method", key, params, body, computed = false, generator = false, async = false) {
			
 
				+  const node = {
			
 
				+    type: "ObjectMethod",
			
 
				+    kind,
			
 
				+    key,
			
 
				+    params,
			
 
				+    body,
			
 
				+    computed,
			
 
				+    generator,
			
 
				+    async
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectMethod;
			
 
				+  validate(defs.kind, node, "kind", kind);
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.computed, node, "computed", computed);
			
 
				+  validate(defs.generator, node, "generator", generator);
			
 
				+  validate(defs.async, node, "async", async);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectProperty(key, value, computed = false, shorthand = false, decorators = null) {
			
 
				+  const node = {
			
 
				+    type: "ObjectProperty",
			
 
				+    key,
			
 
				+    value,
			
 
				+    computed,
			
 
				+    shorthand,
			
 
				+    decorators
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectProperty;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  validate(defs.computed, node, "computed", computed);
			
 
				+  validate(defs.shorthand, node, "shorthand", shorthand);
			
 
				+  validate(defs.decorators, node, "decorators", decorators, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function restElement(argument) {
			
 
				+  const node = {
			
 
				+    type: "RestElement",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.RestElement;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function returnStatement(argument = null) {
			
 
				+  const node = {
			
 
				+    type: "ReturnStatement",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ReturnStatement;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function sequenceExpression(expressions) {
			
 
				+  const node = {
			
 
				+    type: "SequenceExpression",
			
 
				+    expressions
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.SequenceExpression;
			
 
				+  validate(defs.expressions, node, "expressions", expressions, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function parenthesizedExpression(expression) {
			
 
				+  const node = {
			
 
				+    type: "ParenthesizedExpression",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ParenthesizedExpression;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function switchCase(test = null, consequent) {
			
 
				+  const node = {
			
 
				+    type: "SwitchCase",
			
 
				+    test,
			
 
				+    consequent
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.SwitchCase;
			
 
				+  validate(defs.test, node, "test", test, 1);
			
 
				+  validate(defs.consequent, node, "consequent", consequent, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function switchStatement(discriminant, cases) {
			
 
				+  const node = {
			
 
				+    type: "SwitchStatement",
			
 
				+    discriminant,
			
 
				+    cases
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.SwitchStatement;
			
 
				+  validate(defs.discriminant, node, "discriminant", discriminant, 1);
			
 
				+  validate(defs.cases, node, "cases", cases, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function thisExpression() {
			
 
				+  return {
			
 
				+    type: "ThisExpression"
			
 
				+  };
			
 
				+}
			
 
				+function throwStatement(argument) {
			
 
				+  const node = {
			
 
				+    type: "ThrowStatement",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ThrowStatement;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tryStatement(block, handler = null, finalizer = null) {
			
 
				+  const node = {
			
 
				+    type: "TryStatement",
			
 
				+    block,
			
 
				+    handler,
			
 
				+    finalizer
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TryStatement;
			
 
				+  validate(defs.block, node, "block", block, 1);
			
 
				+  validate(defs.handler, node, "handler", handler, 1);
			
 
				+  validate(defs.finalizer, node, "finalizer", finalizer, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function unaryExpression(operator, argument, prefix = true) {
			
 
				+  const node = {
			
 
				+    type: "UnaryExpression",
			
 
				+    operator,
			
 
				+    argument,
			
 
				+    prefix
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.UnaryExpression;
			
 
				+  validate(defs.operator, node, "operator", operator);
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  validate(defs.prefix, node, "prefix", prefix);
			
 
				+  return node;
			
 
				+}
			
 
				+function updateExpression(operator, argument, prefix = false) {
			
 
				+  const node = {
			
 
				+    type: "UpdateExpression",
			
 
				+    operator,
			
 
				+    argument,
			
 
				+    prefix
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.UpdateExpression;
			
 
				+  validate(defs.operator, node, "operator", operator);
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  validate(defs.prefix, node, "prefix", prefix);
			
 
				+  return node;
			
 
				+}
			
 
				+function variableDeclaration(kind, declarations) {
			
 
				+  const node = {
			
 
				+    type: "VariableDeclaration",
			
 
				+    kind,
			
 
				+    declarations
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.VariableDeclaration;
			
 
				+  validate(defs.kind, node, "kind", kind);
			
 
				+  validate(defs.declarations, node, "declarations", declarations, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function variableDeclarator(id, init = null) {
			
 
				+  const node = {
			
 
				+    type: "VariableDeclarator",
			
 
				+    id,
			
 
				+    init
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.VariableDeclarator;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.init, node, "init", init, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function whileStatement(test, body) {
			
 
				+  const node = {
			
 
				+    type: "WhileStatement",
			
 
				+    test,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.WhileStatement;
			
 
				+  validate(defs.test, node, "test", test, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function withStatement(object, body) {
			
 
				+  const node = {
			
 
				+    type: "WithStatement",
			
 
				+    object,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.WithStatement;
			
 
				+  validate(defs.object, node, "object", object, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function assignmentPattern(left, right) {
			
 
				+  const node = {
			
 
				+    type: "AssignmentPattern",
			
 
				+    left,
			
 
				+    right
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.AssignmentPattern;
			
 
				+  validate(defs.left, node, "left", left, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function arrayPattern(elements) {
			
 
				+  const node = {
			
 
				+    type: "ArrayPattern",
			
 
				+    elements
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ArrayPattern;
			
 
				+  validate(defs.elements, node, "elements", elements, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function arrowFunctionExpression(params, body, async = false) {
			
 
				+  const node = {
			
 
				+    type: "ArrowFunctionExpression",
			
 
				+    params,
			
 
				+    body,
			
 
				+    async,
			
 
				+    expression: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ArrowFunctionExpression;
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.async, node, "async", async);
			
 
				+  return node;
			
 
				+}
			
 
				+function classBody(body) {
			
 
				+  const node = {
			
 
				+    type: "ClassBody",
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassBody;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function classExpression(id = null, superClass = null, body, decorators = null) {
			
 
				+  const node = {
			
 
				+    type: "ClassExpression",
			
 
				+    id,
			
 
				+    superClass,
			
 
				+    body,
			
 
				+    decorators
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassExpression;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.superClass, node, "superClass", superClass, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.decorators, node, "decorators", decorators, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function classDeclaration(id = null, superClass = null, body, decorators = null) {
			
 
				+  const node = {
			
 
				+    type: "ClassDeclaration",
			
 
				+    id,
			
 
				+    superClass,
			
 
				+    body,
			
 
				+    decorators
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.superClass, node, "superClass", superClass, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.decorators, node, "decorators", decorators, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function exportAllDeclaration(source, attributes = null) {
			
 
				+  const node = {
			
 
				+    type: "ExportAllDeclaration",
			
 
				+    source,
			
 
				+    attributes
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ExportAllDeclaration;
			
 
				+  validate(defs.source, node, "source", source, 1);
			
 
				+  validate(defs.attributes, node, "attributes", attributes, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function exportDefaultDeclaration(declaration) {
			
 
				+  const node = {
			
 
				+    type: "ExportDefaultDeclaration",
			
 
				+    declaration
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ExportDefaultDeclaration;
			
 
				+  validate(defs.declaration, node, "declaration", declaration, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function exportNamedDeclaration(declaration = null, specifiers = [], source = null, attributes = null) {
			
 
				+  const node = {
			
 
				+    type: "ExportNamedDeclaration",
			
 
				+    declaration,
			
 
				+    specifiers,
			
 
				+    source,
			
 
				+    attributes
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ExportNamedDeclaration;
			
 
				+  validate(defs.declaration, node, "declaration", declaration, 1);
			
 
				+  validate(defs.specifiers, node, "specifiers", specifiers, 1);
			
 
				+  validate(defs.source, node, "source", source, 1);
			
 
				+  validate(defs.attributes, node, "attributes", attributes, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function exportSpecifier(local, exported) {
			
 
				+  const node = {
			
 
				+    type: "ExportSpecifier",
			
 
				+    local,
			
 
				+    exported
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ExportSpecifier;
			
 
				+  validate(defs.local, node, "local", local, 1);
			
 
				+  validate(defs.exported, node, "exported", exported, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function forOfStatement(left, right, body, _await = false) {
			
 
				+  const node = {
			
 
				+    type: "ForOfStatement",
			
 
				+    left,
			
 
				+    right,
			
 
				+    body,
			
 
				+    await: _await
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ForOfStatement;
			
 
				+  validate(defs.left, node, "left", left, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.await, node, "await", _await);
			
 
				+  return node;
			
 
				+}
			
 
				+function importDeclaration(specifiers, source, attributes = null) {
			
 
				+  const node = {
			
 
				+    type: "ImportDeclaration",
			
 
				+    specifiers,
			
 
				+    source,
			
 
				+    attributes
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ImportDeclaration;
			
 
				+  validate(defs.specifiers, node, "specifiers", specifiers, 1);
			
 
				+  validate(defs.source, node, "source", source, 1);
			
 
				+  validate(defs.attributes, node, "attributes", attributes, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function importDefaultSpecifier(local) {
			
 
				+  const node = {
			
 
				+    type: "ImportDefaultSpecifier",
			
 
				+    local
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ImportDefaultSpecifier;
			
 
				+  validate(defs.local, node, "local", local, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function importNamespaceSpecifier(local) {
			
 
				+  const node = {
			
 
				+    type: "ImportNamespaceSpecifier",
			
 
				+    local
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ImportNamespaceSpecifier;
			
 
				+  validate(defs.local, node, "local", local, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function importSpecifier(local, imported) {
			
 
				+  const node = {
			
 
				+    type: "ImportSpecifier",
			
 
				+    local,
			
 
				+    imported
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ImportSpecifier;
			
 
				+  validate(defs.local, node, "local", local, 1);
			
 
				+  validate(defs.imported, node, "imported", imported, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function importExpression(source, options = null) {
			
 
				+  const node = {
			
 
				+    type: "ImportExpression",
			
 
				+    source,
			
 
				+    options
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ImportExpression;
			
 
				+  validate(defs.source, node, "source", source, 1);
			
 
				+  validate(defs.options, node, "options", options, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function metaProperty(meta, property) {
			
 
				+  const node = {
			
 
				+    type: "MetaProperty",
			
 
				+    meta,
			
 
				+    property
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.MetaProperty;
			
 
				+  validate(defs.meta, node, "meta", meta, 1);
			
 
				+  validate(defs.property, node, "property", property, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function classMethod(kind = "method", key, params, body, computed = false, _static = false, generator = false, async = false) {
			
 
				+  const node = {
			
 
				+    type: "ClassMethod",
			
 
				+    kind,
			
 
				+    key,
			
 
				+    params,
			
 
				+    body,
			
 
				+    computed,
			
 
				+    static: _static,
			
 
				+    generator,
			
 
				+    async
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassMethod;
			
 
				+  validate(defs.kind, node, "kind", kind);
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.computed, node, "computed", computed);
			
 
				+  validate(defs.static, node, "static", _static);
			
 
				+  validate(defs.generator, node, "generator", generator);
			
 
				+  validate(defs.async, node, "async", async);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectPattern(properties) {
			
 
				+  const node = {
			
 
				+    type: "ObjectPattern",
			
 
				+    properties
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectPattern;
			
 
				+  validate(defs.properties, node, "properties", properties, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function spreadElement(argument) {
			
 
				+  const node = {
			
 
				+    type: "SpreadElement",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.SpreadElement;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function _super() {
			
 
				+  return {
			
 
				+    type: "Super"
			
 
				+  };
			
 
				+}
			
 
				+function taggedTemplateExpression(tag, quasi) {
			
 
				+  const node = {
			
 
				+    type: "TaggedTemplateExpression",
			
 
				+    tag,
			
 
				+    quasi
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TaggedTemplateExpression;
			
 
				+  validate(defs.tag, node, "tag", tag, 1);
			
 
				+  validate(defs.quasi, node, "quasi", quasi, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function templateElement(value, tail = false) {
			
 
				+  const node = {
			
 
				+    type: "TemplateElement",
			
 
				+    value,
			
 
				+    tail
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TemplateElement;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  validate(defs.tail, node, "tail", tail);
			
 
				+  return node;
			
 
				+}
			
 
				+function templateLiteral(quasis, expressions) {
			
 
				+  const node = {
			
 
				+    type: "TemplateLiteral",
			
 
				+    quasis,
			
 
				+    expressions
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TemplateLiteral;
			
 
				+  validate(defs.quasis, node, "quasis", quasis, 1);
			
 
				+  validate(defs.expressions, node, "expressions", expressions, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function yieldExpression(argument = null, delegate = false) {
			
 
				+  const node = {
			
 
				+    type: "YieldExpression",
			
 
				+    argument,
			
 
				+    delegate
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.YieldExpression;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  validate(defs.delegate, node, "delegate", delegate);
			
 
				+  return node;
			
 
				+}
			
 
				+function awaitExpression(argument) {
			
 
				+  const node = {
			
 
				+    type: "AwaitExpression",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.AwaitExpression;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function _import() {
			
 
				+  return {
			
 
				+    type: "Import"
			
 
				+  };
			
 
				+}
			
 
				+function exportNamespaceSpecifier(exported) {
			
 
				+  const node = {
			
 
				+    type: "ExportNamespaceSpecifier",
			
 
				+    exported
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ExportNamespaceSpecifier;
			
 
				+  validate(defs.exported, node, "exported", exported, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function optionalMemberExpression(object, property, computed = false, optional) {
			
 
				+  const node = {
			
 
				+    type: "OptionalMemberExpression",
			
 
				+    object,
			
 
				+    property,
			
 
				+    computed,
			
 
				+    optional
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.OptionalMemberExpression;
			
 
				+  validate(defs.object, node, "object", object, 1);
			
 
				+  validate(defs.property, node, "property", property, 1);
			
 
				+  validate(defs.computed, node, "computed", computed);
			
 
				+  validate(defs.optional, node, "optional", optional);
			
 
				+  return node;
			
 
				+}
			
 
				+function optionalCallExpression(callee, _arguments, optional) {
			
 
				+  const node = {
			
 
				+    type: "OptionalCallExpression",
			
 
				+    callee,
			
 
				+    arguments: _arguments,
			
 
				+    optional
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.OptionalCallExpression;
			
 
				+  validate(defs.callee, node, "callee", callee, 1);
			
 
				+  validate(defs.arguments, node, "arguments", _arguments, 1);
			
 
				+  validate(defs.optional, node, "optional", optional);
			
 
				+  return node;
			
 
				+}
			
 
				+function classProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
			
 
				+  const node = {
			
 
				+    type: "ClassProperty",
			
 
				+    key,
			
 
				+    value,
			
 
				+    typeAnnotation,
			
 
				+    decorators,
			
 
				+    computed,
			
 
				+    static: _static
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassProperty;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  validate(defs.decorators, node, "decorators", decorators, 1);
			
 
				+  validate(defs.computed, node, "computed", computed);
			
 
				+  validate(defs.static, node, "static", _static);
			
 
				+  return node;
			
 
				+}
			
 
				+function classAccessorProperty(key, value = null, typeAnnotation = null, decorators = null, computed = false, _static = false) {
			
 
				+  const node = {
			
 
				+    type: "ClassAccessorProperty",
			
 
				+    key,
			
 
				+    value,
			
 
				+    typeAnnotation,
			
 
				+    decorators,
			
 
				+    computed,
			
 
				+    static: _static
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassAccessorProperty;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  validate(defs.decorators, node, "decorators", decorators, 1);
			
 
				+  validate(defs.computed, node, "computed", computed);
			
 
				+  validate(defs.static, node, "static", _static);
			
 
				+  return node;
			
 
				+}
			
 
				+function classPrivateProperty(key, value = null, decorators = null, _static = false) {
			
 
				+  const node = {
			
 
				+    type: "ClassPrivateProperty",
			
 
				+    key,
			
 
				+    value,
			
 
				+    decorators,
			
 
				+    static: _static
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassPrivateProperty;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  validate(defs.decorators, node, "decorators", decorators, 1);
			
 
				+  validate(defs.static, node, "static", _static);
			
 
				+  return node;
			
 
				+}
			
 
				+function classPrivateMethod(kind = "method", key, params, body, _static = false) {
			
 
				+  const node = {
			
 
				+    type: "ClassPrivateMethod",
			
 
				+    kind,
			
 
				+    key,
			
 
				+    params,
			
 
				+    body,
			
 
				+    static: _static
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassPrivateMethod;
			
 
				+  validate(defs.kind, node, "kind", kind);
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.static, node, "static", _static);
			
 
				+  return node;
			
 
				+}
			
 
				+function privateName(id) {
			
 
				+  const node = {
			
 
				+    type: "PrivateName",
			
 
				+    id
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.PrivateName;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function staticBlock(body) {
			
 
				+  const node = {
			
 
				+    type: "StaticBlock",
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.StaticBlock;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function importAttribute(key, value) {
			
 
				+  const node = {
			
 
				+    type: "ImportAttribute",
			
 
				+    key,
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ImportAttribute;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function anyTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "AnyTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function arrayTypeAnnotation(elementType) {
			
 
				+  const node = {
			
 
				+    type: "ArrayTypeAnnotation",
			
 
				+    elementType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ArrayTypeAnnotation;
			
 
				+  validate(defs.elementType, node, "elementType", elementType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function booleanTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "BooleanTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function booleanLiteralTypeAnnotation(value) {
			
 
				+  const node = {
			
 
				+    type: "BooleanLiteralTypeAnnotation",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.BooleanLiteralTypeAnnotation;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function nullLiteralTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "NullLiteralTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function classImplements(id, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "ClassImplements",
			
 
				+    id,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ClassImplements;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareClass(id, typeParameters = null, _extends = null, body) {
			
 
				+  const node = {
			
 
				+    type: "DeclareClass",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    extends: _extends,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareClass;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.extends, node, "extends", _extends, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareFunction(id) {
			
 
				+  const node = {
			
 
				+    type: "DeclareFunction",
			
 
				+    id
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareFunction;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareInterface(id, typeParameters = null, _extends = null, body) {
			
 
				+  const node = {
			
 
				+    type: "DeclareInterface",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    extends: _extends,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareInterface;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.extends, node, "extends", _extends, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareModule(id, body, kind = null) {
			
 
				+  const node = {
			
 
				+    type: "DeclareModule",
			
 
				+    id,
			
 
				+    body,
			
 
				+    kind
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareModule;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.kind, node, "kind", kind);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareModuleExports(typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "DeclareModuleExports",
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareModuleExports;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareTypeAlias(id, typeParameters = null, right) {
			
 
				+  const node = {
			
 
				+    type: "DeclareTypeAlias",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    right
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareTypeAlias;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareOpaqueType(id, typeParameters = null, supertype = null) {
			
 
				+  const node = {
			
 
				+    type: "DeclareOpaqueType",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    supertype
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareOpaqueType;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.supertype, node, "supertype", supertype, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareVariable(id) {
			
 
				+  const node = {
			
 
				+    type: "DeclareVariable",
			
 
				+    id
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareVariable;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareExportDeclaration(declaration = null, specifiers = null, source = null, attributes = null) {
			
 
				+  const node = {
			
 
				+    type: "DeclareExportDeclaration",
			
 
				+    declaration,
			
 
				+    specifiers,
			
 
				+    source,
			
 
				+    attributes
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareExportDeclaration;
			
 
				+  validate(defs.declaration, node, "declaration", declaration, 1);
			
 
				+  validate(defs.specifiers, node, "specifiers", specifiers, 1);
			
 
				+  validate(defs.source, node, "source", source, 1);
			
 
				+  validate(defs.attributes, node, "attributes", attributes, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declareExportAllDeclaration(source, attributes = null) {
			
 
				+  const node = {
			
 
				+    type: "DeclareExportAllDeclaration",
			
 
				+    source,
			
 
				+    attributes
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclareExportAllDeclaration;
			
 
				+  validate(defs.source, node, "source", source, 1);
			
 
				+  validate(defs.attributes, node, "attributes", attributes, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function declaredPredicate(value) {
			
 
				+  const node = {
			
 
				+    type: "DeclaredPredicate",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DeclaredPredicate;
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function existsTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "ExistsTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function functionTypeAnnotation(typeParameters = null, params, rest = null, returnType) {
			
 
				+  const node = {
			
 
				+    type: "FunctionTypeAnnotation",
			
 
				+    typeParameters,
			
 
				+    params,
			
 
				+    rest,
			
 
				+    returnType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.FunctionTypeAnnotation;
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.rest, node, "rest", rest, 1);
			
 
				+  validate(defs.returnType, node, "returnType", returnType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function functionTypeParam(name = null, typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "FunctionTypeParam",
			
 
				+    name,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.FunctionTypeParam;
			
 
				+  validate(defs.name, node, "name", name, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function genericTypeAnnotation(id, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "GenericTypeAnnotation",
			
 
				+    id,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.GenericTypeAnnotation;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function inferredPredicate() {
			
 
				+  return {
			
 
				+    type: "InferredPredicate"
			
 
				+  };
			
 
				+}
			
 
				+function interfaceExtends(id, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "InterfaceExtends",
			
 
				+    id,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.InterfaceExtends;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function interfaceDeclaration(id, typeParameters = null, _extends = null, body) {
			
 
				+  const node = {
			
 
				+    type: "InterfaceDeclaration",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    extends: _extends,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.InterfaceDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.extends, node, "extends", _extends, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function interfaceTypeAnnotation(_extends = null, body) {
			
 
				+  const node = {
			
 
				+    type: "InterfaceTypeAnnotation",
			
 
				+    extends: _extends,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.InterfaceTypeAnnotation;
			
 
				+  validate(defs.extends, node, "extends", _extends, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function intersectionTypeAnnotation(types) {
			
 
				+  const node = {
			
 
				+    type: "IntersectionTypeAnnotation",
			
 
				+    types
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.IntersectionTypeAnnotation;
			
 
				+  validate(defs.types, node, "types", types, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function mixedTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "MixedTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function emptyTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "EmptyTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function nullableTypeAnnotation(typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "NullableTypeAnnotation",
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.NullableTypeAnnotation;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function numberLiteralTypeAnnotation(value) {
			
 
				+  const node = {
			
 
				+    type: "NumberLiteralTypeAnnotation",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.NumberLiteralTypeAnnotation;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function numberTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "NumberTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function objectTypeAnnotation(properties, indexers = [], callProperties = [], internalSlots = [], exact = false) {
			
 
				+  const node = {
			
 
				+    type: "ObjectTypeAnnotation",
			
 
				+    properties,
			
 
				+    indexers,
			
 
				+    callProperties,
			
 
				+    internalSlots,
			
 
				+    exact
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectTypeAnnotation;
			
 
				+  validate(defs.properties, node, "properties", properties, 1);
			
 
				+  validate(defs.indexers, node, "indexers", indexers, 1);
			
 
				+  validate(defs.callProperties, node, "callProperties", callProperties, 1);
			
 
				+  validate(defs.internalSlots, node, "internalSlots", internalSlots, 1);
			
 
				+  validate(defs.exact, node, "exact", exact);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectTypeInternalSlot(id, value, optional, _static, method) {
			
 
				+  const node = {
			
 
				+    type: "ObjectTypeInternalSlot",
			
 
				+    id,
			
 
				+    value,
			
 
				+    optional,
			
 
				+    static: _static,
			
 
				+    method
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectTypeInternalSlot;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  validate(defs.optional, node, "optional", optional);
			
 
				+  validate(defs.static, node, "static", _static);
			
 
				+  validate(defs.method, node, "method", method);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectTypeCallProperty(value) {
			
 
				+  const node = {
			
 
				+    type: "ObjectTypeCallProperty",
			
 
				+    value,
			
 
				+    static: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectTypeCallProperty;
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectTypeIndexer(id = null, key, value, variance = null) {
			
 
				+  const node = {
			
 
				+    type: "ObjectTypeIndexer",
			
 
				+    id,
			
 
				+    key,
			
 
				+    value,
			
 
				+    variance,
			
 
				+    static: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectTypeIndexer;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  validate(defs.variance, node, "variance", variance, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectTypeProperty(key, value, variance = null) {
			
 
				+  const node = {
			
 
				+    type: "ObjectTypeProperty",
			
 
				+    key,
			
 
				+    value,
			
 
				+    variance,
			
 
				+    kind: null,
			
 
				+    method: null,
			
 
				+    optional: null,
			
 
				+    proto: null,
			
 
				+    static: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectTypeProperty;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  validate(defs.variance, node, "variance", variance, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function objectTypeSpreadProperty(argument) {
			
 
				+  const node = {
			
 
				+    type: "ObjectTypeSpreadProperty",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ObjectTypeSpreadProperty;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function opaqueType(id, typeParameters = null, supertype = null, impltype) {
			
 
				+  const node = {
			
 
				+    type: "OpaqueType",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    supertype,
			
 
				+    impltype
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.OpaqueType;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.supertype, node, "supertype", supertype, 1);
			
 
				+  validate(defs.impltype, node, "impltype", impltype, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function qualifiedTypeIdentifier(id, qualification) {
			
 
				+  const node = {
			
 
				+    type: "QualifiedTypeIdentifier",
			
 
				+    id,
			
 
				+    qualification
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.QualifiedTypeIdentifier;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.qualification, node, "qualification", qualification, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function stringLiteralTypeAnnotation(value) {
			
 
				+  const node = {
			
 
				+    type: "StringLiteralTypeAnnotation",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.StringLiteralTypeAnnotation;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function stringTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "StringTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function symbolTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "SymbolTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function thisTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "ThisTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function tupleTypeAnnotation(types) {
			
 
				+  const node = {
			
 
				+    type: "TupleTypeAnnotation",
			
 
				+    types
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TupleTypeAnnotation;
			
 
				+  validate(defs.types, node, "types", types, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function typeofTypeAnnotation(argument) {
			
 
				+  const node = {
			
 
				+    type: "TypeofTypeAnnotation",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TypeofTypeAnnotation;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function typeAlias(id, typeParameters = null, right) {
			
 
				+  const node = {
			
 
				+    type: "TypeAlias",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    right
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TypeAlias;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function typeAnnotation(typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TypeAnnotation",
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TypeAnnotation;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function typeCastExpression(expression, typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TypeCastExpression",
			
 
				+    expression,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TypeCastExpression;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function typeParameter(bound = null, _default = null, variance = null) {
			
 
				+  const node = {
			
 
				+    type: "TypeParameter",
			
 
				+    bound,
			
 
				+    default: _default,
			
 
				+    variance,
			
 
				+    name: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TypeParameter;
			
 
				+  validate(defs.bound, node, "bound", bound, 1);
			
 
				+  validate(defs.default, node, "default", _default, 1);
			
 
				+  validate(defs.variance, node, "variance", variance, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function typeParameterDeclaration(params) {
			
 
				+  const node = {
			
 
				+    type: "TypeParameterDeclaration",
			
 
				+    params
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TypeParameterDeclaration;
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function typeParameterInstantiation(params) {
			
 
				+  const node = {
			
 
				+    type: "TypeParameterInstantiation",
			
 
				+    params
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TypeParameterInstantiation;
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function unionTypeAnnotation(types) {
			
 
				+  const node = {
			
 
				+    type: "UnionTypeAnnotation",
			
 
				+    types
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.UnionTypeAnnotation;
			
 
				+  validate(defs.types, node, "types", types, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function variance(kind) {
			
 
				+  const node = {
			
 
				+    type: "Variance",
			
 
				+    kind
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.Variance;
			
 
				+  validate(defs.kind, node, "kind", kind);
			
 
				+  return node;
			
 
				+}
			
 
				+function voidTypeAnnotation() {
			
 
				+  return {
			
 
				+    type: "VoidTypeAnnotation"
			
 
				+  };
			
 
				+}
			
 
				+function enumDeclaration(id, body) {
			
 
				+  const node = {
			
 
				+    type: "EnumDeclaration",
			
 
				+    id,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumBooleanBody(members) {
			
 
				+  const node = {
			
 
				+    type: "EnumBooleanBody",
			
 
				+    members,
			
 
				+    explicitType: null,
			
 
				+    hasUnknownMembers: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumBooleanBody;
			
 
				+  validate(defs.members, node, "members", members, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumNumberBody(members) {
			
 
				+  const node = {
			
 
				+    type: "EnumNumberBody",
			
 
				+    members,
			
 
				+    explicitType: null,
			
 
				+    hasUnknownMembers: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumNumberBody;
			
 
				+  validate(defs.members, node, "members", members, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumStringBody(members) {
			
 
				+  const node = {
			
 
				+    type: "EnumStringBody",
			
 
				+    members,
			
 
				+    explicitType: null,
			
 
				+    hasUnknownMembers: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumStringBody;
			
 
				+  validate(defs.members, node, "members", members, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumSymbolBody(members) {
			
 
				+  const node = {
			
 
				+    type: "EnumSymbolBody",
			
 
				+    members,
			
 
				+    hasUnknownMembers: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumSymbolBody;
			
 
				+  validate(defs.members, node, "members", members, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumBooleanMember(id) {
			
 
				+  const node = {
			
 
				+    type: "EnumBooleanMember",
			
 
				+    id,
			
 
				+    init: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumBooleanMember;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumNumberMember(id, init) {
			
 
				+  const node = {
			
 
				+    type: "EnumNumberMember",
			
 
				+    id,
			
 
				+    init
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumNumberMember;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.init, node, "init", init, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumStringMember(id, init) {
			
 
				+  const node = {
			
 
				+    type: "EnumStringMember",
			
 
				+    id,
			
 
				+    init
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumStringMember;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.init, node, "init", init, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function enumDefaultedMember(id) {
			
 
				+  const node = {
			
 
				+    type: "EnumDefaultedMember",
			
 
				+    id
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.EnumDefaultedMember;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function indexedAccessType(objectType, indexType) {
			
 
				+  const node = {
			
 
				+    type: "IndexedAccessType",
			
 
				+    objectType,
			
 
				+    indexType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.IndexedAccessType;
			
 
				+  validate(defs.objectType, node, "objectType", objectType, 1);
			
 
				+  validate(defs.indexType, node, "indexType", indexType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function optionalIndexedAccessType(objectType, indexType) {
			
 
				+  const node = {
			
 
				+    type: "OptionalIndexedAccessType",
			
 
				+    objectType,
			
 
				+    indexType,
			
 
				+    optional: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.OptionalIndexedAccessType;
			
 
				+  validate(defs.objectType, node, "objectType", objectType, 1);
			
 
				+  validate(defs.indexType, node, "indexType", indexType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxAttribute(name, value = null) {
			
 
				+  const node = {
			
 
				+    type: "JSXAttribute",
			
 
				+    name,
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXAttribute;
			
 
				+  validate(defs.name, node, "name", name, 1);
			
 
				+  validate(defs.value, node, "value", value, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxClosingElement(name) {
			
 
				+  const node = {
			
 
				+    type: "JSXClosingElement",
			
 
				+    name
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXClosingElement;
			
 
				+  validate(defs.name, node, "name", name, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxElement(openingElement, closingElement = null, children, selfClosing = null) {
			
 
				+  const node = {
			
 
				+    type: "JSXElement",
			
 
				+    openingElement,
			
 
				+    closingElement,
			
 
				+    children,
			
 
				+    selfClosing
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXElement;
			
 
				+  validate(defs.openingElement, node, "openingElement", openingElement, 1);
			
 
				+  validate(defs.closingElement, node, "closingElement", closingElement, 1);
			
 
				+  validate(defs.children, node, "children", children, 1);
			
 
				+  validate(defs.selfClosing, node, "selfClosing", selfClosing);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxEmptyExpression() {
			
 
				+  return {
			
 
				+    type: "JSXEmptyExpression"
			
 
				+  };
			
 
				+}
			
 
				+function jsxExpressionContainer(expression) {
			
 
				+  const node = {
			
 
				+    type: "JSXExpressionContainer",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXExpressionContainer;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxSpreadChild(expression) {
			
 
				+  const node = {
			
 
				+    type: "JSXSpreadChild",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXSpreadChild;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxIdentifier(name) {
			
 
				+  const node = {
			
 
				+    type: "JSXIdentifier",
			
 
				+    name
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXIdentifier;
			
 
				+  validate(defs.name, node, "name", name);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxMemberExpression(object, property) {
			
 
				+  const node = {
			
 
				+    type: "JSXMemberExpression",
			
 
				+    object,
			
 
				+    property
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXMemberExpression;
			
 
				+  validate(defs.object, node, "object", object, 1);
			
 
				+  validate(defs.property, node, "property", property, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxNamespacedName(namespace, name) {
			
 
				+  const node = {
			
 
				+    type: "JSXNamespacedName",
			
 
				+    namespace,
			
 
				+    name
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXNamespacedName;
			
 
				+  validate(defs.namespace, node, "namespace", namespace, 1);
			
 
				+  validate(defs.name, node, "name", name, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxOpeningElement(name, attributes, selfClosing = false) {
			
 
				+  const node = {
			
 
				+    type: "JSXOpeningElement",
			
 
				+    name,
			
 
				+    attributes,
			
 
				+    selfClosing
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXOpeningElement;
			
 
				+  validate(defs.name, node, "name", name, 1);
			
 
				+  validate(defs.attributes, node, "attributes", attributes, 1);
			
 
				+  validate(defs.selfClosing, node, "selfClosing", selfClosing);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxSpreadAttribute(argument) {
			
 
				+  const node = {
			
 
				+    type: "JSXSpreadAttribute",
			
 
				+    argument
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXSpreadAttribute;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxText(value) {
			
 
				+  const node = {
			
 
				+    type: "JSXText",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXText;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxFragment(openingFragment, closingFragment, children) {
			
 
				+  const node = {
			
 
				+    type: "JSXFragment",
			
 
				+    openingFragment,
			
 
				+    closingFragment,
			
 
				+    children
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.JSXFragment;
			
 
				+  validate(defs.openingFragment, node, "openingFragment", openingFragment, 1);
			
 
				+  validate(defs.closingFragment, node, "closingFragment", closingFragment, 1);
			
 
				+  validate(defs.children, node, "children", children, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function jsxOpeningFragment() {
			
 
				+  return {
			
 
				+    type: "JSXOpeningFragment"
			
 
				+  };
			
 
				+}
			
 
				+function jsxClosingFragment() {
			
 
				+  return {
			
 
				+    type: "JSXClosingFragment"
			
 
				+  };
			
 
				+}
			
 
				+function noop() {
			
 
				+  return {
			
 
				+    type: "Noop"
			
 
				+  };
			
 
				+}
			
 
				+function placeholder(expectedNode, name) {
			
 
				+  const node = {
			
 
				+    type: "Placeholder",
			
 
				+    expectedNode,
			
 
				+    name
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.Placeholder;
			
 
				+  validate(defs.expectedNode, node, "expectedNode", expectedNode);
			
 
				+  validate(defs.name, node, "name", name, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function v8IntrinsicIdentifier(name) {
			
 
				+  const node = {
			
 
				+    type: "V8IntrinsicIdentifier",
			
 
				+    name
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.V8IntrinsicIdentifier;
			
 
				+  validate(defs.name, node, "name", name);
			
 
				+  return node;
			
 
				+}
			
 
				+function argumentPlaceholder() {
			
 
				+  return {
			
 
				+    type: "ArgumentPlaceholder"
			
 
				+  };
			
 
				+}
			
 
				+function bindExpression(object, callee) {
			
 
				+  const node = {
			
 
				+    type: "BindExpression",
			
 
				+    object,
			
 
				+    callee
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.BindExpression;
			
 
				+  validate(defs.object, node, "object", object, 1);
			
 
				+  validate(defs.callee, node, "callee", callee, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function decorator(expression) {
			
 
				+  const node = {
			
 
				+    type: "Decorator",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.Decorator;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function doExpression(body, async = false) {
			
 
				+  const node = {
			
 
				+    type: "DoExpression",
			
 
				+    body,
			
 
				+    async
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DoExpression;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  validate(defs.async, node, "async", async);
			
 
				+  return node;
			
 
				+}
			
 
				+function exportDefaultSpecifier(exported) {
			
 
				+  const node = {
			
 
				+    type: "ExportDefaultSpecifier",
			
 
				+    exported
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ExportDefaultSpecifier;
			
 
				+  validate(defs.exported, node, "exported", exported, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function recordExpression(properties) {
			
 
				+  const node = {
			
 
				+    type: "RecordExpression",
			
 
				+    properties
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.RecordExpression;
			
 
				+  validate(defs.properties, node, "properties", properties, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tupleExpression(elements = []) {
			
 
				+  const node = {
			
 
				+    type: "TupleExpression",
			
 
				+    elements
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TupleExpression;
			
 
				+  validate(defs.elements, node, "elements", elements, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function decimalLiteral(value) {
			
 
				+  const node = {
			
 
				+    type: "DecimalLiteral",
			
 
				+    value
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.DecimalLiteral;
			
 
				+  validate(defs.value, node, "value", value);
			
 
				+  return node;
			
 
				+}
			
 
				+function moduleExpression(body) {
			
 
				+  const node = {
			
 
				+    type: "ModuleExpression",
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.ModuleExpression;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function topicReference() {
			
 
				+  return {
			
 
				+    type: "TopicReference"
			
 
				+  };
			
 
				+}
			
 
				+function pipelineTopicExpression(expression) {
			
 
				+  const node = {
			
 
				+    type: "PipelineTopicExpression",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.PipelineTopicExpression;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function pipelineBareFunction(callee) {
			
 
				+  const node = {
			
 
				+    type: "PipelineBareFunction",
			
 
				+    callee
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.PipelineBareFunction;
			
 
				+  validate(defs.callee, node, "callee", callee, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function pipelinePrimaryTopicReference() {
			
 
				+  return {
			
 
				+    type: "PipelinePrimaryTopicReference"
			
 
				+  };
			
 
				+}
			
 
				+function voidPattern() {
			
 
				+  return {
			
 
				+    type: "VoidPattern"
			
 
				+  };
			
 
				+}
			
 
				+function tsParameterProperty(parameter) {
			
 
				+  const node = {
			
 
				+    type: "TSParameterProperty",
			
 
				+    parameter
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSParameterProperty;
			
 
				+  validate(defs.parameter, node, "parameter", parameter, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsDeclareFunction(id = null, typeParameters = null, params, returnType = null) {
			
 
				+  const node = {
			
 
				+    type: "TSDeclareFunction",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    params,
			
 
				+    returnType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSDeclareFunction;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.returnType, node, "returnType", returnType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsDeclareMethod(decorators = null, key, typeParameters = null, params, returnType = null) {
			
 
				+  const node = {
			
 
				+    type: "TSDeclareMethod",
			
 
				+    decorators,
			
 
				+    key,
			
 
				+    typeParameters,
			
 
				+    params,
			
 
				+    returnType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSDeclareMethod;
			
 
				+  validate(defs.decorators, node, "decorators", decorators, 1);
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  validate(defs.returnType, node, "returnType", returnType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsQualifiedName(left, right) {
			
 
				+  const node = {
			
 
				+    type: "TSQualifiedName",
			
 
				+    left,
			
 
				+    right
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSQualifiedName;
			
 
				+  validate(defs.left, node, "left", left, 1);
			
 
				+  validate(defs.right, node, "right", right, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsCallSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
			
 
				+  const node = {
			
 
				+    type: "TSCallSignatureDeclaration",
			
 
				+    typeParameters,
			
 
				+    parameters,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSCallSignatureDeclaration;
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.parameters, node, "parameters", parameters, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsConstructSignatureDeclaration(typeParameters = null, parameters, typeAnnotation = null) {
			
 
				+  const node = {
			
 
				+    type: "TSConstructSignatureDeclaration",
			
 
				+    typeParameters,
			
 
				+    parameters,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSConstructSignatureDeclaration;
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.parameters, node, "parameters", parameters, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsPropertySignature(key, typeAnnotation = null) {
			
 
				+  const node = {
			
 
				+    type: "TSPropertySignature",
			
 
				+    key,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSPropertySignature;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsMethodSignature(key, typeParameters = null, parameters, typeAnnotation = null) {
			
 
				+  const node = {
			
 
				+    type: "TSMethodSignature",
			
 
				+    key,
			
 
				+    typeParameters,
			
 
				+    parameters,
			
 
				+    typeAnnotation,
			
 
				+    kind: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSMethodSignature;
			
 
				+  validate(defs.key, node, "key", key, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.parameters, node, "parameters", parameters, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsIndexSignature(parameters, typeAnnotation = null) {
			
 
				+  const node = {
			
 
				+    type: "TSIndexSignature",
			
 
				+    parameters,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSIndexSignature;
			
 
				+  validate(defs.parameters, node, "parameters", parameters, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsAnyKeyword() {
			
 
				+  return {
			
 
				+    type: "TSAnyKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsBooleanKeyword() {
			
 
				+  return {
			
 
				+    type: "TSBooleanKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsBigIntKeyword() {
			
 
				+  return {
			
 
				+    type: "TSBigIntKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsIntrinsicKeyword() {
			
 
				+  return {
			
 
				+    type: "TSIntrinsicKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsNeverKeyword() {
			
 
				+  return {
			
 
				+    type: "TSNeverKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsNullKeyword() {
			
 
				+  return {
			
 
				+    type: "TSNullKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsNumberKeyword() {
			
 
				+  return {
			
 
				+    type: "TSNumberKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsObjectKeyword() {
			
 
				+  return {
			
 
				+    type: "TSObjectKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsStringKeyword() {
			
 
				+  return {
			
 
				+    type: "TSStringKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsSymbolKeyword() {
			
 
				+  return {
			
 
				+    type: "TSSymbolKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsUndefinedKeyword() {
			
 
				+  return {
			
 
				+    type: "TSUndefinedKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsUnknownKeyword() {
			
 
				+  return {
			
 
				+    type: "TSUnknownKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsVoidKeyword() {
			
 
				+  return {
			
 
				+    type: "TSVoidKeyword"
			
 
				+  };
			
 
				+}
			
 
				+function tsThisType() {
			
 
				+  return {
			
 
				+    type: "TSThisType"
			
 
				+  };
			
 
				+}
			
 
				+function tsFunctionType(typeParameters = null, parameters, typeAnnotation = null) {
			
 
				+  const node = {
			
 
				+    type: "TSFunctionType",
			
 
				+    typeParameters,
			
 
				+    parameters,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSFunctionType;
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.parameters, node, "parameters", parameters, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsConstructorType(typeParameters = null, parameters, typeAnnotation = null) {
			
 
				+  const node = {
			
 
				+    type: "TSConstructorType",
			
 
				+    typeParameters,
			
 
				+    parameters,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSConstructorType;
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.parameters, node, "parameters", parameters, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeReference(typeName, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeReference",
			
 
				+    typeName,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeReference;
			
 
				+  validate(defs.typeName, node, "typeName", typeName, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypePredicate(parameterName, typeAnnotation = null, asserts = null) {
			
 
				+  const node = {
			
 
				+    type: "TSTypePredicate",
			
 
				+    parameterName,
			
 
				+    typeAnnotation,
			
 
				+    asserts
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypePredicate;
			
 
				+  validate(defs.parameterName, node, "parameterName", parameterName, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  validate(defs.asserts, node, "asserts", asserts);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeQuery(exprName, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeQuery",
			
 
				+    exprName,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeQuery;
			
 
				+  validate(defs.exprName, node, "exprName", exprName, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeLiteral(members) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeLiteral",
			
 
				+    members
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeLiteral;
			
 
				+  validate(defs.members, node, "members", members, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsArrayType(elementType) {
			
 
				+  const node = {
			
 
				+    type: "TSArrayType",
			
 
				+    elementType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSArrayType;
			
 
				+  validate(defs.elementType, node, "elementType", elementType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTupleType(elementTypes) {
			
 
				+  const node = {
			
 
				+    type: "TSTupleType",
			
 
				+    elementTypes
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTupleType;
			
 
				+  validate(defs.elementTypes, node, "elementTypes", elementTypes, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsOptionalType(typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TSOptionalType",
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSOptionalType;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsRestType(typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TSRestType",
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSRestType;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsNamedTupleMember(label, elementType, optional = false) {
			
 
				+  const node = {
			
 
				+    type: "TSNamedTupleMember",
			
 
				+    label,
			
 
				+    elementType,
			
 
				+    optional
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSNamedTupleMember;
			
 
				+  validate(defs.label, node, "label", label, 1);
			
 
				+  validate(defs.elementType, node, "elementType", elementType, 1);
			
 
				+  validate(defs.optional, node, "optional", optional);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsUnionType(types) {
			
 
				+  const node = {
			
 
				+    type: "TSUnionType",
			
 
				+    types
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSUnionType;
			
 
				+  validate(defs.types, node, "types", types, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsIntersectionType(types) {
			
 
				+  const node = {
			
 
				+    type: "TSIntersectionType",
			
 
				+    types
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSIntersectionType;
			
 
				+  validate(defs.types, node, "types", types, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsConditionalType(checkType, extendsType, trueType, falseType) {
			
 
				+  const node = {
			
 
				+    type: "TSConditionalType",
			
 
				+    checkType,
			
 
				+    extendsType,
			
 
				+    trueType,
			
 
				+    falseType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSConditionalType;
			
 
				+  validate(defs.checkType, node, "checkType", checkType, 1);
			
 
				+  validate(defs.extendsType, node, "extendsType", extendsType, 1);
			
 
				+  validate(defs.trueType, node, "trueType", trueType, 1);
			
 
				+  validate(defs.falseType, node, "falseType", falseType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsInferType(typeParameter) {
			
 
				+  const node = {
			
 
				+    type: "TSInferType",
			
 
				+    typeParameter
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSInferType;
			
 
				+  validate(defs.typeParameter, node, "typeParameter", typeParameter, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsParenthesizedType(typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TSParenthesizedType",
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSParenthesizedType;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeOperator(typeAnnotation, operator = "keyof") {
			
 
				+  const node = {
			
 
				+    type: "TSTypeOperator",
			
 
				+    typeAnnotation,
			
 
				+    operator
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeOperator;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  validate(defs.operator, node, "operator", operator);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsIndexedAccessType(objectType, indexType) {
			
 
				+  const node = {
			
 
				+    type: "TSIndexedAccessType",
			
 
				+    objectType,
			
 
				+    indexType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSIndexedAccessType;
			
 
				+  validate(defs.objectType, node, "objectType", objectType, 1);
			
 
				+  validate(defs.indexType, node, "indexType", indexType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsMappedType(typeParameter, typeAnnotation = null, nameType = null) {
			
 
				+  const node = {
			
 
				+    type: "TSMappedType",
			
 
				+    typeParameter,
			
 
				+    typeAnnotation,
			
 
				+    nameType
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSMappedType;
			
 
				+  validate(defs.typeParameter, node, "typeParameter", typeParameter, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  validate(defs.nameType, node, "nameType", nameType, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTemplateLiteralType(quasis, types) {
			
 
				+  const node = {
			
 
				+    type: "TSTemplateLiteralType",
			
 
				+    quasis,
			
 
				+    types
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTemplateLiteralType;
			
 
				+  validate(defs.quasis, node, "quasis", quasis, 1);
			
 
				+  validate(defs.types, node, "types", types, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsLiteralType(literal) {
			
 
				+  const node = {
			
 
				+    type: "TSLiteralType",
			
 
				+    literal
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSLiteralType;
			
 
				+  validate(defs.literal, node, "literal", literal, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsExpressionWithTypeArguments(expression, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "TSExpressionWithTypeArguments",
			
 
				+    expression,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSExpressionWithTypeArguments;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsInterfaceDeclaration(id, typeParameters = null, _extends = null, body) {
			
 
				+  const node = {
			
 
				+    type: "TSInterfaceDeclaration",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    extends: _extends,
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSInterfaceDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.extends, node, "extends", _extends, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsInterfaceBody(body) {
			
 
				+  const node = {
			
 
				+    type: "TSInterfaceBody",
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSInterfaceBody;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeAliasDeclaration(id, typeParameters = null, typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeAliasDeclaration",
			
 
				+    id,
			
 
				+    typeParameters,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeAliasDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsInstantiationExpression(expression, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "TSInstantiationExpression",
			
 
				+    expression,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSInstantiationExpression;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsAsExpression(expression, typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TSAsExpression",
			
 
				+    expression,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSAsExpression;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsSatisfiesExpression(expression, typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TSSatisfiesExpression",
			
 
				+    expression,
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSSatisfiesExpression;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeAssertion(typeAnnotation, expression) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeAssertion",
			
 
				+    typeAnnotation,
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeAssertion;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsEnumBody(members) {
			
 
				+  const node = {
			
 
				+    type: "TSEnumBody",
			
 
				+    members
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSEnumBody;
			
 
				+  validate(defs.members, node, "members", members, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsEnumDeclaration(id, members) {
			
 
				+  const node = {
			
 
				+    type: "TSEnumDeclaration",
			
 
				+    id,
			
 
				+    members
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSEnumDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.members, node, "members", members, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsEnumMember(id, initializer = null) {
			
 
				+  const node = {
			
 
				+    type: "TSEnumMember",
			
 
				+    id,
			
 
				+    initializer
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSEnumMember;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.initializer, node, "initializer", initializer, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsModuleDeclaration(id, body) {
			
 
				+  const node = {
			
 
				+    type: "TSModuleDeclaration",
			
 
				+    id,
			
 
				+    body,
			
 
				+    kind: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSModuleDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsModuleBlock(body) {
			
 
				+  const node = {
			
 
				+    type: "TSModuleBlock",
			
 
				+    body
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSModuleBlock;
			
 
				+  validate(defs.body, node, "body", body, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsImportType(argument, qualifier = null, typeParameters = null) {
			
 
				+  const node = {
			
 
				+    type: "TSImportType",
			
 
				+    argument,
			
 
				+    qualifier,
			
 
				+    typeParameters
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSImportType;
			
 
				+  validate(defs.argument, node, "argument", argument, 1);
			
 
				+  validate(defs.qualifier, node, "qualifier", qualifier, 1);
			
 
				+  validate(defs.typeParameters, node, "typeParameters", typeParameters, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsImportEqualsDeclaration(id, moduleReference) {
			
 
				+  const node = {
			
 
				+    type: "TSImportEqualsDeclaration",
			
 
				+    id,
			
 
				+    moduleReference,
			
 
				+    isExport: null
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSImportEqualsDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  validate(defs.moduleReference, node, "moduleReference", moduleReference, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsExternalModuleReference(expression) {
			
 
				+  const node = {
			
 
				+    type: "TSExternalModuleReference",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSExternalModuleReference;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsNonNullExpression(expression) {
			
 
				+  const node = {
			
 
				+    type: "TSNonNullExpression",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSNonNullExpression;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsExportAssignment(expression) {
			
 
				+  const node = {
			
 
				+    type: "TSExportAssignment",
			
 
				+    expression
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSExportAssignment;
			
 
				+  validate(defs.expression, node, "expression", expression, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsNamespaceExportDeclaration(id) {
			
 
				+  const node = {
			
 
				+    type: "TSNamespaceExportDeclaration",
			
 
				+    id
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSNamespaceExportDeclaration;
			
 
				+  validate(defs.id, node, "id", id, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeAnnotation(typeAnnotation) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeAnnotation",
			
 
				+    typeAnnotation
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeAnnotation;
			
 
				+  validate(defs.typeAnnotation, node, "typeAnnotation", typeAnnotation, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeParameterInstantiation(params) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeParameterInstantiation",
			
 
				+    params
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeParameterInstantiation;
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeParameterDeclaration(params) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeParameterDeclaration",
			
 
				+    params
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeParameterDeclaration;
			
 
				+  validate(defs.params, node, "params", params, 1);
			
 
				+  return node;
			
 
				+}
			
 
				+function tsTypeParameter(constraint = null, _default = null, name) {
			
 
				+  const node = {
			
 
				+    type: "TSTypeParameter",
			
 
				+    constraint,
			
 
				+    default: _default,
			
 
				+    name
			
 
				+  };
			
 
				+  const defs = NODE_FIELDS.TSTypeParameter;
			
 
				+  validate(defs.constraint, node, "constraint", constraint, 1);
			
 
				+  validate(defs.default, node, "default", _default, 1);
			
 
				+  validate(defs.name, node, "name", name);
			
 
				+  return node;
			
 
				+}
			
 
				+function NumberLiteral(value) {
			
 
				+  (0, _deprecationWarning.default)("NumberLiteral", "NumericLiteral", "The node type ");
			
 
				+  return numericLiteral(value);
			
 
				+}
			
 
				+function RegexLiteral(pattern, flags = "") {
			
 
				+  (0, _deprecationWarning.default)("RegexLiteral", "RegExpLiteral", "The node type ");
			
 
				+  return regExpLiteral(pattern, flags);
			
 
				+}
			
 
				+function RestProperty(argument) {
			
 
				+  (0, _deprecationWarning.default)("RestProperty", "RestElement", "The node type ");
			
 
				+  return restElement(argument);
			
 
				+}
			
 
				+function SpreadProperty(argument) {
			
 
				+  (0, _deprecationWarning.default)("SpreadProperty", "SpreadElement", "The node type ");
			
 
				+  return spreadElement(argument);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=lowercase.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/generated/lowercase.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/generated/lowercase.js.map
--- a/ui/node_modules/@babel/types/lib/builders/generated/uppercase.js
+++ b/ui/node_modules/@babel/types/lib/builders/generated/uppercase.js
--- a/ui/node_modules/@babel/types/lib/builders/generated/uppercase.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/generated/uppercase.js.map
--- a/ui/node_modules/@babel/types/lib/builders/productions.js
+++ b/ui/node_modules/@babel/types/lib/builders/productions.js
@@ -0,0 +1,12 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.buildUndefinedNode = buildUndefinedNode;
			
 
				+var _index = require("./generated/index.js");
			
 
				+function buildUndefinedNode() {
			
 
				+  return (0, _index.unaryExpression)("void", (0, _index.numericLiteral)(0), true);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=productions.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/productions.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/productions.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_index","require","buildUndefinedNode","unaryExpression","numericLiteral"],"sources":["../../src/builders/productions.ts"],"sourcesContent":["import { numericLiteral, unaryExpression } from \"./generated/index.ts\";\n\nexport function buildUndefinedNode() {\n  return unaryExpression(\"void\", numericLiteral(0), true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAEO,SAASC,kBAAkBA,CAAA,EAAG;EACnC,OAAO,IAAAC,sBAAe,EAAC,MAAM,EAAE,IAAAC,qBAAc,EAAC,CAAC,CAAC,EAAE,IAAI,CAAC;AACzD","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/builders/react/buildChildren.js
+++ b/ui/node_modules/@babel/types/lib/builders/react/buildChildren.js
@@ -0,0 +1,24 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = buildChildren;
			
 
				+var _index = require("../../validators/generated/index.js");
			
 
				+var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild.js");
			
 
				+function buildChildren(node) {
			
 
				+  const elements = [];
			
 
				+  for (let i = 0; i < node.children.length; i++) {
			
 
				+    let child = node.children[i];
			
 
				+    if ((0, _index.isJSXText)(child)) {
			
 
				+      (0, _cleanJSXElementLiteralChild.default)(child, elements);
			
 
				+      continue;
			
 
				+    }
			
 
				+    if ((0, _index.isJSXExpressionContainer)(child)) child = child.expression;
			
 
				+    if ((0, _index.isJSXEmptyExpression)(child)) continue;
			
 
				+    elements.push(child);
			
 
				+  }
			
 
				+  return elements;
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=buildChildren.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/react/buildChildren.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/react/buildChildren.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_index","require","_cleanJSXElementLiteralChild","buildChildren","node","elements","i","children","length","child","isJSXText","cleanJSXElementLiteralChild","isJSXExpressionContainer","expression","isJSXEmptyExpression","push"],"sources":["../../../src/builders/react/buildChildren.ts"],"sourcesContent":["import {\n  isJSXText,\n  isJSXExpressionContainer,\n  isJSXEmptyExpression,\n} from \"../../validators/generated/index.ts\";\nimport cleanJSXElementLiteralChild from \"../../utils/react/cleanJSXElementLiteralChild.ts\";\nimport type * as t from \"../../index.ts\";\n\ntype ReturnedChild =\n  | t.JSXSpreadChild\n  | t.JSXElement\n  | t.JSXFragment\n  | t.Expression;\n\nexport default function buildChildren(\n  node: t.JSXElement | t.JSXFragment,\n): ReturnedChild[] {\n  const elements = [];\n\n  for (let i = 0; i < node.children.length; i++) {\n    let child: any = node.children[i];\n\n    if (isJSXText(child)) {\n      cleanJSXElementLiteralChild(child, elements);\n      continue;\n    }\n\n    if (isJSXExpressionContainer(child)) child = child.expression;\n    if (isJSXEmptyExpression(child)) continue;\n\n    elements.push(child);\n  }\n\n  return elements;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AAKA,IAAAC,4BAAA,GAAAD,OAAA;AASe,SAASE,aAAaA,CACnCC,IAAkC,EACjB;EACjB,MAAMC,QAAQ,GAAG,EAAE;EAEnB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,IAAI,CAACG,QAAQ,CAACC,MAAM,EAAEF,CAAC,EAAE,EAAE;IAC7C,IAAIG,KAAU,GAAGL,IAAI,CAACG,QAAQ,CAACD,CAAC,CAAC;IAEjC,IAAI,IAAAI,gBAAS,EAACD,KAAK,CAAC,EAAE;MACpB,IAAAE,oCAA2B,EAACF,KAAK,EAAEJ,QAAQ,CAAC;MAC5C;IACF;IAEA,IAAI,IAAAO,+BAAwB,EAACH,KAAK,CAAC,EAAEA,KAAK,GAAGA,KAAK,CAACI,UAAU;IAC7D,IAAI,IAAAC,2BAAoB,EAACL,KAAK,CAAC,EAAE;IAEjCJ,QAAQ,CAACU,IAAI,CAACN,KAAK,CAAC;EACtB;EAEA,OAAOJ,QAAQ;AACjB","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
+++ b/ui/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js
@@ -0,0 +1,22 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = createTSUnionType;
			
 
				+var _index = require("../generated/index.js");
			
 
				+var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates.js");
			
 
				+var _index2 = require("../../validators/generated/index.js");
			
 
				+function createTSUnionType(typeAnnotations) {
			
 
				+  const types = typeAnnotations.map(type => {
			
 
				+    return (0, _index2.isTSTypeAnnotation)(type) ? type.typeAnnotation : type;
			
 
				+  });
			
 
				+  const flattened = (0, _removeTypeDuplicates.default)(types);
			
 
				+  if (flattened.length === 1) {
			
 
				+    return flattened[0];
			
 
				+  } else {
			
 
				+    return (0, _index.tsUnionType)(flattened);
			
 
				+  }
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=createTSUnionType.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/typescript/createTSUnionType.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_index","require","_removeTypeDuplicates","_index2","createTSUnionType","typeAnnotations","types","map","type","isTSTypeAnnotation","typeAnnotation","flattened","removeTypeDuplicates","length","tsUnionType"],"sources":["../../../src/builders/typescript/createTSUnionType.ts"],"sourcesContent":["import { tsUnionType } from \"../generated/index.ts\";\nimport removeTypeDuplicates from \"../../modifications/typescript/removeTypeDuplicates.ts\";\nimport { isTSTypeAnnotation } from \"../../validators/generated/index.ts\";\nimport type * as t from \"../../index.ts\";\n\n/**\n * Takes an array of `types` and flattens them, removing duplicates and\n * returns a `UnionTypeAnnotation` node containing them.\n */\nexport default function createTSUnionType(\n  typeAnnotations: (t.TSTypeAnnotation | t.TSType)[],\n): t.TSType {\n  const types = typeAnnotations.map(type => {\n    return isTSTypeAnnotation(type) ? type.typeAnnotation : type;\n  });\n  const flattened = removeTypeDuplicates(types);\n\n  if (flattened.length === 1) {\n    return flattened[0];\n  } else {\n    return tsUnionType(flattened);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,qBAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAOe,SAASG,iBAAiBA,CACvCC,eAAkD,EACxC;EACV,MAAMC,KAAK,GAAGD,eAAe,CAACE,GAAG,CAACC,IAAI,IAAI;IACxC,OAAO,IAAAC,0BAAkB,EAACD,IAAI,CAAC,GAAGA,IAAI,CAACE,cAAc,GAAGF,IAAI;EAC9D,CAAC,CAAC;EACF,MAAMG,SAAS,GAAG,IAAAC,6BAAoB,EAACN,KAAK,CAAC;EAE7C,IAAIK,SAAS,CAACE,MAAM,KAAK,CAAC,EAAE;IAC1B,OAAOF,SAAS,CAAC,CAAC,CAAC;EACrB,CAAC,MAAM;IACL,OAAO,IAAAG,kBAAW,EAACH,SAAS,CAAC;EAC/B;AACF","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/builders/validateNode.js
+++ b/ui/node_modules/@babel/types/lib/builders/validateNode.js
@@ -0,0 +1,21 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = validateNode;
			
 
				+var _validate = require("../validators/validate.js");
			
 
				+var _index = require("../index.js");
			
 
				+function validateNode(node) {
			
 
				+  if (node == null || typeof node !== "object") return;
			
 
				+  const fields = _index.NODE_FIELDS[node.type];
			
 
				+  if (!fields) return;
			
 
				+  const keys = _index.BUILDER_KEYS[node.type];
			
 
				+  for (const key of keys) {
			
 
				+    const field = fields[key];
			
 
				+    if (field != null) (0, _validate.validateInternal)(field, node, key, node[key]);
			
 
				+  }
			
 
				+  return node;
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=validateNode.js.map
			
--- a/ui/node_modules/@babel/types/lib/builders/validateNode.js.map
+++ b/ui/node_modules/@babel/types/lib/builders/validateNode.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_validate","require","_index","validateNode","node","fields","NODE_FIELDS","type","keys","BUILDER_KEYS","key","field","validateInternal"],"sources":["../../src/builders/validateNode.ts"],"sourcesContent":["import { validateInternal } from \"../validators/validate.ts\";\nimport type * as t from \"../index.ts\";\nimport { BUILDER_KEYS, NODE_FIELDS } from \"../index.ts\";\n\nexport default function validateNode<N extends t.Node>(node: N) {\n  if (node == null || typeof node !== \"object\") return;\n  const fields = NODE_FIELDS[node.type];\n  if (!fields) return;\n\n  // todo: because keys not in BUILDER_KEYS are not validated - this actually allows invalid nodes in some cases\n  const keys = BUILDER_KEYS[node.type] as (keyof N & string)[];\n  for (const key of keys) {\n    const field = fields[key];\n    if (field != null) validateInternal(field, node, key, node[key]);\n  }\n  return node;\n}\n"],"mappings":";;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAEe,SAASE,YAAYA,CAAmBC,IAAO,EAAE;EAC9D,IAAIA,IAAI,IAAI,IAAI,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;EAC9C,MAAMC,MAAM,GAAGC,kBAAW,CAACF,IAAI,CAACG,IAAI,CAAC;EACrC,IAAI,CAACF,MAAM,EAAE;EAGb,MAAMG,IAAI,GAAGC,mBAAY,CAACL,IAAI,CAACG,IAAI,CAAyB;EAC5D,KAAK,MAAMG,GAAG,IAAIF,IAAI,EAAE;IACtB,MAAMG,KAAK,GAAGN,MAAM,CAACK,GAAG,CAAC;IACzB,IAAIC,KAAK,IAAI,IAAI,EAAE,IAAAC,0BAAgB,EAACD,KAAK,EAAEP,IAAI,EAAEM,GAAG,EAAEN,IAAI,CAACM,GAAG,CAAC,CAAC;EAClE;EACA,OAAON,IAAI;AACb","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/clone/clone.js
+++ b/ui/node_modules/@babel/types/lib/clone/clone.js
@@ -0,0 +1,12 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = clone;
			
 
				+var _cloneNode = require("./cloneNode.js");
			
 
				+function clone(node) {
			
 
				+  return (0, _cloneNode.default)(node, false);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=clone.js.map
			
--- a/ui/node_modules/@babel/types/lib/clone/clone.js.map
+++ b/ui/node_modules/@babel/types/lib/clone/clone.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_cloneNode","require","clone","node","cloneNode"],"sources":["../../src/clone/clone.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a shallow clone of a `node`, including only\n * properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function clone<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,KAAKA,CAAmBC,IAAO,EAAK;EAC1D,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,CAAC;AAC1C","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/clone/cloneDeep.js
+++ b/ui/node_modules/@babel/types/lib/clone/cloneDeep.js
@@ -0,0 +1,12 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = cloneDeep;
			
 
				+var _cloneNode = require("./cloneNode.js");
			
 
				+function cloneDeep(node) {
			
 
				+  return (0, _cloneNode.default)(node);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=cloneDeep.js.map
			
--- a/ui/node_modules/@babel/types/lib/clone/cloneDeep.js.map
+++ b/ui/node_modules/@babel/types/lib/clone/cloneDeep.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_cloneNode","require","cloneDeep","node","cloneNode"],"sources":["../../src/clone/cloneDeep.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * @deprecated Use t.cloneNode instead.\n */\nexport default function cloneDeep<T extends t.Node>(node: T): T {\n  return cloneNode(node);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQe,SAASC,SAASA,CAAmBC,IAAO,EAAK;EAC9D,OAAO,IAAAC,kBAAS,EAACD,IAAI,CAAC;AACxB","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
+++ b/ui/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js
@@ -0,0 +1,12 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = cloneDeepWithoutLoc;
			
 
				+var _cloneNode = require("./cloneNode.js");
			
 
				+function cloneDeepWithoutLoc(node) {
			
 
				+  return (0, _cloneNode.default)(node, true, true);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=cloneDeepWithoutLoc.js.map
			
--- a/ui/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js.map
+++ b/ui/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_cloneNode","require","cloneDeepWithoutLoc","node","cloneNode"],"sources":["../../src/clone/cloneDeepWithoutLoc.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n/**\n * Create a deep clone of a `node` and all of it's child nodes\n * including only properties belonging to the node.\n * excluding `_private` and location properties.\n */\nexport default function cloneDeepWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ true, /* withoutLoc */ true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAOe,SAASC,mBAAmBA,CAAmBC,IAAO,EAAK;EACxE,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,IAAI,EAAmB,IAAI,CAAC;AAChE","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/clone/cloneNode.js
+++ b/ui/node_modules/@babel/types/lib/clone/cloneNode.js
@@ -0,0 +1,107 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = cloneNode;
			
 
				+var _index = require("../definitions/index.js");
			
 
				+var _index2 = require("../validators/generated/index.js");
			
 
				+const {
			
 
				+  hasOwn
			
 
				+} = {
			
 
				+  hasOwn: Function.call.bind(Object.prototype.hasOwnProperty)
			
 
				+};
			
 
				+function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
			
 
				+  if (obj && typeof obj.type === "string") {
			
 
				+    return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
			
 
				+  }
			
 
				+  return obj;
			
 
				+}
			
 
				+function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
			
 
				+  if (Array.isArray(obj)) {
			
 
				+    return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));
			
 
				+  }
			
 
				+  return cloneIfNode(obj, deep, withoutLoc, commentsCache);
			
 
				+}
			
 
				+function cloneNode(node, deep = true, withoutLoc = false) {
			
 
				+  return cloneNodeInternal(node, deep, withoutLoc, new Map());
			
 
				+}
			
 
				+function cloneNodeInternal(node, deep = true, withoutLoc = false, commentsCache) {
			
 
				+  if (!node) return node;
			
 
				+  const {
			
 
				+    type
			
 
				+  } = node;
			
 
				+  const newNode = {
			
 
				+    type: node.type
			
 
				+  };
			
 
				+  if ((0, _index2.isIdentifier)(node)) {
			
 
				+    newNode.name = node.name;
			
 
				+    if (hasOwn(node, "optional") && typeof node.optional === "boolean") {
			
 
				+      newNode.optional = node.optional;
			
 
				+    }
			
 
				+    if (hasOwn(node, "typeAnnotation")) {
			
 
				+      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc, commentsCache) : node.typeAnnotation;
			
 
				+    }
			
 
				+    if (hasOwn(node, "decorators")) {
			
 
				+      newNode.decorators = deep ? cloneIfNodeOrArray(node.decorators, true, withoutLoc, commentsCache) : node.decorators;
			
 
				+    }
			
 
				+  } else if (!hasOwn(_index.NODE_FIELDS, type)) {
			
 
				+    throw new Error(`Unknown node type: "${type}"`);
			
 
				+  } else {
			
 
				+    for (const field of Object.keys(_index.NODE_FIELDS[type])) {
			
 
				+      if (hasOwn(node, field)) {
			
 
				+        if (deep) {
			
 
				+          newNode[field] = (0, _index2.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc, commentsCache) : cloneIfNodeOrArray(node[field], true, withoutLoc, commentsCache);
			
 
				+        } else {
			
 
				+          newNode[field] = node[field];
			
 
				+        }
			
 
				+      }
			
 
				+    }
			
 
				+  }
			
 
				+  if (hasOwn(node, "loc")) {
			
 
				+    if (withoutLoc) {
			
 
				+      newNode.loc = null;
			
 
				+    } else {
			
 
				+      newNode.loc = node.loc;
			
 
				+    }
			
 
				+  }
			
 
				+  if (hasOwn(node, "leadingComments")) {
			
 
				+    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc, commentsCache);
			
 
				+  }
			
 
				+  if (hasOwn(node, "innerComments")) {
			
 
				+    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc, commentsCache);
			
 
				+  }
			
 
				+  if (hasOwn(node, "trailingComments")) {
			
 
				+    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc, commentsCache);
			
 
				+  }
			
 
				+  if (hasOwn(node, "extra")) {
			
 
				+    newNode.extra = Object.assign({}, node.extra);
			
 
				+  }
			
 
				+  return newNode;
			
 
				+}
			
 
				+function maybeCloneComments(comments, deep, withoutLoc, commentsCache) {
			
 
				+  if (!comments || !deep) {
			
 
				+    return comments;
			
 
				+  }
			
 
				+  return comments.map(comment => {
			
 
				+    const cache = commentsCache.get(comment);
			
 
				+    if (cache) return cache;
			
 
				+    const {
			
 
				+      type,
			
 
				+      value,
			
 
				+      loc
			
 
				+    } = comment;
			
 
				+    const ret = {
			
 
				+      type,
			
 
				+      value,
			
 
				+      loc
			
 
				+    };
			
 
				+    if (withoutLoc) {
			
 
				+      ret.loc = null;
			
 
				+    }
			
 
				+    commentsCache.set(comment, ret);
			
 
				+    return ret;
			
 
				+  });
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=cloneNode.js.map
			
--- a/ui/node_modules/@babel/types/lib/clone/cloneNode.js.map
+++ b/ui/node_modules/@babel/types/lib/clone/cloneNode.js.map
--- a/ui/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
+++ b/ui/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js
@@ -0,0 +1,12 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = cloneWithoutLoc;
			
 
				+var _cloneNode = require("./cloneNode.js");
			
 
				+function cloneWithoutLoc(node) {
			
 
				+  return (0, _cloneNode.default)(node, false, true);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=cloneWithoutLoc.js.map
			
--- a/ui/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js.map
+++ b/ui/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_cloneNode","require","cloneWithoutLoc","node","cloneNode"],"sources":["../../src/clone/cloneWithoutLoc.ts"],"sourcesContent":["import cloneNode from \"./cloneNode.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Create a shallow clone of a `node` excluding `_private` and location properties.\n */\nexport default function cloneWithoutLoc<T extends t.Node>(node: T): T {\n  return cloneNode(node, /* deep */ false, /* withoutLoc */ true);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAMe,SAASC,eAAeA,CAAmBC,IAAO,EAAK;EACpE,OAAO,IAAAC,kBAAS,EAACD,IAAI,EAAa,KAAK,EAAmB,IAAI,CAAC;AACjE","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/comments/addComment.js
+++ b/ui/node_modules/@babel/types/lib/comments/addComment.js
@@ -0,0 +1,15 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = addComment;
			
 
				+var _addComments = require("./addComments.js");
			
 
				+function addComment(node, type, content, line) {
			
 
				+  return (0, _addComments.default)(node, type, [{
			
 
				+    type: line ? "CommentLine" : "CommentBlock",
			
 
				+    value: content
			
 
				+  }]);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=addComment.js.map
			
--- a/ui/node_modules/@babel/types/lib/comments/addComment.js.map
+++ b/ui/node_modules/@babel/types/lib/comments/addComment.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_addComments","require","addComment","node","type","content","line","addComments","value"],"sources":["../../src/comments/addComment.ts"],"sourcesContent":["import addComments from \"./addComments.ts\";\nimport type * as t from \"../index.ts\";\n\n/**\n * Add comment of certain type to a node.\n */\nexport default function addComment<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  content: string,\n  line?: boolean,\n): T {\n  return addComments(node, type, [\n    {\n      type: line ? \"CommentLine\" : \"CommentBlock\",\n      value: content,\n    } as t.Comment,\n  ]);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,YAAA,GAAAC,OAAA;AAMe,SAASC,UAAUA,CAChCC,IAAO,EACPC,IAA4B,EAC5BC,OAAe,EACfC,IAAc,EACX;EACH,OAAO,IAAAC,oBAAW,EAACJ,IAAI,EAAEC,IAAI,EAAE,CAC7B;IACEA,IAAI,EAAEE,IAAI,GAAG,aAAa,GAAG,cAAc;IAC3CE,KAAK,EAAEH;EACT,CAAC,CACF,CAAC;AACJ","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/comments/addComments.js
+++ b/ui/node_modules/@babel/types/lib/comments/addComments.js
@@ -0,0 +1,22 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = addComments;
			
 
				+function addComments(node, type, comments) {
			
 
				+  if (!comments || !node) return node;
			
 
				+  const key = `${type}Comments`;
			
 
				+  if (node[key]) {
			
 
				+    if (type === "leading") {
			
 
				+      node[key] = comments.concat(node[key]);
			
 
				+    } else {
			
 
				+      node[key].push(...comments);
			
 
				+    }
			
 
				+  } else {
			
 
				+    node[key] = comments;
			
 
				+  }
			
 
				+  return node;
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=addComments.js.map
			
--- a/ui/node_modules/@babel/types/lib/comments/addComments.js.map
+++ b/ui/node_modules/@babel/types/lib/comments/addComments.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["addComments","node","type","comments","key","concat","push"],"sources":["../../src/comments/addComments.ts"],"sourcesContent":["import type * as t from \"../index.ts\";\n\n/**\n * Add comments of certain type to a node.\n */\nexport default function addComments<T extends t.Node>(\n  node: T,\n  type: t.CommentTypeShorthand,\n  comments: t.Comment[],\n): T {\n  if (!comments || !node) return node;\n\n  const key = `${type}Comments` as const;\n\n  if (node[key]) {\n    if (type === \"leading\") {\n      node[key] = comments.concat(node[key]);\n    } else {\n      node[key].push(...comments);\n    }\n  } else {\n    node[key] = comments;\n  }\n\n  return node;\n}\n"],"mappings":";;;;;;AAKe,SAASA,WAAWA,CACjCC,IAAO,EACPC,IAA4B,EAC5BC,QAAqB,EAClB;EACH,IAAI,CAACA,QAAQ,IAAI,CAACF,IAAI,EAAE,OAAOA,IAAI;EAEnC,MAAMG,GAAG,GAAG,GAAGF,IAAI,UAAmB;EAEtC,IAAID,IAAI,CAACG,GAAG,CAAC,EAAE;IACb,IAAIF,IAAI,KAAK,SAAS,EAAE;MACtBD,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ,CAACE,MAAM,CAACJ,IAAI,CAACG,GAAG,CAAC,CAAC;IACxC,CAAC,MAAM;MACLH,IAAI,CAACG,GAAG,CAAC,CAACE,IAAI,CAAC,GAAGH,QAAQ,CAAC;IAC7B;EACF,CAAC,MAAM;IACLF,IAAI,CAACG,GAAG,CAAC,GAAGD,QAAQ;EACtB;EAEA,OAAOF,IAAI;AACb","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/comments/inheritInnerComments.js
+++ b/ui/node_modules/@babel/types/lib/comments/inheritInnerComments.js
@@ -0,0 +1,12 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = inheritInnerComments;
			
 
				+var _inherit = require("../utils/inherit.js");
			
 
				+function inheritInnerComments(child, parent) {
			
 
				+  (0, _inherit.default)("innerComments", child, parent);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=inheritInnerComments.js.map
			
--- a/ui/node_modules/@babel/types/lib/comments/inheritInnerComments.js.map
+++ b/ui/node_modules/@babel/types/lib/comments/inheritInnerComments.js.map
@@ -0,0 +1 @@
 
				+{"version":3,"names":["_inherit","require","inheritInnerComments","child","parent","inherit"],"sources":["../../src/comments/inheritInnerComments.ts"],"sourcesContent":["import inherit from \"../utils/inherit.ts\";\nimport type * as t from \"../index.ts\";\n\nexport default function inheritInnerComments(\n  child: t.Node,\n  parent: t.Node,\n): void {\n  inherit(\"innerComments\", child, parent);\n}\n"],"mappings":";;;;;;AAAA,IAAAA,QAAA,GAAAC,OAAA;AAGe,SAASC,oBAAoBA,CAC1CC,KAAa,EACbC,MAAc,EACR;EACN,IAAAC,gBAAO,EAAC,eAAe,EAAEF,KAAK,EAAEC,MAAM,CAAC;AACzC","ignoreList":[]}
			
--- a/ui/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
+++ b/ui/node_modules/@babel/types/lib/comments/inheritLeadingComments.js
@@ -0,0 +1,12 @@
 
				+"use strict";
			
 
				+
			
 
				+Object.defineProperty(exports, "__esModule", {
			
 
				+  value: true
			
 
				+});
			
 
				+exports.default = inheritLeadingComments;
			
 
				+var _inherit = require("../utils/inherit.js");
			
 
				+function inheritLeadingComments(child, parent) {
			
 
				+  (0, _inherit.default)("leadingComments", child, parent);
			
 
				+}
			
 
				+
			
 
				+//# sourceMappingURL=inheritLeadingComments.js.map