chore: add debug scripts

.gitattributes

@@ -1,8 +0,0 @@
-* text=auto
-*.sh text eol=lf
-*.js text eol=lf
-*.ts text eol=lf
-*.json text eol=lf
-*.md text eol=lf
-*.html text eol=lf
-*.css text eol=lf

.gitignore

@@ -1,3 +0,0 @@
-/dist
-/public
-/logs

.prettierrc

@@ -1,20 +0,0 @@
-{
-  "semi": true,
-  "singleQuote": true,
-  "printWidth": 80,
-  "tabWidth": 2,
-  "useTabs": false,
-  "quoteProps": "as-needed",
-  "jsxSingleQuote": false,
-  "bracketSpacing": true,
-  "objectWrap": "preserve",
-  "arrowParens": "always",
-  "trailingComma": "es5",
-  "proseWrap": "preserve",
-  "htmlWhitespaceSensitivity": "css",
-  "embeddedLanguageFormatting": "auto",
-  "singleAttributePerLine": false,
-  "endOfLine": "lf",
-  "experimentalTernaries": true,
-  "bracketSameLine": true
-}

README.md

@@ -21,76 +21,30 @@ COD Tracker provides a clean interface to fetch, display, and export Call of Dut
 
 - [Node.js](https://nodejs.org/) (v14.x or higher)
 - npm (comes with Node.js)
-- Call of Duty account with API security settings set to "ALL"
+- Call of Duty account with API security settings set to "Open"
 
 ## Authentication Setup
 
-<!-- <div align="center">
+1. Log in to [Call of Duty](https://profile.callofduty.com)
-  <img src="https://img.shields.io/badge/IMPORTANT-Authentication_Required-red" alt="Authentication Required"/>
+2. Open developer tools (F12)
-</div> -->
+3. Navigate to: Application → Storage → Cookies → https://www.callofduty.com/
-
+4. Copy the value of `ACT_SSO_COOKIE`
-### Changing Account API Privacy Settings
+5. Provide this value when prompted by the tool
-
-To use this application, you need to update your Call of Duty profile settings:
-
-1. Log in to [Call of Duty](https://profile.callofduty.com/cod/profile)
-2. Navigate to the **Privacy & Security** tab
-3. Scroll down to **Game Data and Profile Privacy** section
-4. Set the following options to **ALL**:
-   - Game Tag Searchable
-   - Game Play Data
-
-### Obtaining Your SSO Token
-
-<table>
-<tr></tr>
-<td width="60%">
-
-The application requires an authentication token to access the Call of Duty API:
-
-1. Log in to [Call of Duty](https://profile.callofduty.com/cod/profile)
-2. Open developer tools (F12 or right-click → Inspect)
-3. Navigate to: **Application** → **Storage** → **Cookies** → **<https://profile.callofduty.com>**
-4. Find and copy the value of `ACT_SSO_COOKIE`
-5. Paste this token into the "SSO Token" field
-
-> ⚠️ **Note**: Your SSO token is sensitive information. Never share it publicly.
-
-</td>
-<td width="40%">
-
-```plaintext
-Application
- └─ Storage
-    └─ Cookies
-       └─ ACT_SSO_COOKIE
-```
-
-</td>
-</tr>
-</table>
-
-### Token Expiration
-
-The SSO token typically expires after 24 hours. If you encounter authentication errors, repeat Step 2 to obtain a fresh token.
 
 ## Installation
 
 1. Clone the repository:
-
    ```bash
    git clone https://git.rimmyscorner.com/Rim/codtracker-js.git && cd codtracker-js
    ```
 
 2. Start the application:
-
    ```bash
-   npm run start
+   node app.js
    ```
 
 3. Open your browser and navigate to:
-
+   ```
-   ```bash
    http://127.0.0.1:3513
    ```
 

debug/build_v1.js

@@ -0,0 +1,360 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+const terser = require('terser');
+const csso = require('csso');
+const htmlmin = require('html-minifier');
+
+// Configuration
+const config = {
+  rootJs: {
+    src: 'app.js',
+    exclude: ['*.min.js', 'build*.js'],
+    outputExt: '.min.js'
+  },
+  js: {
+    src: 'src/**/*.js',
+    exclude: 'src/**/*.min.js',
+    outputExt: '.min.js'
+  },
+  css: {
+    src: 'src/**/*.css',
+    exclude: 'src/**/*.min.css',
+    outputExt: '.min.css'
+  },
+  json: {
+    src: ['src/**/*.json', './package.json', './package-lock.json']
+  },
+  html: {
+    src: 'src/**/*.html'
+  },
+  images: {
+    src: 'src/**/*.+(png|jpg|jpeg|gif|svg|ico)'
+  },
+  typescript: {
+    src: 'src/**/*.+(ts|ts.map|d.ts)'
+  },
+  // Add all files that might contain references
+  allFiles: {
+    src: ['./*.js', 'src/**/*.js', 'src/**/*.html', 'src/**/*.css', 'src/**/*.json']
+  }
+};
+
+// Ensure directory exists
+function ensureDirectoryExistence(filePath) {
+  const dirname = path.dirname(filePath);
+  if (fs.existsSync(dirname)) return;
+  ensureDirectoryExistence(dirname);
+  fs.mkdirSync(dirname);
+}
+
+// Clean public directory
+function cleanPublicDir() {
+  console.log('Cleaning public directory...');
+  if (fs.existsSync('public')) {
+    fs.rmSync('public', { recursive: true, force: true });
+  }
+  fs.mkdirSync('public');
+  console.log('✓ Public directory cleaned');
+}
+
+// Create output path preserving directory structure
+function createOutputPath(file, baseDir, outputExt = null) {
+  // Get relative path from the source root
+  const relativePath = path.relative(baseDir, file);
+  
+  // Create public path with the same relative structure
+  let outputPath = path.join('public', relativePath);
+  
+  // Apply output extension if provided
+  if (outputExt) {
+    outputPath = outputPath.replace(path.extname(outputPath), outputExt);
+  }
+  
+  return outputPath;
+}
+
+// Minify JavaScript files
+async function minifyJS() {
+  console.log('Minifying JavaScript files...');
+  
+  // Minify root-level JS files (like app.js)
+  const rootFiles = glob.sync(config.rootJs.src, { ignore: config.rootJs.exclude });
+  
+  for (const file of rootFiles) {
+    // Skip already minified files
+    if (file.endsWith('.min.js')) continue;
+    
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const result = await terser.minify(content, {
+        compress: true,
+        mangle: true
+      });
+      
+      const outputPath = createOutputPath(file, '.', config.rootJs.outputExt);
+      ensureDirectoryExistence(outputPath);
+      fs.writeFileSync(outputPath, result.code);
+      console.log(`✓ Minified: ${file} -> ${outputPath}`);
+    } catch (err) {
+      console.error(`Error minifying ${file}:`, err);
+    }
+  }
+  
+  // Minify JavaScript files in src directory
+  const srcFiles = glob.sync(config.js.src, { ignore: config.js.exclude });
+  
+  for (const file of srcFiles) {
+    // Skip already minified files
+    if (file.endsWith('.min.js')) continue;
+    
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const result = await terser.minify(content, {
+        compress: true,
+        mangle: true
+      });
+      
+      const outputPath = createOutputPath(file, '.', config.js.outputExt);
+      ensureDirectoryExistence(outputPath);
+      fs.writeFileSync(outputPath, result.code);
+      console.log(`✓ Minified: ${file} -> ${outputPath}`);
+    } catch (err) {
+      console.error(`Error minifying ${file}:`, err);
+    }
+  }
+}
+
+// Minify CSS files
+function minifyCSS() {
+  console.log('Minifying CSS files...');
+  const files = glob.sync(config.css.src, { ignore: config.css.exclude });
+  
+  for (const file of files) {
+    if (file.endsWith('.min.css')) continue;
+    
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const result = csso.minify(content);
+      
+      const outputPath = createOutputPath(file, '.', config.css.outputExt);
+      ensureDirectoryExistence(outputPath);
+      fs.writeFileSync(outputPath, result.css);
+      console.log(`✓ Minified: ${file} -> ${outputPath}`);
+    } catch (err) {
+      console.error(`Error minifying ${file}:`, err);
+    }
+  }
+}
+
+// Minify JSON files
+function minifyJSON() {
+  console.log('Minifying JSON files...');
+  const files = glob.sync(config.json.src);
+  
+  for (const file of files) {
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const jsonData = JSON.parse(content);
+      const minified = JSON.stringify(jsonData);
+      
+      const outputPath = createOutputPath(file, '.');
+      ensureDirectoryExistence(outputPath);
+      fs.writeFileSync(outputPath, minified);
+      console.log(`✓ Minified: ${file} -> ${outputPath}`);
+    } catch (err) {
+      console.error(`Error minifying ${file}:`, err);
+    }
+  }
+}
+
+// Minify HTML files
+function minifyHTML() {
+  console.log('Minifying HTML files...');
+  const files = glob.sync(config.html.src);
+  
+  for (const file of files) {
+    try {
+      let content = fs.readFileSync(file, 'utf8');
+      
+      // Minify HTML
+      const minified = htmlmin.minify(content, {
+        collapseWhitespace: true,
+        removeComments: true,
+        minifyJS: true,
+        minifyCSS: true,
+        removeRedundantAttributes: true,
+        removeEmptyAttributes: true,
+        removeOptionalTags: true
+      });
+      
+      const outputPath = createOutputPath(file, '.');
+      ensureDirectoryExistence(outputPath);
+      fs.writeFileSync(outputPath, minified);
+      console.log(`✓ Minified: ${file} -> ${outputPath}`);
+    } catch (err) {
+      console.error(`Error minifying ${file}:`, err);
+    }
+  }
+}
+
+// Copy images
+function copyImages() {
+  console.log('Copying images...');
+  const files = glob.sync(config.images.src);
+  
+  for (const file of files) {
+    try {
+      const outputPath = createOutputPath(file, '.');
+      ensureDirectoryExistence(outputPath);
+      fs.copyFileSync(file, outputPath);
+      console.log(`✓ Copied: ${file} -> ${outputPath}`);
+    } catch (err) {
+      console.error(`Error copying ${file}:`, err);
+    }
+  }
+}
+
+// Copy TypeScript files
+function copyTypeScriptFiles() {
+  console.log('Copying TypeScript files...');
+  const files = glob.sync(config.typescript.src);
+  
+  for (const file of files) {
+    try {
+      const outputPath = createOutputPath(file, '.');
+      ensureDirectoryExistence(outputPath);
+      fs.copyFileSync(file, outputPath);
+      console.log(`✓ Copied: ${file} -> ${outputPath}`);
+    } catch (err) {
+      console.error(`Error copying ${file}:`, err);
+    }
+  }
+}
+
+// Update all file references in all files
+function updateAllReferences() {
+  console.log('Updating file references in all files...');
+  
+  // Get all files that might contain references
+  const files = glob.sync(config.allFiles.src);
+  
+  // Create a list of file mappings (original to minified)
+  const jsFiles = [
+    ...glob.sync(config.rootJs.src, { ignore: config.rootJs.exclude }),
+    ...glob.sync(config.js.src, { ignore: config.js.exclude })
+  ]
+  .filter(file => !file.endsWith('.min.js') && !file.endsWith('.d.ts') && !file.endsWith('.map') && file !== 'build.js');
+  
+  const cssFiles = glob.sync(config.css.src, { ignore: config.css.exclude })
+    .filter(file => !file.endsWith('.min.css'));
+  
+  for (const targetFile of files) {
+    // Skip build.js
+    if (targetFile === 'build.js' || targetFile.includes('build_v')) continue;
+    
+    // Skip files that likely don't have references or are already processed
+    if (targetFile.endsWith('.min.js') || targetFile.endsWith('.d.ts') || 
+        targetFile.endsWith('.map') || targetFile.endsWith('.min.css')) continue;
+    
+    try {
+      let content = fs.readFileSync(targetFile, 'utf8');
+      let modified = false;
+      
+      // Replace JS file references
+      for (const jsFile of jsFiles) {
+        // Get different forms of the path for replacement
+        const normalizedPath = jsFile.replace(/\\/g, '/');  // Convert backslashes to forward slashes
+        const relativePath = './' + normalizedPath;  // With leading ./
+        const plainPath = normalizedPath;  // Without leading ./
+        const fileNameOnly = path.basename(normalizedPath);  // Just the filename
+        
+        // Create minified versions of each path form
+        const normalizedPathMin = normalizedPath.replace('.js', '.min.js');
+        const relativePathMin = relativePath.replace('.js', '.min.js');
+        const plainPathMin = plainPath.replace('.js', '.min.js');
+        const fileNameOnlyMin = fileNameOnly.replace('.js', '.min.js');
+        
+        // Attempt different path styles replacements
+        if (content.includes(relativePath)) {
+          content = content.replace(new RegExp(escapeRegExp(relativePath), 'g'), relativePathMin);
+          modified = true;
+        }
+        if (content.includes(plainPath)) {
+          content = content.replace(new RegExp(escapeRegExp(plainPath), 'g'), plainPathMin);
+          modified = true;
+        }
+        if (content.includes(fileNameOnly) && fileNameOnly !== 'index.js') { // Be careful with just filenames
+          content = content.replace(new RegExp(`(['"\\s])${escapeRegExp(fileNameOnly)}(['"\\s])`, 'g'), 
+                                    `$1${fileNameOnlyMin}$2`);
+          modified = true;
+        }
+      }
+      
+      // Replace CSS file references
+      for (const cssFile of cssFiles) {
+        const normalizedPath = cssFile.replace(/\\/g, '/');
+        const relativePath = './' + normalizedPath;
+        const plainPath = normalizedPath;
+        const fileNameOnly = path.basename(normalizedPath);
+        
+        const normalizedPathMin = normalizedPath.replace('.css', '.min.css');
+        const relativePathMin = relativePath.replace('.css', '.min.css');
+        const plainPathMin = plainPath.replace('.css', '.min.css');
+        const fileNameOnlyMin = fileNameOnly.replace('.css', '.min.css');
+        
+        if (content.includes(relativePath)) {
+          content = content.replace(new RegExp(escapeRegExp(relativePath), 'g'), relativePathMin);
+          modified = true;
+        }
+        if (content.includes(plainPath)) {
+          content = content.replace(new RegExp(escapeRegExp(plainPath), 'g'), plainPathMin);
+          modified = true;
+        }
+        if (content.includes(fileNameOnly) && fileNameOnly !== 'styles.css') { // Be careful with just filenames
+          content = content.replace(new RegExp(`(['"\\s])${escapeRegExp(fileNameOnly)}(['"\\s])`, 'g'), 
+                                    `$1${fileNameOnlyMin}$2`);
+          modified = true;
+        }
+      }
+      
+      if (modified) {
+        // Write updated content to the public version
+        const outputPath = createOutputPath(targetFile, '.', 
+                          targetFile.endsWith('.js') ? config.js.outputExt : 
+                          targetFile.endsWith('.css') ? config.css.outputExt : null);
+        fs.writeFileSync(outputPath, content);
+        console.log(`✓ Updated references in: ${outputPath}`);
+      }
+    } catch (err) {
+      console.error(`Error updating references in ${targetFile}:`, err);
+    }
+  }
+}
+
+// Helper function to escape special characters in a string for use in RegExp
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Main function
+async function build() {
+  console.log('Starting build process...');
+  
+  cleanPublicDir();
+  await minifyJS();
+  minifyCSS();
+  minifyJSON();
+  minifyHTML();
+  copyImages();
+  copyTypeScriptFiles();
+  updateAllReferences();
+  
+  console.log('Build completed successfully!');
+}
+
+// Run the build
+build().catch(err => {
+  console.error('Build failed:', err);
+  process.exit(1);
+});

debug/build_v2.js

@@ -0,0 +1,234 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+const terser = require('terser');
+const csso = require('csso');
+const htmlmin = require('html-minifier');
+
+// Configuration
+const config = {
+  rootJs: {
+    src: './*.js',
+    exclude: './*.min.js',
+    outputExt: '.min.js'
+  },
+  js: {
+    src: 'src/**/*.js',
+    exclude: 'src/**/*.min.js',
+    outputExt: '.min.js'
+  },
+  css: {
+    src: 'src/**/*.css',
+    exclude: 'src/**/*.min.css',
+    outputExt: '.min.css'
+  },
+  json: {
+    src: 'src/**/*.json'
+  },
+  html: {
+    src: 'src/**/*.html'
+  },
+  images: {
+    src: 'src/**/*.+(png|jpg|jpeg|gif|svg|ico)'
+  }
+};
+
+// Ensure directory exists
+function ensureDirectoryExistence(filePath) {
+  const dirname = path.dirname(filePath);
+  if (fs.existsSync(dirname)) return;
+  ensureDirectoryExistence(dirname);
+  fs.mkdirSync(dirname);
+}
+
+// Clean public directory
+function cleanPublicDir() {
+  console.log('Cleaning public directory...');
+  if (fs.existsSync('public')) {
+    fs.rmSync('public', { recursive: true, force: true });
+  }
+  fs.mkdirSync('public');
+  console.log('✓ Public directory cleaned');
+}
+
+// Create output path preserving directory structure
+function createOutputPath(file, baseDir, outputExt = null) {
+  // Get relative path from the source root
+  const relativePath = path.relative(baseDir, file);
+  
+  // Create public path with the same relative structure
+  let outputPath = path.join('public', relativePath);
+  
+  // Apply output extension if provided
+  if (outputExt) {
+    outputPath = outputPath.replace(path.extname(outputPath), outputExt);
+  }
+  
+  return outputPath;
+}
+
+// Minify JavaScript files
+async function minifyJS() {
+  console.log('Minifying JavaScript files...');
+  
+  // Minify root-level JS files (like app.js)
+  const rootFiles = glob.sync(config.rootJs.src, { ignore: config.rootJs.exclude });
+  
+  for (const file of rootFiles) {
+    // Skip already minified files and module files
+    if (file.endsWith('.min.js') || file === 'build.js') continue;
+    
+    const content = fs.readFileSync(file, 'utf8');
+    const result = await terser.minify(content, {
+      compress: true,
+      mangle: true
+    });
+    
+    const outputPath = createOutputPath(file, '.', config.rootJs.outputExt);
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, result.code);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+  
+  // Minify JavaScript files in src directory
+  const srcFiles = glob.sync(config.js.src, { ignore: config.js.exclude });
+  
+  for (const file of srcFiles) {
+    // Skip already minified files, type definition, and map files
+    if (file.endsWith('.min.js') || file.endsWith('.d.ts') || file.endsWith('.map')) continue;
+    
+    const content = fs.readFileSync(file, 'utf8');
+    const result = await terser.minify(content, {
+      compress: true,
+      mangle: true
+    });
+    
+    const outputPath = createOutputPath(file, '.', config.js.outputExt);
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, result.code);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Minify CSS files
+function minifyCSS() {
+  console.log('Minifying CSS files...');
+  const files = glob.sync(config.css.src, { ignore: config.css.exclude });
+  
+  for (const file of files) {
+    if (file.endsWith('.min.css')) continue;
+    
+    const content = fs.readFileSync(file, 'utf8');
+    const result = csso.minify(content);
+    
+    const outputPath = createOutputPath(file, '.', config.css.outputExt);
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, result.css);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Minify JSON files
+function minifyJSON() {
+  console.log('Minifying JSON files...');
+  const files = glob.sync(config.json.src);
+  
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+    const jsonData = JSON.parse(content);
+    const minified = JSON.stringify(jsonData);
+    
+    const outputPath = createOutputPath(file, '.');
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, minified);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Minify HTML files and update references
+function minifyHTML() {
+  console.log('Minifying HTML files...');
+  const files = glob.sync(config.html.src);
+  
+  for (const file of files) {
+    let content = fs.readFileSync(file, 'utf8');
+    
+    // Update JS references to minified versions, preserving directory structure
+    content = content.replace(/src=["'](.+?)\.js["']/g, (match, p1) => {
+      return `src="${p1}.min.js"`;
+    });
+    
+    // Update CSS references to minified versions, preserving directory structure
+    content = content.replace(/href=["'](.+?)\.css["']/g, (match, p1) => {
+      return `href="${p1}.min.css"`;
+    });
+    
+    // Minify HTML
+    const minified = htmlmin.minify(content, {
+      collapseWhitespace: true,
+      removeComments: true,
+      minifyJS: true,
+      minifyCSS: true,
+      removeRedundantAttributes: true,
+      removeEmptyAttributes: true,
+      removeOptionalTags: true
+    });
+    
+    const outputPath = createOutputPath(file, '.');
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, minified);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Copy images
+function copyImages() {
+  console.log('Copying images...');
+  const files = glob.sync(config.images.src);
+  
+  for (const file of files) {
+    const outputPath = createOutputPath(file, '.');
+    ensureDirectoryExistence(outputPath);
+    fs.copyFileSync(file, outputPath);
+    console.log(`✓ Copied: ${file} -> ${outputPath}`);
+  }
+}
+
+// Copy other files like README.md
+function copyMiscFiles() {
+  console.log('Copying miscellaneous files...');
+  const filesToCopy = [
+    'README.md',
+    'package.json',
+    'package-lock.json'
+  ];
+  
+  for (const file of filesToCopy) {
+    if (fs.existsSync(file)) {
+      const outputPath = path.join('public', file);
+      fs.copyFileSync(file, outputPath);
+      console.log(`✓ Copied: ${file} -> ${outputPath}`);
+    }
+  }
+}
+
+// Main function
+async function build() {
+  console.log('Starting build process...');
+  
+  cleanPublicDir();
+  await minifyJS();
+  minifyCSS();
+  minifyJSON();
+  minifyHTML();
+  copyImages();
+  copyMiscFiles();
+  
+  console.log('Build completed successfully!');
+}
+
+// Run the build
+build().catch(err => {
+  console.error('Build failed:', err);
+  process.exit(1);
+});

debug/build_v3.js

@@ -0,0 +1,330 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+const terser = require('terser');
+const csso = require('csso');
+const htmlmin = require('html-minifier');
+
+// Configuration
+const config = {
+  rootJs: {
+    src: './*.js',
+    exclude: './*.min.js',
+    outputExt: '.min.js'
+  },
+  js: {
+    src: 'src/**/*.js',
+    exclude: 'src/**/*.min.js',
+    outputExt: '.min.js'
+  },
+  css: {
+    src: 'src/**/*.css',
+    exclude: 'src/**/*.min.css',
+    outputExt: '.min.css'
+  },
+  json: {
+    src: 'src/**/*.json'
+  },
+  html: {
+    src: 'src/**/*.html'
+  },
+  images: {
+    src: 'src/**/*.+(png|jpg|jpeg|gif|svg|ico)'
+  },
+  // Add all files that might contain references
+  allFiles: {
+    src: ['./*.js', 'src/**/*.js', 'src/**/*.html', 'src/**/*.css', 'src/**/*.json']
+  }
+};
+
+// Ensure directory exists
+function ensureDirectoryExistence(filePath) {
+  const dirname = path.dirname(filePath);
+  if (fs.existsSync(dirname)) return;
+  ensureDirectoryExistence(dirname);
+  fs.mkdirSync(dirname);
+}
+
+// Clean public directory
+function cleanPublicDir() {
+  console.log('Cleaning public directory...');
+  if (fs.existsSync('public')) {
+    fs.rmSync('public', { recursive: true, force: true });
+  }
+  fs.mkdirSync('public');
+  console.log('✓ Public directory cleaned');
+}
+
+// Create output path preserving directory structure
+function createOutputPath(file, baseDir, outputExt = null) {
+  // Get relative path from the source root
+  const relativePath = path.relative(baseDir, file);
+  
+  // Create public path with the same relative structure
+  let outputPath = path.join('public', relativePath);
+  
+  // Apply output extension if provided
+  if (outputExt) {
+    outputPath = outputPath.replace(path.extname(outputPath), outputExt);
+  }
+  
+  return outputPath;
+}
+
+// Minify JavaScript files
+async function minifyJS() {
+  console.log('Minifying JavaScript files...');
+  
+  // Minify root-level JS files (like app.js)
+  const rootFiles = glob.sync(config.rootJs.src, { ignore: config.rootJs.exclude });
+  
+  for (const file of rootFiles) {
+    // Skip already minified files and module files
+    if (file.endsWith('.min.js') || file === 'build.js') continue;
+    
+    const content = fs.readFileSync(file, 'utf8');
+    const result = await terser.minify(content, {
+      compress: true,
+      mangle: true
+    });
+    
+    const outputPath = createOutputPath(file, '.', config.rootJs.outputExt);
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, result.code);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+  
+  // Minify JavaScript files in src directory
+  const srcFiles = glob.sync(config.js.src, { ignore: config.js.exclude });
+  
+  for (const file of srcFiles) {
+    // Skip already minified files, type definition, and map files
+    if (file.endsWith('.min.js') || file.endsWith('.d.ts') || file.endsWith('.map')) continue;
+    
+    const content = fs.readFileSync(file, 'utf8');
+    const result = await terser.minify(content, {
+      compress: true,
+      mangle: true
+    });
+    
+    const outputPath = createOutputPath(file, '.', config.js.outputExt);
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, result.code);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Minify CSS files
+function minifyCSS() {
+  console.log('Minifying CSS files...');
+  const files = glob.sync(config.css.src, { ignore: config.css.exclude });
+  
+  for (const file of files) {
+    if (file.endsWith('.min.css')) continue;
+    
+    const content = fs.readFileSync(file, 'utf8');
+    const result = csso.minify(content);
+    
+    const outputPath = createOutputPath(file, '.', config.css.outputExt);
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, result.css);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Minify JSON files
+function minifyJSON() {
+  console.log('Minifying JSON files...');
+  const files = glob.sync(config.json.src);
+  
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+    const jsonData = JSON.parse(content);
+    const minified = JSON.stringify(jsonData);
+    
+    const outputPath = createOutputPath(file, '.');
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, minified);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Minify HTML files
+function minifyHTML() {
+  console.log('Minifying HTML files...');
+  const files = glob.sync(config.html.src);
+  
+  for (const file of files) {
+    let content = fs.readFileSync(file, 'utf8');
+    
+    // Minify HTML
+    const minified = htmlmin.minify(content, {
+      collapseWhitespace: true,
+      removeComments: true,
+      minifyJS: true,
+      minifyCSS: true,
+      removeRedundantAttributes: true,
+      removeEmptyAttributes: true,
+      removeOptionalTags: true
+    });
+    
+    const outputPath = createOutputPath(file, '.');
+    ensureDirectoryExistence(outputPath);
+    fs.writeFileSync(outputPath, minified);
+    console.log(`✓ Minified: ${file} -> ${outputPath}`);
+  }
+}
+
+// Copy images
+function copyImages() {
+  console.log('Copying images...');
+  const files = glob.sync(config.images.src);
+  
+  for (const file of files) {
+    const outputPath = createOutputPath(file, '.');
+    ensureDirectoryExistence(outputPath);
+    fs.copyFileSync(file, outputPath);
+    console.log(`✓ Copied: ${file} -> ${outputPath}`);
+  }
+}
+
+// Copy other files like README.md
+function copyMiscFiles() {
+  console.log('Copying miscellaneous files...');
+  const filesToCopy = [
+    'README.md',
+    'package.json',
+    'package-lock.json'
+  ];
+  
+  for (const file of filesToCopy) {
+    if (fs.existsSync(file)) {
+      const outputPath = path.join('public', file);
+      fs.copyFileSync(file, outputPath);
+      console.log(`✓ Copied: ${file} -> ${outputPath}`);
+    }
+  }
+}
+
+// Update all file references in all files
+function updateAllReferences() {
+  console.log('Updating file references in all files...');
+  
+  // Get all files that might contain references
+  const files = glob.sync(config.allFiles.src);
+  
+  // Create a list of file mappings (original to minified)
+  const jsFiles = [
+    ...glob.sync(config.rootJs.src, { ignore: config.rootJs.exclude }),
+    ...glob.sync(config.js.src, { ignore: config.js.exclude })
+  ]
+  .filter(file => !file.endsWith('.min.js') && !file.endsWith('.d.ts') && !file.endsWith('.map') && file !== 'build.js');
+  
+  const cssFiles = glob.sync(config.css.src, { ignore: config.css.exclude })
+    .filter(file => !file.endsWith('.min.css'));
+  
+  for (const targetFile of files) {
+    // Skip build.js
+    if (targetFile === 'build.js') continue;
+    
+    // Skip files that likely don't have references or are already processed
+    if (targetFile.endsWith('.min.js') || targetFile.endsWith('.d.ts') || 
+        targetFile.endsWith('.map') || targetFile.endsWith('.min.css')) continue;
+    
+    let content = fs.readFileSync(targetFile, 'utf8');
+    let modified = false;
+    
+    // Replace JS file references
+    for (const jsFile of jsFiles) {
+      // Get different forms of the path for replacement
+      const normalizedPath = jsFile.replace(/\\/g, '/');  // Convert backslashes to forward slashes
+      const relativePath = './' + normalizedPath;  // With leading ./
+      const plainPath = normalizedPath;  // Without leading ./
+      const fileNameOnly = path.basename(normalizedPath);  // Just the filename
+      
+      // Create minified versions of each path form
+      const normalizedPathMin = normalizedPath.replace('.js', '.min.js');
+      const relativePathMin = relativePath.replace('.js', '.min.js');
+      const plainPathMin = plainPath.replace('.js', '.min.js');
+      const fileNameOnlyMin = fileNameOnly.replace('.js', '.min.js');
+      
+      // Attempt different path styles replacements
+      if (content.includes(relativePath)) {
+        content = content.replace(new RegExp(escapeRegExp(relativePath), 'g'), relativePathMin);
+        modified = true;
+      }
+      if (content.includes(plainPath)) {
+        content = content.replace(new RegExp(escapeRegExp(plainPath), 'g'), plainPathMin);
+        modified = true;
+      }
+      if (content.includes(fileNameOnly) && fileNameOnly !== 'index.js') { // Be careful with just filenames
+        content = content.replace(new RegExp(`(['"\\s])${escapeRegExp(fileNameOnly)}(['"\\s])`, 'g'), 
+                                  `$1${fileNameOnlyMin}$2`);
+        modified = true;
+      }
+    }
+    
+    // Replace CSS file references
+    for (const cssFile of cssFiles) {
+      const normalizedPath = cssFile.replace(/\\/g, '/');
+      const relativePath = './' + normalizedPath;
+      const plainPath = normalizedPath;
+      const fileNameOnly = path.basename(normalizedPath);
+      
+      const normalizedPathMin = normalizedPath.replace('.css', '.min.css');
+      const relativePathMin = relativePath.replace('.css', '.min.css');
+      const plainPathMin = plainPath.replace('.css', '.min.css');
+      const fileNameOnlyMin = fileNameOnly.replace('.css', '.min.css');
+      
+      if (content.includes(relativePath)) {
+        content = content.replace(new RegExp(escapeRegExp(relativePath), 'g'), relativePathMin);
+        modified = true;
+      }
+      if (content.includes(plainPath)) {
+        content = content.replace(new RegExp(escapeRegExp(plainPath), 'g'), plainPathMin);
+        modified = true;
+      }
+      if (content.includes(fileNameOnly) && fileNameOnly !== 'styles.css') { // Be careful with just filenames
+        content = content.replace(new RegExp(`(['"\\s])${escapeRegExp(fileNameOnly)}(['"\\s])`, 'g'), 
+                                  `$1${fileNameOnlyMin}$2`);
+        modified = true;
+      }
+    }
+    
+    if (modified) {
+      // Write updated content to the public version
+      const outputPath = createOutputPath(targetFile, '.', 
+                        targetFile.endsWith('.js') ? config.js.outputExt : 
+                        targetFile.endsWith('.css') ? config.css.outputExt : null);
+      fs.writeFileSync(outputPath, content);
+      console.log(`✓ Updated references in: ${outputPath}`);
+    }
+  }
+}
+
+// Helper function to escape special characters in a string for use in RegExp
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// Main function
+async function build() {
+  console.log('Starting build process...');
+  
+  cleanPublicDir();
+  await minifyJS();
+  minifyCSS();
+  minifyJSON();
+  minifyHTML();
+  copyImages();
+  copyMiscFiles();
+  updateAllReferences();
+  
+  console.log('Build completed successfully!');
+}
+
+// Run the build
+build().catch(err => {
+  console.error('Build failed:', err);
+  process.exit(1);
+});

debug/debug-app-js.js

@@ -0,0 +1,7 @@
+const { debugAppJsOnly } = require('./build.js');
+
+// Run only the app.js debug procedure
+debugAppJsOnly().catch(err => {
+  console.error('Debug process failed:', err);
+  process.exit(1);
+});

node_modules/.bin/acorn.cmd

@@ -1,17 +0,0 @@
-@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%\..\acorn\bin\acorn" %*

node_modules/.bin/acorn.ps1

@@ -1,28 +0,0 @@
-#!/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/../acorn/bin/acorn" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../acorn/bin/acorn" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../acorn/bin/acorn" $args
-  } else {
-    & "node$exe"  "$basedir/../acorn/bin/acorn" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/glob.cmd

@@ -1,17 +0,0 @@
-@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%\..\glob\dist\esm\bin.mjs" %*

node_modules/.bin/glob.ps1

@@ -1,28 +0,0 @@
-#!/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/../glob/dist/esm/bin.mjs" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../glob/dist/esm/bin.mjs" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../glob/dist/esm/bin.mjs" $args
-  } else {
-    & "node$exe"  "$basedir/../glob/dist/esm/bin.mjs" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/he.cmd

@@ -1,17 +0,0 @@
-@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%\..\he\bin\he" %*

node_modules/.bin/he.ps1

@@ -1,28 +0,0 @@
-#!/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/../he/bin/he" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../he/bin/he" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../he/bin/he" $args
-  } else {
-    & "node$exe"  "$basedir/../he/bin/he" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/html-minifier.cmd

@@ -1,17 +0,0 @@
-@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%\..\html-minifier\cli.js" %*

node_modules/.bin/html-minifier.ps1

@@ -1,28 +0,0 @@
-#!/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/../html-minifier/cli.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../html-minifier/cli.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../html-minifier/cli.js" $args
-  } else {
-    & "node$exe"  "$basedir/../html-minifier/cli.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/jsesc

@@ -1,16 +0,0 @@
-#!/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/../jsesc/bin/jsesc" "$@"
-else 
-  exec node  "$basedir/../jsesc/bin/jsesc" "$@"
-fi

node_modules/.bin/jsesc.cmd

@@ -1,17 +0,0 @@
-@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%\..\jsesc\bin\jsesc" %*

node_modules/.bin/jsesc.ps1

@@ -1,28 +0,0 @@
-#!/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/../jsesc/bin/jsesc" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../jsesc/bin/jsesc" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../jsesc/bin/jsesc" $args
-  } else {
-    & "node$exe"  "$basedir/../jsesc/bin/jsesc" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/mime.cmd

@@ -1,17 +0,0 @@
-@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%\..\mime\cli.js" %*

node_modules/.bin/mime.ps1

@@ -1,28 +0,0 @@
-#!/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/../mime/cli.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../mime/cli.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../mime/cli.js" $args
-  } else {
-    & "node$exe"  "$basedir/../mime/cli.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/node-which

@@ -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/../which/bin/node-which" "$@"
+else 
+  exec node  "$basedir/../which/bin/node-which" "$@"
+fi

node_modules/.bin/nodemon

@@ -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/../nodemon/bin/nodemon.js" "$@"
+else 
+  exec node  "$basedir/../nodemon/bin/nodemon.js" "$@"
+fi

node_modules/.bin/nodetouch

@@ -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/../touch/bin/nodetouch.js" "$@"
+else 
+  exec node  "$basedir/../touch/bin/nodetouch.js" "$@"
+fi

node_modules/.bin/parser

@@ -1,16 +0,0 @@
-#!/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

node_modules/.bin/parser.cmd

@@ -1,17 +0,0 @@
-@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" %*

node_modules/.bin/parser.ps1

@@ -1,28 +0,0 @@
-#!/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

node_modules/.bin/pkg

@@ -1,16 +0,0 @@
-#!/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/../pkg/lib-es5/bin.js" "$@"
-else 
-  exec node  "$basedir/../pkg/lib-es5/bin.js" "$@"
-fi

node_modules/.bin/pkg-fetch

@@ -1,16 +0,0 @@
-#!/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/../pkg-fetch/lib-es5/bin.js" "$@"
-else 
-  exec node  "$basedir/../pkg-fetch/lib-es5/bin.js" "$@"
-fi

node_modules/.bin/pkg-fetch.cmd

@@ -1,17 +0,0 @@
-@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%\..\pkg-fetch\lib-es5\bin.js" %*

node_modules/.bin/pkg-fetch.ps1

@@ -1,28 +0,0 @@
-#!/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/../pkg-fetch/lib-es5/bin.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../pkg-fetch/lib-es5/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../pkg-fetch/lib-es5/bin.js" $args
-  } else {
-    & "node$exe"  "$basedir/../pkg-fetch/lib-es5/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/pkg.cmd

@@ -1,17 +0,0 @@
-@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%\..\pkg\lib-es5\bin.js" %*

node_modules/.bin/pkg.ps1

@@ -1,28 +0,0 @@
-#!/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/../pkg/lib-es5/bin.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../pkg/lib-es5/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../pkg/lib-es5/bin.js" $args
-  } else {
-    & "node$exe"  "$basedir/../pkg/lib-es5/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/prebuild-install

@@ -1,16 +0,0 @@
-#!/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/../prebuild-install/bin.js" "$@"
-else 
-  exec node  "$basedir/../prebuild-install/bin.js" "$@"
-fi

node_modules/.bin/prebuild-install.cmd

@@ -1,17 +0,0 @@
-@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%\..\prebuild-install\bin.js" %*

node_modules/.bin/prebuild-install.ps1

@@ -1,28 +0,0 @@
-#!/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/../prebuild-install/bin.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../prebuild-install/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../prebuild-install/bin.js" $args
-  } else {
-    & "node$exe"  "$basedir/../prebuild-install/bin.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/prettier

@@ -1,16 +0,0 @@
-#!/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/../prettier/bin/prettier.cjs" "$@"
-else 
-  exec node  "$basedir/../prettier/bin/prettier.cjs" "$@"
-fi

node_modules/.bin/prettier.cmd

@@ -1,17 +0,0 @@
-@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%\..\prettier\bin\prettier.cjs" %*

node_modules/.bin/prettier.ps1

@@ -1,28 +0,0 @@
-#!/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/../prettier/bin/prettier.cjs" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../prettier/bin/prettier.cjs" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../prettier/bin/prettier.cjs" $args
-  } else {
-    & "node$exe"  "$basedir/../prettier/bin/prettier.cjs" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/rc

@@ -1,16 +0,0 @@
-#!/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/../rc/cli.js" "$@"
-else 
-  exec node  "$basedir/../rc/cli.js" "$@"
-fi

node_modules/.bin/rc.cmd

@@ -1,17 +0,0 @@
-@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%\..\rc\cli.js" %*

node_modules/.bin/rc.ps1

@@ -1,28 +0,0 @@
-#!/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/../rc/cli.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../rc/cli.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../rc/cli.js" $args
-  } else {
-    & "node$exe"  "$basedir/../rc/cli.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/replace-in-file

@@ -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/../replace-in-file/bin/cli.js" "$@"
+else 
+  exec node  "$basedir/../replace-in-file/bin/cli.js" "$@"
+fi

node_modules/.bin/resolve

@@ -1,16 +0,0 @@
-#!/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/../resolve/bin/resolve" "$@"
-else 
-  exec node  "$basedir/../resolve/bin/resolve" "$@"
-fi

node_modules/.bin/resolve.cmd

@@ -1,17 +0,0 @@
-@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%\..\resolve\bin\resolve" %*

node_modules/.bin/resolve.ps1

@@ -1,28 +0,0 @@
-#!/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/../resolve/bin/resolve" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../resolve/bin/resolve" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../resolve/bin/resolve" $args
-  } else {
-    & "node$exe"  "$basedir/../resolve/bin/resolve" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/semver.cmd

@@ -1,17 +0,0 @@
-@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%\..\semver\bin\semver.js" %*

node_modules/.bin/semver.ps1

@@ -1,28 +0,0 @@
-#!/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/../semver/bin/semver.js" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../semver/bin/semver.js" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../semver/bin/semver.js" $args
-  } else {
-    & "node$exe"  "$basedir/../semver/bin/semver.js" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/terser.cmd

@@ -1,17 +0,0 @@
-@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%\..\terser\bin\terser" %*

node_modules/.bin/terser.ps1

@@ -1,28 +0,0 @@
-#!/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/../terser/bin/terser" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../terser/bin/terser" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../terser/bin/terser" $args
-  } else {
-    & "node$exe"  "$basedir/../terser/bin/terser" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/.bin/uglifyjs.cmd

@@ -1,17 +0,0 @@
-@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%\..\uglify-js\bin\uglifyjs" %*

node_modules/.bin/uglifyjs.ps1

@@ -1,28 +0,0 @@
-#!/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/../uglify-js/bin/uglifyjs" $args
-  } else {
-    & "$basedir/node$exe"  "$basedir/../uglify-js/bin/uglifyjs" $args
-  }
-  $ret=$LASTEXITCODE
-} else {
-  # Support pipeline input
-  if ($MyInvocation.ExpectingInput) {
-    $input | & "node$exe"  "$basedir/../uglify-js/bin/uglifyjs" $args
-  } else {
-    & "node$exe"  "$basedir/../uglify-js/bin/uglifyjs" $args
-  }
-  $ret=$LASTEXITCODE
-}
-exit $ret

node_modules/@babel/generator/lib/buffer.js

@@ -1,254 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.default = void 0;
-
-function SourcePos() {
-  return {
-    identifierName: undefined,
-    line: undefined,
-    column: undefined,
-    filename: undefined,
-  };
-}
-
-const SPACES_RE = /^[ \t]+$/;
-
-class Buffer {
-  constructor(map) {
-    this._map = null;
-    this._buf = '';
-    this._last = 0;
-    this._queue = [];
-    this._position = {
-      line: 1,
-      column: 0,
-    };
-    this._sourcePosition = SourcePos();
-    this._disallowedPop = null;
-    this._map = map;
-  }
-
-  get() {
-    this._flush();
-
-    const map = this._map;
-    const result = {
-      code: this._buf.trimRight(),
-      decodedMap: map == null ? void 0 : map.getDecoded(),
-
-      get map() {
-        return (result.map = map ? map.get() : null);
-      },
-
-      set map(value) {
-        Object.defineProperty(result, 'map', {
-          value,
-          writable: true,
-        });
-      },
-
-      get rawMappings() {
-        return (result.rawMappings =
-          map == null ? void 0 : map.getRawMappings());
-      },
-
-      set rawMappings(value) {
-        Object.defineProperty(result, 'rawMappings', {
-          value,
-          writable: true,
-        });
-      },
-    };
-    return result;
-  }
-
-  append(str) {
-    this._flush();
-
-    const { line, column, filename, identifierName } = this._sourcePosition;
-
-    this._append(str, line, column, identifierName, filename);
-  }
-
-  queue(str) {
-    if (str === '\n') {
-      while (this._queue.length > 0 && SPACES_RE.test(this._queue[0][0])) {
-        this._queue.shift();
-      }
-    }
-
-    const { line, column, filename, identifierName } = this._sourcePosition;
-
-    this._queue.unshift([str, line, column, identifierName, filename]);
-  }
-
-  queueIndentation(str) {
-    this._queue.unshift([str, undefined, undefined, undefined, undefined]);
-  }
-
-  _flush() {
-    let item;
-
-    while ((item = this._queue.pop())) {
-      this._append(...item);
-    }
-  }
-
-  _append(str, line, column, identifierName, filename) {
-    this._buf += str;
-    this._last = str.charCodeAt(str.length - 1);
-    let i = str.indexOf('\n');
-    let last = 0;
-
-    if (i !== 0) {
-      this._mark(line, column, identifierName, filename);
-    }
-
-    while (i !== -1) {
-      this._position.line++;
-      this._position.column = 0;
-      last = i + 1;
-
-      if (last < str.length) {
-        this._mark(++line, 0, identifierName, filename);
-      }
-
-      i = str.indexOf('\n', last);
-    }
-
-    this._position.column += str.length - last;
-  }
-
-  _mark(line, column, identifierName, filename) {
-    var _this$_map;
-
-    (_this$_map = this._map) == null ?
-      void 0
-    : _this$_map.mark(this._position, line, column, identifierName, filename);
-  }
-
-  removeTrailingNewline() {
-    if (this._queue.length > 0 && this._queue[0][0] === '\n') {
-      this._queue.shift();
-    }
-  }
-
-  removeLastSemicolon() {
-    if (this._queue.length > 0 && this._queue[0][0] === ';') {
-      this._queue.shift();
-    }
-  }
-
-  getLastChar() {
-    let last;
-
-    if (this._queue.length > 0) {
-      const str = this._queue[0][0];
-      last = str.charCodeAt(0);
-    } else {
-      last = this._last;
-    }
-
-    return last;
-  }
-
-  endsWithCharAndNewline() {
-    const queue = this._queue;
-
-    if (queue.length > 0) {
-      const last = queue[0][0];
-      const lastCp = last.charCodeAt(0);
-      if (lastCp !== 10) return;
-
-      if (queue.length > 1) {
-        const secondLast = queue[1][0];
-        return secondLast.charCodeAt(0);
-      } else {
-        return this._last;
-      }
-    }
-  }
-
-  hasContent() {
-    return this._queue.length > 0 || !!this._last;
-  }
-
-  exactSource(loc, cb) {
-    this.source('start', loc);
-    cb();
-    this.source('end', loc);
-
-    this._disallowPop('start', loc);
-  }
-
-  source(prop, loc) {
-    if (prop && !loc) return;
-
-    this._normalizePosition(prop, loc, this._sourcePosition);
-  }
-
-  withSource(prop, loc, cb) {
-    if (!this._map) return cb();
-    const originalLine = this._sourcePosition.line;
-    const originalColumn = this._sourcePosition.column;
-    const originalFilename = this._sourcePosition.filename;
-    const originalIdentifierName = this._sourcePosition.identifierName;
-    this.source(prop, loc);
-    cb();
-
-    if (
-      !this._disallowedPop ||
-      this._disallowedPop.line !== originalLine ||
-      this._disallowedPop.column !== originalColumn ||
-      this._disallowedPop.filename !== originalFilename
-    ) {
-      this._sourcePosition.line = originalLine;
-      this._sourcePosition.column = originalColumn;
-      this._sourcePosition.filename = originalFilename;
-      this._sourcePosition.identifierName = originalIdentifierName;
-      this._disallowedPop = null;
-    }
-  }
-
-  _disallowPop(prop, loc) {
-    if (prop && !loc) return;
-    this._disallowedPop = this._normalizePosition(prop, loc, SourcePos());
-  }
-
-  _normalizePosition(prop, loc, targetObj) {
-    const pos = loc ? loc[prop] : null;
-    targetObj.identifierName =
-      (prop === 'start' && (loc == null ? void 0 : loc.identifierName)) ||
-      undefined;
-    targetObj.line = pos == null ? void 0 : pos.line;
-    targetObj.column = pos == null ? void 0 : pos.column;
-    targetObj.filename = loc == null ? void 0 : loc.filename;
-    return targetObj;
-  }
-
-  getCurrentColumn() {
-    const extra = this._queue.reduce((acc, item) => item[0] + acc, '');
-
-    const lastIndex = extra.lastIndexOf('\n');
-    return lastIndex === -1 ?
-        this._position.column + extra.length
-      : extra.length - 1 - lastIndex;
-  }
-
-  getCurrentLine() {
-    const extra = this._queue.reduce((acc, item) => item[0] + acc, '');
-
-    let count = 0;
-
-    for (let i = 0; i < extra.length; i++) {
-      if (extra[i] === '\n') count++;
-    }
-
-    return this._position.line + count;
-  }
-}
-
-exports.default = Buffer;

node_modules/@babel/generator/lib/generators/base.js

@@ -1,100 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.BlockStatement = BlockStatement;
-exports.Directive = Directive;
-exports.DirectiveLiteral = DirectiveLiteral;
-exports.File = File;
-exports.InterpreterDirective = InterpreterDirective;
-exports.Placeholder = Placeholder;
-exports.Program = Program;
-
-function File(node) {
-  if (node.program) {
-    this.print(node.program.interpreter, node);
-  }
-
-  this.print(node.program, node);
-}
-
-function Program(node) {
-  this.printInnerComments(node, false);
-  this.printSequence(node.directives, node);
-  if (node.directives && node.directives.length) this.newline();
-  this.printSequence(node.body, node);
-}
-
-function BlockStatement(node) {
-  var _node$directives;
-
-  this.token('{');
-  this.printInnerComments(node);
-  const hasDirectives =
-    (_node$directives = node.directives) == null ?
-      void 0
-    : _node$directives.length;
-
-  if (node.body.length || hasDirectives) {
-    this.newline();
-    this.printSequence(node.directives, node, {
-      indent: true,
-    });
-    if (hasDirectives) this.newline();
-    this.printSequence(node.body, node, {
-      indent: true,
-    });
-    this.removeTrailingNewline();
-    this.source('end', node.loc);
-    if (!this.endsWith(10)) this.newline();
-    this.rightBrace();
-  } else {
-    this.source('end', node.loc);
-    this.token('}');
-  }
-}
-
-function Directive(node) {
-  this.print(node.value, node);
-  this.semicolon();
-}
-
-const unescapedSingleQuoteRE = /(?:^|[^\\])(?:\\\\)*'/;
-const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
-
-function DirectiveLiteral(node) {
-  const raw = this.getPossibleRaw(node);
-
-  if (!this.format.minified && raw != null) {
-    this.token(raw);
-    return;
-  }
-
-  const { value } = node;
-
-  if (!unescapedDoubleQuoteRE.test(value)) {
-    this.token(`"${value}"`);
-  } else if (!unescapedSingleQuoteRE.test(value)) {
-    this.token(`'${value}'`);
-  } else {
-    throw new Error(
-      'Malformed AST: it is not possible to print a directive containing' +
-        ' both unescaped single and double quotes.'
-    );
-  }
-}
-
-function InterpreterDirective(node) {
-  this.token(`#!${node.value}\n`);
-}
-
-function Placeholder(node) {
-  this.token('%%');
-  this.print(node.name);
-  this.token('%%');
-
-  if (node.expectedNode === 'Statement') {
-    this.semicolon();
-  }
-}

node_modules/@babel/generator/lib/generators/classes.js

@@ -1,213 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.ClassAccessorProperty = ClassAccessorProperty;
-exports.ClassBody = ClassBody;
-exports.ClassExpression = exports.ClassDeclaration = ClassDeclaration;
-exports.ClassMethod = ClassMethod;
-exports.ClassPrivateMethod = ClassPrivateMethod;
-exports.ClassPrivateProperty = ClassPrivateProperty;
-exports.ClassProperty = ClassProperty;
-exports.StaticBlock = StaticBlock;
-exports._classMethodHead = _classMethodHead;
-
-var _t = require('@babel/types');
-
-const { isExportDefaultDeclaration, isExportNamedDeclaration } = _t;
-
-function ClassDeclaration(node, parent) {
-  if (
-    !this.format.decoratorsBeforeExport ||
-    (!isExportDefaultDeclaration(parent) && !isExportNamedDeclaration(parent))
-  ) {
-    this.printJoin(node.decorators, node);
-  }
-
-  if (node.declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  if (node.abstract) {
-    this.word('abstract');
-    this.space();
-  }
-
-  this.word('class');
-  this.printInnerComments(node);
-
-  if (node.id) {
-    this.space();
-    this.print(node.id, node);
-  }
-
-  this.print(node.typeParameters, node);
-
-  if (node.superClass) {
-    this.space();
-    this.word('extends');
-    this.space();
-    this.print(node.superClass, node);
-    this.print(node.superTypeParameters, node);
-  }
-
-  if (node.implements) {
-    this.space();
-    this.word('implements');
-    this.space();
-    this.printList(node.implements, node);
-  }
-
-  this.space();
-  this.print(node.body, node);
-}
-
-function ClassBody(node) {
-  this.token('{');
-  this.printInnerComments(node);
-
-  if (node.body.length === 0) {
-    this.token('}');
-  } else {
-    this.newline();
-    this.indent();
-    this.printSequence(node.body, node);
-    this.dedent();
-    if (!this.endsWith(10)) this.newline();
-    this.rightBrace();
-  }
-}
-
-function ClassProperty(node) {
-  this.printJoin(node.decorators, node);
-  this.source('end', node.key.loc);
-  this.tsPrintClassMemberModifiers(node, true);
-
-  if (node.computed) {
-    this.token('[');
-    this.print(node.key, node);
-    this.token(']');
-  } else {
-    this._variance(node);
-
-    this.print(node.key, node);
-  }
-
-  if (node.optional) {
-    this.token('?');
-  }
-
-  if (node.definite) {
-    this.token('!');
-  }
-
-  this.print(node.typeAnnotation, node);
-
-  if (node.value) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(node.value, node);
-  }
-
-  this.semicolon();
-}
-
-function ClassAccessorProperty(node) {
-  this.printJoin(node.decorators, node);
-  this.source('end', node.key.loc);
-  this.tsPrintClassMemberModifiers(node, true);
-  this.word('accessor');
-  this.printInnerComments(node);
-  this.space();
-
-  if (node.computed) {
-    this.token('[');
-    this.print(node.key, node);
-    this.token(']');
-  } else {
-    this._variance(node);
-
-    this.print(node.key, node);
-  }
-
-  if (node.optional) {
-    this.token('?');
-  }
-
-  if (node.definite) {
-    this.token('!');
-  }
-
-  this.print(node.typeAnnotation, node);
-
-  if (node.value) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(node.value, node);
-  }
-
-  this.semicolon();
-}
-
-function ClassPrivateProperty(node) {
-  this.printJoin(node.decorators, node);
-
-  if (node.static) {
-    this.word('static');
-    this.space();
-  }
-
-  this.print(node.key, node);
-  this.print(node.typeAnnotation, node);
-
-  if (node.value) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(node.value, node);
-  }
-
-  this.semicolon();
-}
-
-function ClassMethod(node) {
-  this._classMethodHead(node);
-
-  this.space();
-  this.print(node.body, node);
-}
-
-function ClassPrivateMethod(node) {
-  this._classMethodHead(node);
-
-  this.space();
-  this.print(node.body, node);
-}
-
-function _classMethodHead(node) {
-  this.printJoin(node.decorators, node);
-  this.source('end', node.key.loc);
-  this.tsPrintClassMemberModifiers(node, false);
-
-  this._methodHead(node);
-}
-
-function StaticBlock(node) {
-  this.word('static');
-  this.space();
-  this.token('{');
-
-  if (node.body.length === 0) {
-    this.token('}');
-  } else {
-    this.newline();
-    this.printSequence(node.body, node, {
-      indent: true,
-    });
-    this.rightBrace();
-  }
-}

node_modules/@babel/generator/lib/generators/expressions.js

@@ -1,369 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.LogicalExpression =
-  exports.BinaryExpression =
-  exports.AssignmentExpression =
-    AssignmentExpression;
-exports.AssignmentPattern = AssignmentPattern;
-exports.AwaitExpression = void 0;
-exports.BindExpression = BindExpression;
-exports.CallExpression = CallExpression;
-exports.ConditionalExpression = ConditionalExpression;
-exports.Decorator = Decorator;
-exports.DoExpression = DoExpression;
-exports.EmptyStatement = EmptyStatement;
-exports.ExpressionStatement = ExpressionStatement;
-exports.Import = Import;
-exports.MemberExpression = MemberExpression;
-exports.MetaProperty = MetaProperty;
-exports.ModuleExpression = ModuleExpression;
-exports.NewExpression = NewExpression;
-exports.OptionalCallExpression = OptionalCallExpression;
-exports.OptionalMemberExpression = OptionalMemberExpression;
-exports.ParenthesizedExpression = ParenthesizedExpression;
-exports.PrivateName = PrivateName;
-exports.SequenceExpression = SequenceExpression;
-exports.Super = Super;
-exports.ThisExpression = ThisExpression;
-exports.UnaryExpression = UnaryExpression;
-exports.UpdateExpression = UpdateExpression;
-exports.V8IntrinsicIdentifier = V8IntrinsicIdentifier;
-exports.YieldExpression = void 0;
-
-var _t = require('@babel/types');
-
-var n = require('../node');
-
-const { isCallExpression, isLiteral, isMemberExpression, isNewExpression } = _t;
-
-function UnaryExpression(node) {
-  if (
-    node.operator === 'void' ||
-    node.operator === 'delete' ||
-    node.operator === 'typeof' ||
-    node.operator === 'throw'
-  ) {
-    this.word(node.operator);
-    this.space();
-  } else {
-    this.token(node.operator);
-  }
-
-  this.print(node.argument, node);
-}
-
-function DoExpression(node) {
-  if (node.async) {
-    this.word('async');
-    this.space();
-  }
-
-  this.word('do');
-  this.space();
-  this.print(node.body, node);
-}
-
-function ParenthesizedExpression(node) {
-  this.token('(');
-  this.print(node.expression, node);
-  this.token(')');
-}
-
-function UpdateExpression(node) {
-  if (node.prefix) {
-    this.token(node.operator);
-    this.print(node.argument, node);
-  } else {
-    this.startTerminatorless(true);
-    this.print(node.argument, node);
-    this.endTerminatorless();
-    this.token(node.operator);
-  }
-}
-
-function ConditionalExpression(node) {
-  this.print(node.test, node);
-  this.space();
-  this.token('?');
-  this.space();
-  this.print(node.consequent, node);
-  this.space();
-  this.token(':');
-  this.space();
-  this.print(node.alternate, node);
-}
-
-function NewExpression(node, parent) {
-  this.word('new');
-  this.space();
-  this.print(node.callee, node);
-
-  if (
-    this.format.minified &&
-    node.arguments.length === 0 &&
-    !node.optional &&
-    !isCallExpression(parent, {
-      callee: node,
-    }) &&
-    !isMemberExpression(parent) &&
-    !isNewExpression(parent)
-  ) {
-    return;
-  }
-
-  this.print(node.typeArguments, node);
-  this.print(node.typeParameters, node);
-
-  if (node.optional) {
-    this.token('?.');
-  }
-
-  this.token('(');
-  this.printList(node.arguments, node);
-  this.token(')');
-}
-
-function SequenceExpression(node) {
-  this.printList(node.expressions, node);
-}
-
-function ThisExpression() {
-  this.word('this');
-}
-
-function Super() {
-  this.word('super');
-}
-
-function isDecoratorMemberExpression(node) {
-  switch (node.type) {
-    case 'Identifier':
-      return true;
-
-    case 'MemberExpression':
-      return (
-        !node.computed &&
-        node.property.type === 'Identifier' &&
-        isDecoratorMemberExpression(node.object)
-      );
-
-    default:
-      return false;
-  }
-}
-
-function shouldParenthesizeDecoratorExpression(node) {
-  if (node.type === 'CallExpression') {
-    node = node.callee;
-  }
-
-  if (node.type === 'ParenthesizedExpression') {
-    return false;
-  }
-
-  return !isDecoratorMemberExpression(node);
-}
-
-function Decorator(node) {
-  this.token('@');
-  const { expression } = node;
-
-  if (shouldParenthesizeDecoratorExpression(expression)) {
-    this.token('(');
-    this.print(expression, node);
-    this.token(')');
-  } else {
-    this.print(expression, node);
-  }
-
-  this.newline();
-}
-
-function OptionalMemberExpression(node) {
-  this.print(node.object, node);
-
-  if (!node.computed && isMemberExpression(node.property)) {
-    throw new TypeError('Got a MemberExpression for MemberExpression property');
-  }
-
-  let computed = node.computed;
-
-  if (isLiteral(node.property) && typeof node.property.value === 'number') {
-    computed = true;
-  }
-
-  if (node.optional) {
-    this.token('?.');
-  }
-
-  if (computed) {
-    this.token('[');
-    this.print(node.property, node);
-    this.token(']');
-  } else {
-    if (!node.optional) {
-      this.token('.');
-    }
-
-    this.print(node.property, node);
-  }
-}
-
-function OptionalCallExpression(node) {
-  this.print(node.callee, node);
-  this.print(node.typeArguments, node);
-  this.print(node.typeParameters, node);
-
-  if (node.optional) {
-    this.token('?.');
-  }
-
-  this.token('(');
-  this.printList(node.arguments, node);
-  this.token(')');
-}
-
-function CallExpression(node) {
-  this.print(node.callee, node);
-  this.print(node.typeArguments, node);
-  this.print(node.typeParameters, node);
-  this.token('(');
-  this.printList(node.arguments, node);
-  this.token(')');
-}
-
-function Import() {
-  this.word('import');
-}
-
-function buildYieldAwait(keyword) {
-  return function (node) {
-    this.word(keyword);
-
-    if (node.delegate) {
-      this.token('*');
-    }
-
-    if (node.argument) {
-      this.space();
-      const terminatorState = this.startTerminatorless();
-      this.print(node.argument, node);
-      this.endTerminatorless(terminatorState);
-    }
-  };
-}
-
-const YieldExpression = buildYieldAwait('yield');
-exports.YieldExpression = YieldExpression;
-const AwaitExpression = buildYieldAwait('await');
-exports.AwaitExpression = AwaitExpression;
-
-function EmptyStatement() {
-  this.semicolon(true);
-}
-
-function ExpressionStatement(node) {
-  this.print(node.expression, node);
-  this.semicolon();
-}
-
-function AssignmentPattern(node) {
-  this.print(node.left, node);
-  if (node.left.optional) this.token('?');
-  this.print(node.left.typeAnnotation, node);
-  this.space();
-  this.token('=');
-  this.space();
-  this.print(node.right, node);
-}
-
-function AssignmentExpression(node, parent) {
-  const parens =
-    this.inForStatementInitCounter &&
-    node.operator === 'in' &&
-    !n.needsParens(node, parent);
-
-  if (parens) {
-    this.token('(');
-  }
-
-  this.print(node.left, node);
-  this.space();
-
-  if (node.operator === 'in' || node.operator === 'instanceof') {
-    this.word(node.operator);
-  } else {
-    this.token(node.operator);
-  }
-
-  this.space();
-  this.print(node.right, node);
-
-  if (parens) {
-    this.token(')');
-  }
-}
-
-function BindExpression(node) {
-  this.print(node.object, node);
-  this.token('::');
-  this.print(node.callee, node);
-}
-
-function MemberExpression(node) {
-  this.print(node.object, node);
-
-  if (!node.computed && isMemberExpression(node.property)) {
-    throw new TypeError('Got a MemberExpression for MemberExpression property');
-  }
-
-  let computed = node.computed;
-
-  if (isLiteral(node.property) && typeof node.property.value === 'number') {
-    computed = true;
-  }
-
-  if (computed) {
-    this.token('[');
-    this.print(node.property, node);
-    this.token(']');
-  } else {
-    this.token('.');
-    this.print(node.property, node);
-  }
-}
-
-function MetaProperty(node) {
-  this.print(node.meta, node);
-  this.token('.');
-  this.print(node.property, node);
-}
-
-function PrivateName(node) {
-  this.token('#');
-  this.print(node.id, node);
-}
-
-function V8IntrinsicIdentifier(node) {
-  this.token('%');
-  this.word(node.name);
-}
-
-function ModuleExpression(node) {
-  this.word('module');
-  this.space();
-  this.token('{');
-
-  if (node.body.body.length === 0) {
-    this.token('}');
-  } else {
-    this.newline();
-    this.printSequence(node.body.body, node, {
-      indent: true,
-    });
-    this.rightBrace();
-  }
-}

node_modules/@babel/generator/lib/generators/flow.js

@@ -1,790 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.AnyTypeAnnotation = AnyTypeAnnotation;
-exports.ArrayTypeAnnotation = ArrayTypeAnnotation;
-exports.BooleanLiteralTypeAnnotation = BooleanLiteralTypeAnnotation;
-exports.BooleanTypeAnnotation = BooleanTypeAnnotation;
-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.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.FunctionTypeAnnotation = FunctionTypeAnnotation;
-exports.FunctionTypeParam = FunctionTypeParam;
-exports.IndexedAccessType = IndexedAccessType;
-exports.InferredPredicate = InferredPredicate;
-exports.InterfaceDeclaration = InterfaceDeclaration;
-exports.GenericTypeAnnotation =
-  exports.ClassImplements =
-  exports.InterfaceExtends =
-    InterfaceExtends;
-exports.InterfaceTypeAnnotation = InterfaceTypeAnnotation;
-exports.IntersectionTypeAnnotation = IntersectionTypeAnnotation;
-exports.MixedTypeAnnotation = MixedTypeAnnotation;
-exports.NullLiteralTypeAnnotation = NullLiteralTypeAnnotation;
-exports.NullableTypeAnnotation = NullableTypeAnnotation;
-Object.defineProperty(exports, 'NumberLiteralTypeAnnotation', {
-  enumerable: true,
-  get: function () {
-    return _types2.NumericLiteral;
-  },
-});
-exports.NumberTypeAnnotation = NumberTypeAnnotation;
-exports.ObjectTypeAnnotation = ObjectTypeAnnotation;
-exports.ObjectTypeCallProperty = ObjectTypeCallProperty;
-exports.ObjectTypeIndexer = ObjectTypeIndexer;
-exports.ObjectTypeInternalSlot = ObjectTypeInternalSlot;
-exports.ObjectTypeProperty = ObjectTypeProperty;
-exports.ObjectTypeSpreadProperty = ObjectTypeSpreadProperty;
-exports.OpaqueType = OpaqueType;
-exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
-exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
-Object.defineProperty(exports, 'StringLiteralTypeAnnotation', {
-  enumerable: true,
-  get: function () {
-    return _types2.StringLiteral;
-  },
-});
-exports.StringTypeAnnotation = StringTypeAnnotation;
-exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
-exports.ThisTypeAnnotation = ThisTypeAnnotation;
-exports.TupleTypeAnnotation = TupleTypeAnnotation;
-exports.TypeAlias = TypeAlias;
-exports.TypeAnnotation = TypeAnnotation;
-exports.TypeCastExpression = TypeCastExpression;
-exports.TypeParameter = TypeParameter;
-exports.TypeParameterDeclaration = exports.TypeParameterInstantiation =
-  TypeParameterInstantiation;
-exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
-exports.UnionTypeAnnotation = UnionTypeAnnotation;
-exports.Variance = Variance;
-exports.VoidTypeAnnotation = VoidTypeAnnotation;
-exports._interfaceish = _interfaceish;
-exports._variance = _variance;
-
-var _t = require('@babel/types');
-
-var _modules = require('./modules');
-
-var _types2 = require('./types');
-
-const { isDeclareExportDeclaration, isStatement } = _t;
-
-function AnyTypeAnnotation() {
-  this.word('any');
-}
-
-function ArrayTypeAnnotation(node) {
-  this.print(node.elementType, node);
-  this.token('[');
-  this.token(']');
-}
-
-function BooleanTypeAnnotation() {
-  this.word('boolean');
-}
-
-function BooleanLiteralTypeAnnotation(node) {
-  this.word(node.value ? 'true' : 'false');
-}
-
-function NullLiteralTypeAnnotation() {
-  this.word('null');
-}
-
-function DeclareClass(node, parent) {
-  if (!isDeclareExportDeclaration(parent)) {
-    this.word('declare');
-    this.space();
-  }
-
-  this.word('class');
-  this.space();
-
-  this._interfaceish(node);
-}
-
-function DeclareFunction(node, parent) {
-  if (!isDeclareExportDeclaration(parent)) {
-    this.word('declare');
-    this.space();
-  }
-
-  this.word('function');
-  this.space();
-  this.print(node.id, node);
-  this.print(node.id.typeAnnotation.typeAnnotation, node);
-
-  if (node.predicate) {
-    this.space();
-    this.print(node.predicate, node);
-  }
-
-  this.semicolon();
-}
-
-function InferredPredicate() {
-  this.token('%');
-  this.word('checks');
-}
-
-function DeclaredPredicate(node) {
-  this.token('%');
-  this.word('checks');
-  this.token('(');
-  this.print(node.value, node);
-  this.token(')');
-}
-
-function DeclareInterface(node) {
-  this.word('declare');
-  this.space();
-  this.InterfaceDeclaration(node);
-}
-
-function DeclareModule(node) {
-  this.word('declare');
-  this.space();
-  this.word('module');
-  this.space();
-  this.print(node.id, node);
-  this.space();
-  this.print(node.body, node);
-}
-
-function DeclareModuleExports(node) {
-  this.word('declare');
-  this.space();
-  this.word('module');
-  this.token('.');
-  this.word('exports');
-  this.print(node.typeAnnotation, node);
-}
-
-function DeclareTypeAlias(node) {
-  this.word('declare');
-  this.space();
-  this.TypeAlias(node);
-}
-
-function DeclareOpaqueType(node, parent) {
-  if (!isDeclareExportDeclaration(parent)) {
-    this.word('declare');
-    this.space();
-  }
-
-  this.OpaqueType(node);
-}
-
-function DeclareVariable(node, parent) {
-  if (!isDeclareExportDeclaration(parent)) {
-    this.word('declare');
-    this.space();
-  }
-
-  this.word('var');
-  this.space();
-  this.print(node.id, node);
-  this.print(node.id.typeAnnotation, node);
-  this.semicolon();
-}
-
-function DeclareExportDeclaration(node) {
-  this.word('declare');
-  this.space();
-  this.word('export');
-  this.space();
-
-  if (node.default) {
-    this.word('default');
-    this.space();
-  }
-
-  FlowExportDeclaration.apply(this, arguments);
-}
-
-function DeclareExportAllDeclaration() {
-  this.word('declare');
-  this.space();
-
-  _modules.ExportAllDeclaration.apply(this, arguments);
-}
-
-function EnumDeclaration(node) {
-  const { id, body } = node;
-  this.word('enum');
-  this.space();
-  this.print(id, node);
-  this.print(body, node);
-}
-
-function enumExplicitType(context, name, hasExplicitType) {
-  if (hasExplicitType) {
-    context.space();
-    context.word('of');
-    context.space();
-    context.word(name);
-  }
-
-  context.space();
-}
-
-function enumBody(context, node) {
-  const { members } = node;
-  context.token('{');
-  context.indent();
-  context.newline();
-
-  for (const member of members) {
-    context.print(member, node);
-    context.newline();
-  }
-
-  if (node.hasUnknownMembers) {
-    context.token('...');
-    context.newline();
-  }
-
-  context.dedent();
-  context.token('}');
-}
-
-function EnumBooleanBody(node) {
-  const { explicitType } = node;
-  enumExplicitType(this, 'boolean', explicitType);
-  enumBody(this, node);
-}
-
-function EnumNumberBody(node) {
-  const { explicitType } = node;
-  enumExplicitType(this, 'number', explicitType);
-  enumBody(this, node);
-}
-
-function EnumStringBody(node) {
-  const { explicitType } = node;
-  enumExplicitType(this, 'string', explicitType);
-  enumBody(this, node);
-}
-
-function EnumSymbolBody(node) {
-  enumExplicitType(this, 'symbol', true);
-  enumBody(this, node);
-}
-
-function EnumDefaultedMember(node) {
-  const { id } = node;
-  this.print(id, node);
-  this.token(',');
-}
-
-function enumInitializedMember(context, node) {
-  const { id, init } = node;
-  context.print(id, node);
-  context.space();
-  context.token('=');
-  context.space();
-  context.print(init, node);
-  context.token(',');
-}
-
-function EnumBooleanMember(node) {
-  enumInitializedMember(this, node);
-}
-
-function EnumNumberMember(node) {
-  enumInitializedMember(this, node);
-}
-
-function EnumStringMember(node) {
-  enumInitializedMember(this, node);
-}
-
-function FlowExportDeclaration(node) {
-  if (node.declaration) {
-    const declar = node.declaration;
-    this.print(declar, node);
-    if (!isStatement(declar)) this.semicolon();
-  } else {
-    this.token('{');
-
-    if (node.specifiers.length) {
-      this.space();
-      this.printList(node.specifiers, node);
-      this.space();
-    }
-
-    this.token('}');
-
-    if (node.source) {
-      this.space();
-      this.word('from');
-      this.space();
-      this.print(node.source, node);
-    }
-
-    this.semicolon();
-  }
-}
-
-function ExistsTypeAnnotation() {
-  this.token('*');
-}
-
-function FunctionTypeAnnotation(node, parent) {
-  this.print(node.typeParameters, node);
-  this.token('(');
-
-  if (node.this) {
-    this.word('this');
-    this.token(':');
-    this.space();
-    this.print(node.this.typeAnnotation, node);
-
-    if (node.params.length || node.rest) {
-      this.token(',');
-      this.space();
-    }
-  }
-
-  this.printList(node.params, node);
-
-  if (node.rest) {
-    if (node.params.length) {
-      this.token(',');
-      this.space();
-    }
-
-    this.token('...');
-    this.print(node.rest, node);
-  }
-
-  this.token(')');
-
-  if (
-    parent &&
-    (parent.type === 'ObjectTypeCallProperty' ||
-      parent.type === 'DeclareFunction' ||
-      (parent.type === 'ObjectTypeProperty' && parent.method))
-  ) {
-    this.token(':');
-  } else {
-    this.space();
-    this.token('=>');
-  }
-
-  this.space();
-  this.print(node.returnType, node);
-}
-
-function FunctionTypeParam(node) {
-  this.print(node.name, node);
-  if (node.optional) this.token('?');
-
-  if (node.name) {
-    this.token(':');
-    this.space();
-  }
-
-  this.print(node.typeAnnotation, node);
-}
-
-function InterfaceExtends(node) {
-  this.print(node.id, node);
-  this.print(node.typeParameters, node);
-}
-
-function _interfaceish(node) {
-  var _node$extends;
-
-  this.print(node.id, node);
-  this.print(node.typeParameters, node);
-
-  if ((_node$extends = node.extends) != null && _node$extends.length) {
-    this.space();
-    this.word('extends');
-    this.space();
-    this.printList(node.extends, node);
-  }
-
-  if (node.mixins && node.mixins.length) {
-    this.space();
-    this.word('mixins');
-    this.space();
-    this.printList(node.mixins, node);
-  }
-
-  if (node.implements && node.implements.length) {
-    this.space();
-    this.word('implements');
-    this.space();
-    this.printList(node.implements, node);
-  }
-
-  this.space();
-  this.print(node.body, node);
-}
-
-function _variance(node) {
-  if (node.variance) {
-    if (node.variance.kind === 'plus') {
-      this.token('+');
-    } else if (node.variance.kind === 'minus') {
-      this.token('-');
-    }
-  }
-}
-
-function InterfaceDeclaration(node) {
-  this.word('interface');
-  this.space();
-
-  this._interfaceish(node);
-}
-
-function andSeparator() {
-  this.space();
-  this.token('&');
-  this.space();
-}
-
-function InterfaceTypeAnnotation(node) {
-  this.word('interface');
-
-  if (node.extends && node.extends.length) {
-    this.space();
-    this.word('extends');
-    this.space();
-    this.printList(node.extends, node);
-  }
-
-  this.space();
-  this.print(node.body, node);
-}
-
-function IntersectionTypeAnnotation(node) {
-  this.printJoin(node.types, node, {
-    separator: andSeparator,
-  });
-}
-
-function MixedTypeAnnotation() {
-  this.word('mixed');
-}
-
-function EmptyTypeAnnotation() {
-  this.word('empty');
-}
-
-function NullableTypeAnnotation(node) {
-  this.token('?');
-  this.print(node.typeAnnotation, node);
-}
-
-function NumberTypeAnnotation() {
-  this.word('number');
-}
-
-function StringTypeAnnotation() {
-  this.word('string');
-}
-
-function ThisTypeAnnotation() {
-  this.word('this');
-}
-
-function TupleTypeAnnotation(node) {
-  this.token('[');
-  this.printList(node.types, node);
-  this.token(']');
-}
-
-function TypeofTypeAnnotation(node) {
-  this.word('typeof');
-  this.space();
-  this.print(node.argument, node);
-}
-
-function TypeAlias(node) {
-  this.word('type');
-  this.space();
-  this.print(node.id, node);
-  this.print(node.typeParameters, node);
-  this.space();
-  this.token('=');
-  this.space();
-  this.print(node.right, node);
-  this.semicolon();
-}
-
-function TypeAnnotation(node) {
-  this.token(':');
-  this.space();
-  if (node.optional) this.token('?');
-  this.print(node.typeAnnotation, node);
-}
-
-function TypeParameterInstantiation(node) {
-  this.token('<');
-  this.printList(node.params, node, {});
-  this.token('>');
-}
-
-function TypeParameter(node) {
-  this._variance(node);
-
-  this.word(node.name);
-
-  if (node.bound) {
-    this.print(node.bound, node);
-  }
-
-  if (node.default) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(node.default, node);
-  }
-}
-
-function OpaqueType(node) {
-  this.word('opaque');
-  this.space();
-  this.word('type');
-  this.space();
-  this.print(node.id, node);
-  this.print(node.typeParameters, node);
-
-  if (node.supertype) {
-    this.token(':');
-    this.space();
-    this.print(node.supertype, node);
-  }
-
-  if (node.impltype) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(node.impltype, node);
-  }
-
-  this.semicolon();
-}
-
-function ObjectTypeAnnotation(node) {
-  if (node.exact) {
-    this.token('{|');
-  } else {
-    this.token('{');
-  }
-
-  const props = [
-    ...node.properties,
-    ...(node.callProperties || []),
-    ...(node.indexers || []),
-    ...(node.internalSlots || []),
-  ];
-
-  if (props.length) {
-    this.space();
-    this.printJoin(props, node, {
-      addNewlines(leading) {
-        if (leading && !props[0]) return 1;
-      },
-
-      indent: true,
-      statement: true,
-      iterator: () => {
-        if (props.length !== 1 || node.inexact) {
-          this.token(',');
-          this.space();
-        }
-      },
-    });
-    this.space();
-  }
-
-  if (node.inexact) {
-    this.indent();
-    this.token('...');
-
-    if (props.length) {
-      this.newline();
-    }
-
-    this.dedent();
-  }
-
-  if (node.exact) {
-    this.token('|}');
-  } else {
-    this.token('}');
-  }
-}
-
-function ObjectTypeInternalSlot(node) {
-  if (node.static) {
-    this.word('static');
-    this.space();
-  }
-
-  this.token('[');
-  this.token('[');
-  this.print(node.id, node);
-  this.token(']');
-  this.token(']');
-  if (node.optional) this.token('?');
-
-  if (!node.method) {
-    this.token(':');
-    this.space();
-  }
-
-  this.print(node.value, node);
-}
-
-function ObjectTypeCallProperty(node) {
-  if (node.static) {
-    this.word('static');
-    this.space();
-  }
-
-  this.print(node.value, node);
-}
-
-function ObjectTypeIndexer(node) {
-  if (node.static) {
-    this.word('static');
-    this.space();
-  }
-
-  this._variance(node);
-
-  this.token('[');
-
-  if (node.id) {
-    this.print(node.id, node);
-    this.token(':');
-    this.space();
-  }
-
-  this.print(node.key, node);
-  this.token(']');
-  this.token(':');
-  this.space();
-  this.print(node.value, node);
-}
-
-function ObjectTypeProperty(node) {
-  if (node.proto) {
-    this.word('proto');
-    this.space();
-  }
-
-  if (node.static) {
-    this.word('static');
-    this.space();
-  }
-
-  if (node.kind === 'get' || node.kind === 'set') {
-    this.word(node.kind);
-    this.space();
-  }
-
-  this._variance(node);
-
-  this.print(node.key, node);
-  if (node.optional) this.token('?');
-
-  if (!node.method) {
-    this.token(':');
-    this.space();
-  }
-
-  this.print(node.value, node);
-}
-
-function ObjectTypeSpreadProperty(node) {
-  this.token('...');
-  this.print(node.argument, node);
-}
-
-function QualifiedTypeIdentifier(node) {
-  this.print(node.qualification, node);
-  this.token('.');
-  this.print(node.id, node);
-}
-
-function SymbolTypeAnnotation() {
-  this.word('symbol');
-}
-
-function orSeparator() {
-  this.space();
-  this.token('|');
-  this.space();
-}
-
-function UnionTypeAnnotation(node) {
-  this.printJoin(node.types, node, {
-    separator: orSeparator,
-  });
-}
-
-function TypeCastExpression(node) {
-  this.token('(');
-  this.print(node.expression, node);
-  this.print(node.typeAnnotation, node);
-  this.token(')');
-}
-
-function Variance(node) {
-  if (node.kind === 'plus') {
-    this.token('+');
-  } else {
-    this.token('-');
-  }
-}
-
-function VoidTypeAnnotation() {
-  this.word('void');
-}
-
-function IndexedAccessType(node) {
-  this.print(node.objectType, node);
-  this.token('[');
-  this.print(node.indexType, node);
-  this.token(']');
-}
-
-function OptionalIndexedAccessType(node) {
-  this.print(node.objectType, node);
-
-  if (node.optional) {
-    this.token('?.');
-  }
-
-  this.token('[');
-  this.print(node.indexType, node);
-  this.token(']');
-}

node_modules/@babel/generator/lib/generators/index.js

@@ -1,148 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-
-var _templateLiterals = require('./template-literals');
-
-Object.keys(_templateLiterals).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _templateLiterals[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _templateLiterals[key];
-    },
-  });
-});
-
-var _expressions = require('./expressions');
-
-Object.keys(_expressions).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _expressions[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _expressions[key];
-    },
-  });
-});
-
-var _statements = require('./statements');
-
-Object.keys(_statements).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _statements[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _statements[key];
-    },
-  });
-});
-
-var _classes = require('./classes');
-
-Object.keys(_classes).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _classes[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _classes[key];
-    },
-  });
-});
-
-var _methods = require('./methods');
-
-Object.keys(_methods).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _methods[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _methods[key];
-    },
-  });
-});
-
-var _modules = require('./modules');
-
-Object.keys(_modules).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _modules[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _modules[key];
-    },
-  });
-});
-
-var _types = require('./types');
-
-Object.keys(_types).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _types[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _types[key];
-    },
-  });
-});
-
-var _flow = require('./flow');
-
-Object.keys(_flow).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _flow[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _flow[key];
-    },
-  });
-});
-
-var _base = require('./base');
-
-Object.keys(_base).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _base[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _base[key];
-    },
-  });
-});
-
-var _jsx = require('./jsx');
-
-Object.keys(_jsx).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _jsx[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _jsx[key];
-    },
-  });
-});
-
-var _typescript = require('./typescript');
-
-Object.keys(_typescript).forEach(function (key) {
-  if (key === 'default' || key === '__esModule') return;
-  if (key in exports && exports[key] === _typescript[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _typescript[key];
-    },
-  });
-});

node_modules/@babel/generator/lib/generators/jsx.js

@@ -1,145 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.JSXAttribute = JSXAttribute;
-exports.JSXClosingElement = JSXClosingElement;
-exports.JSXClosingFragment = JSXClosingFragment;
-exports.JSXElement = JSXElement;
-exports.JSXEmptyExpression = JSXEmptyExpression;
-exports.JSXExpressionContainer = JSXExpressionContainer;
-exports.JSXFragment = JSXFragment;
-exports.JSXIdentifier = JSXIdentifier;
-exports.JSXMemberExpression = JSXMemberExpression;
-exports.JSXNamespacedName = JSXNamespacedName;
-exports.JSXOpeningElement = JSXOpeningElement;
-exports.JSXOpeningFragment = JSXOpeningFragment;
-exports.JSXSpreadAttribute = JSXSpreadAttribute;
-exports.JSXSpreadChild = JSXSpreadChild;
-exports.JSXText = JSXText;
-
-function JSXAttribute(node) {
-  this.print(node.name, node);
-
-  if (node.value) {
-    this.token('=');
-    this.print(node.value, node);
-  }
-}
-
-function JSXIdentifier(node) {
-  this.word(node.name);
-}
-
-function JSXNamespacedName(node) {
-  this.print(node.namespace, node);
-  this.token(':');
-  this.print(node.name, node);
-}
-
-function JSXMemberExpression(node) {
-  this.print(node.object, node);
-  this.token('.');
-  this.print(node.property, node);
-}
-
-function JSXSpreadAttribute(node) {
-  this.token('{');
-  this.token('...');
-  this.print(node.argument, node);
-  this.token('}');
-}
-
-function JSXExpressionContainer(node) {
-  this.token('{');
-  this.print(node.expression, node);
-  this.token('}');
-}
-
-function JSXSpreadChild(node) {
-  this.token('{');
-  this.token('...');
-  this.print(node.expression, node);
-  this.token('}');
-}
-
-function JSXText(node) {
-  const raw = this.getPossibleRaw(node);
-
-  if (raw != null) {
-    this.token(raw);
-  } else {
-    this.token(node.value);
-  }
-}
-
-function JSXElement(node) {
-  const open = node.openingElement;
-  this.print(open, node);
-  if (open.selfClosing) return;
-  this.indent();
-
-  for (const child of node.children) {
-    this.print(child, node);
-  }
-
-  this.dedent();
-  this.print(node.closingElement, node);
-}
-
-function spaceSeparator() {
-  this.space();
-}
-
-function JSXOpeningElement(node) {
-  this.token('<');
-  this.print(node.name, node);
-  this.print(node.typeParameters, node);
-
-  if (node.attributes.length > 0) {
-    this.space();
-    this.printJoin(node.attributes, node, {
-      separator: spaceSeparator,
-    });
-  }
-
-  if (node.selfClosing) {
-    this.space();
-    this.token('/>');
-  } else {
-    this.token('>');
-  }
-}
-
-function JSXClosingElement(node) {
-  this.token('</');
-  this.print(node.name, node);
-  this.token('>');
-}
-
-function JSXEmptyExpression(node) {
-  this.printInnerComments(node);
-}
-
-function JSXFragment(node) {
-  this.print(node.openingFragment, node);
-  this.indent();
-
-  for (const child of node.children) {
-    this.print(child, node);
-  }
-
-  this.dedent();
-  this.print(node.closingFragment, node);
-}
-
-function JSXOpeningFragment() {
-  this.token('<');
-  this.token('>');
-}
-
-function JSXClosingFragment() {
-  this.token('</');
-  this.token('>');
-}

node_modules/@babel/generator/lib/generators/methods.js

@@ -1,165 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.ArrowFunctionExpression = ArrowFunctionExpression;
-exports.FunctionDeclaration = exports.FunctionExpression = FunctionExpression;
-exports._functionHead = _functionHead;
-exports._methodHead = _methodHead;
-exports._param = _param;
-exports._parameters = _parameters;
-exports._params = _params;
-exports._predicate = _predicate;
-
-var _t = require('@babel/types');
-
-const { isIdentifier } = _t;
-
-function _params(node) {
-  this.print(node.typeParameters, node);
-  this.token('(');
-
-  this._parameters(node.params, node);
-
-  this.token(')');
-  this.print(node.returnType, node);
-}
-
-function _parameters(parameters, parent) {
-  for (let i = 0; i < parameters.length; i++) {
-    this._param(parameters[i], parent);
-
-    if (i < parameters.length - 1) {
-      this.token(',');
-      this.space();
-    }
-  }
-}
-
-function _param(parameter, parent) {
-  this.printJoin(parameter.decorators, parameter);
-  this.print(parameter, parent);
-  if (parameter.optional) this.token('?');
-  this.print(parameter.typeAnnotation, parameter);
-}
-
-function _methodHead(node) {
-  const kind = node.kind;
-  const key = node.key;
-
-  if (kind === 'get' || kind === 'set') {
-    this.word(kind);
-    this.space();
-  }
-
-  if (node.async) {
-    this._catchUp('start', key.loc);
-
-    this.word('async');
-    this.space();
-  }
-
-  if (kind === 'method' || kind === 'init') {
-    if (node.generator) {
-      this.token('*');
-    }
-  }
-
-  if (node.computed) {
-    this.token('[');
-    this.print(key, node);
-    this.token(']');
-  } else {
-    this.print(key, node);
-  }
-
-  if (node.optional) {
-    this.token('?');
-  }
-
-  this._params(node);
-}
-
-function _predicate(node) {
-  if (node.predicate) {
-    if (!node.returnType) {
-      this.token(':');
-    }
-
-    this.space();
-    this.print(node.predicate, node);
-  }
-}
-
-function _functionHead(node) {
-  if (node.async) {
-    this.word('async');
-    this.space();
-  }
-
-  this.word('function');
-  if (node.generator) this.token('*');
-  this.printInnerComments(node);
-  this.space();
-
-  if (node.id) {
-    this.print(node.id, node);
-  }
-
-  this._params(node);
-
-  this._predicate(node);
-}
-
-function FunctionExpression(node) {
-  this._functionHead(node);
-
-  this.space();
-  this.print(node.body, node);
-}
-
-function ArrowFunctionExpression(node) {
-  if (node.async) {
-    this.word('async');
-    this.space();
-  }
-
-  const firstParam = node.params[0];
-
-  if (
-    !this.format.retainLines &&
-    !this.format.auxiliaryCommentBefore &&
-    !this.format.auxiliaryCommentAfter &&
-    node.params.length === 1 &&
-    isIdentifier(firstParam) &&
-    !hasTypesOrComments(node, firstParam)
-  ) {
-    this.print(firstParam, node);
-  } else {
-    this._params(node);
-  }
-
-  this._predicate(node);
-
-  this.space();
-  this.token('=>');
-  this.space();
-  this.print(node.body, node);
-}
-
-function hasTypesOrComments(node, param) {
-  var _param$leadingComment, _param$trailingCommen;
-
-  return !!(
-    node.typeParameters ||
-    node.returnType ||
-    node.predicate ||
-    param.typeAnnotation ||
-    param.optional ||
-    ((_param$leadingComment = param.leadingComments) != null &&
-      _param$leadingComment.length) ||
-    ((_param$trailingCommen = param.trailingComments) != null &&
-      _param$trailingCommen.length)
-  );
-}

node_modules/@babel/generator/lib/generators/modules.js

@@ -1,256 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.ExportAllDeclaration = ExportAllDeclaration;
-exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
-exports.ExportDefaultSpecifier = ExportDefaultSpecifier;
-exports.ExportNamedDeclaration = ExportNamedDeclaration;
-exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
-exports.ExportSpecifier = ExportSpecifier;
-exports.ImportAttribute = ImportAttribute;
-exports.ImportDeclaration = ImportDeclaration;
-exports.ImportDefaultSpecifier = ImportDefaultSpecifier;
-exports.ImportNamespaceSpecifier = ImportNamespaceSpecifier;
-exports.ImportSpecifier = ImportSpecifier;
-
-var _t = require('@babel/types');
-
-const {
-  isClassDeclaration,
-  isExportDefaultSpecifier,
-  isExportNamespaceSpecifier,
-  isImportDefaultSpecifier,
-  isImportNamespaceSpecifier,
-  isStatement,
-} = _t;
-
-function ImportSpecifier(node) {
-  if (node.importKind === 'type' || node.importKind === 'typeof') {
-    this.word(node.importKind);
-    this.space();
-  }
-
-  this.print(node.imported, node);
-
-  if (node.local && node.local.name !== node.imported.name) {
-    this.space();
-    this.word('as');
-    this.space();
-    this.print(node.local, node);
-  }
-}
-
-function ImportDefaultSpecifier(node) {
-  this.print(node.local, node);
-}
-
-function ExportDefaultSpecifier(node) {
-  this.print(node.exported, node);
-}
-
-function ExportSpecifier(node) {
-  if (node.exportKind === 'type') {
-    this.word('type');
-    this.space();
-  }
-
-  this.print(node.local, node);
-
-  if (node.exported && node.local.name !== node.exported.name) {
-    this.space();
-    this.word('as');
-    this.space();
-    this.print(node.exported, node);
-  }
-}
-
-function ExportNamespaceSpecifier(node) {
-  this.token('*');
-  this.space();
-  this.word('as');
-  this.space();
-  this.print(node.exported, node);
-}
-
-function ExportAllDeclaration(node) {
-  this.word('export');
-  this.space();
-
-  if (node.exportKind === 'type') {
-    this.word('type');
-    this.space();
-  }
-
-  this.token('*');
-  this.space();
-  this.word('from');
-  this.space();
-  this.print(node.source, node);
-  this.printAssertions(node);
-  this.semicolon();
-}
-
-function ExportNamedDeclaration(node) {
-  if (
-    this.format.decoratorsBeforeExport &&
-    isClassDeclaration(node.declaration)
-  ) {
-    this.printJoin(node.declaration.decorators, node);
-  }
-
-  this.word('export');
-  this.space();
-  ExportDeclaration.apply(this, arguments);
-}
-
-function ExportDefaultDeclaration(node) {
-  if (
-    this.format.decoratorsBeforeExport &&
-    isClassDeclaration(node.declaration)
-  ) {
-    this.printJoin(node.declaration.decorators, node);
-  }
-
-  this.word('export');
-  this.space();
-  this.word('default');
-  this.space();
-  ExportDeclaration.apply(this, arguments);
-}
-
-function ExportDeclaration(node) {
-  if (node.declaration) {
-    const declar = node.declaration;
-    this.print(declar, node);
-    if (!isStatement(declar)) this.semicolon();
-  } else {
-    if (node.exportKind === 'type') {
-      this.word('type');
-      this.space();
-    }
-
-    const specifiers = node.specifiers.slice(0);
-    let hasSpecial = false;
-
-    for (;;) {
-      const first = specifiers[0];
-
-      if (
-        isExportDefaultSpecifier(first) ||
-        isExportNamespaceSpecifier(first)
-      ) {
-        hasSpecial = true;
-        this.print(specifiers.shift(), node);
-
-        if (specifiers.length) {
-          this.token(',');
-          this.space();
-        }
-      } else {
-        break;
-      }
-    }
-
-    if (specifiers.length || (!specifiers.length && !hasSpecial)) {
-      this.token('{');
-
-      if (specifiers.length) {
-        this.space();
-        this.printList(specifiers, node);
-        this.space();
-      }
-
-      this.token('}');
-    }
-
-    if (node.source) {
-      this.space();
-      this.word('from');
-      this.space();
-      this.print(node.source, node);
-      this.printAssertions(node);
-    }
-
-    this.semicolon();
-  }
-}
-
-function ImportDeclaration(node) {
-  this.word('import');
-  this.space();
-  const isTypeKind = node.importKind === 'type' || node.importKind === 'typeof';
-
-  if (isTypeKind) {
-    this.word(node.importKind);
-    this.space();
-  }
-
-  const specifiers = node.specifiers.slice(0);
-  const hasSpecifiers = !!specifiers.length;
-
-  while (hasSpecifiers) {
-    const first = specifiers[0];
-
-    if (isImportDefaultSpecifier(first) || isImportNamespaceSpecifier(first)) {
-      this.print(specifiers.shift(), node);
-
-      if (specifiers.length) {
-        this.token(',');
-        this.space();
-      }
-    } else {
-      break;
-    }
-  }
-
-  if (specifiers.length) {
-    this.token('{');
-    this.space();
-    this.printList(specifiers, node);
-    this.space();
-    this.token('}');
-  } else if (isTypeKind && !hasSpecifiers) {
-    this.token('{');
-    this.token('}');
-  }
-
-  if (hasSpecifiers || isTypeKind) {
-    this.space();
-    this.word('from');
-    this.space();
-  }
-
-  this.print(node.source, node);
-  this.printAssertions(node);
-  {
-    var _node$attributes;
-
-    if (
-      (_node$attributes = node.attributes) != null &&
-      _node$attributes.length
-    ) {
-      this.space();
-      this.word('with');
-      this.space();
-      this.printList(node.attributes, node);
-    }
-  }
-  this.semicolon();
-}
-
-function ImportAttribute(node) {
-  this.print(node.key);
-  this.token(':');
-  this.space();
-  this.print(node.value);
-}
-
-function ImportNamespaceSpecifier(node) {
-  this.token('*');
-  this.space();
-  this.word('as');
-  this.space();
-  this.print(node.local, node);
-}

node_modules/@babel/generator/lib/generators/statements.js

@@ -1,329 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.BreakStatement = void 0;
-exports.CatchClause = CatchClause;
-exports.ContinueStatement = void 0;
-exports.DebuggerStatement = DebuggerStatement;
-exports.DoWhileStatement = DoWhileStatement;
-exports.ForOfStatement = exports.ForInStatement = void 0;
-exports.ForStatement = ForStatement;
-exports.IfStatement = IfStatement;
-exports.LabeledStatement = LabeledStatement;
-exports.ReturnStatement = void 0;
-exports.SwitchCase = SwitchCase;
-exports.SwitchStatement = SwitchStatement;
-exports.ThrowStatement = void 0;
-exports.TryStatement = TryStatement;
-exports.VariableDeclaration = VariableDeclaration;
-exports.VariableDeclarator = VariableDeclarator;
-exports.WhileStatement = WhileStatement;
-exports.WithStatement = WithStatement;
-
-var _t = require('@babel/types');
-
-const { isFor, isForStatement, isIfStatement, isStatement } = _t;
-
-function WithStatement(node) {
-  this.word('with');
-  this.space();
-  this.token('(');
-  this.print(node.object, node);
-  this.token(')');
-  this.printBlock(node);
-}
-
-function IfStatement(node) {
-  this.word('if');
-  this.space();
-  this.token('(');
-  this.print(node.test, node);
-  this.token(')');
-  this.space();
-  const needsBlock =
-    node.alternate && isIfStatement(getLastStatement(node.consequent));
-
-  if (needsBlock) {
-    this.token('{');
-    this.newline();
-    this.indent();
-  }
-
-  this.printAndIndentOnComments(node.consequent, node);
-
-  if (needsBlock) {
-    this.dedent();
-    this.newline();
-    this.token('}');
-  }
-
-  if (node.alternate) {
-    if (this.endsWith(125)) this.space();
-    this.word('else');
-    this.space();
-    this.printAndIndentOnComments(node.alternate, node);
-  }
-}
-
-function getLastStatement(statement) {
-  if (!isStatement(statement.body)) return statement;
-  return getLastStatement(statement.body);
-}
-
-function ForStatement(node) {
-  this.word('for');
-  this.space();
-  this.token('(');
-  this.inForStatementInitCounter++;
-  this.print(node.init, node);
-  this.inForStatementInitCounter--;
-  this.token(';');
-
-  if (node.test) {
-    this.space();
-    this.print(node.test, node);
-  }
-
-  this.token(';');
-
-  if (node.update) {
-    this.space();
-    this.print(node.update, node);
-  }
-
-  this.token(')');
-  this.printBlock(node);
-}
-
-function WhileStatement(node) {
-  this.word('while');
-  this.space();
-  this.token('(');
-  this.print(node.test, node);
-  this.token(')');
-  this.printBlock(node);
-}
-
-const buildForXStatement = function (op) {
-  return function (node) {
-    this.word('for');
-    this.space();
-
-    if (op === 'of' && node.await) {
-      this.word('await');
-      this.space();
-    }
-
-    this.token('(');
-    this.print(node.left, node);
-    this.space();
-    this.word(op);
-    this.space();
-    this.print(node.right, node);
-    this.token(')');
-    this.printBlock(node);
-  };
-};
-
-const ForInStatement = buildForXStatement('in');
-exports.ForInStatement = ForInStatement;
-const ForOfStatement = buildForXStatement('of');
-exports.ForOfStatement = ForOfStatement;
-
-function DoWhileStatement(node) {
-  this.word('do');
-  this.space();
-  this.print(node.body, node);
-  this.space();
-  this.word('while');
-  this.space();
-  this.token('(');
-  this.print(node.test, node);
-  this.token(')');
-  this.semicolon();
-}
-
-function buildLabelStatement(prefix, key = 'label') {
-  return function (node) {
-    this.word(prefix);
-    const label = node[key];
-
-    if (label) {
-      this.space();
-      const isLabel = key == 'label';
-      const terminatorState = this.startTerminatorless(isLabel);
-      this.print(label, node);
-      this.endTerminatorless(terminatorState);
-    }
-
-    this.semicolon();
-  };
-}
-
-const ContinueStatement = buildLabelStatement('continue');
-exports.ContinueStatement = ContinueStatement;
-const ReturnStatement = buildLabelStatement('return', 'argument');
-exports.ReturnStatement = ReturnStatement;
-const BreakStatement = buildLabelStatement('break');
-exports.BreakStatement = BreakStatement;
-const ThrowStatement = buildLabelStatement('throw', 'argument');
-exports.ThrowStatement = ThrowStatement;
-
-function LabeledStatement(node) {
-  this.print(node.label, node);
-  this.token(':');
-  this.space();
-  this.print(node.body, node);
-}
-
-function TryStatement(node) {
-  this.word('try');
-  this.space();
-  this.print(node.block, node);
-  this.space();
-
-  if (node.handlers) {
-    this.print(node.handlers[0], node);
-  } else {
-    this.print(node.handler, node);
-  }
-
-  if (node.finalizer) {
-    this.space();
-    this.word('finally');
-    this.space();
-    this.print(node.finalizer, node);
-  }
-}
-
-function CatchClause(node) {
-  this.word('catch');
-  this.space();
-
-  if (node.param) {
-    this.token('(');
-    this.print(node.param, node);
-    this.print(node.param.typeAnnotation, node);
-    this.token(')');
-    this.space();
-  }
-
-  this.print(node.body, node);
-}
-
-function SwitchStatement(node) {
-  this.word('switch');
-  this.space();
-  this.token('(');
-  this.print(node.discriminant, node);
-  this.token(')');
-  this.space();
-  this.token('{');
-  this.printSequence(node.cases, node, {
-    indent: true,
-
-    addNewlines(leading, cas) {
-      if (!leading && node.cases[node.cases.length - 1] === cas) return -1;
-    },
-  });
-  this.token('}');
-}
-
-function SwitchCase(node) {
-  if (node.test) {
-    this.word('case');
-    this.space();
-    this.print(node.test, node);
-    this.token(':');
-  } else {
-    this.word('default');
-    this.token(':');
-  }
-
-  if (node.consequent.length) {
-    this.newline();
-    this.printSequence(node.consequent, node, {
-      indent: true,
-    });
-  }
-}
-
-function DebuggerStatement() {
-  this.word('debugger');
-  this.semicolon();
-}
-
-function variableDeclarationIndent() {
-  this.token(',');
-  this.newline();
-
-  if (this.endsWith(10)) {
-    for (let i = 0; i < 4; i++) this.space(true);
-  }
-}
-
-function constDeclarationIndent() {
-  this.token(',');
-  this.newline();
-
-  if (this.endsWith(10)) {
-    for (let i = 0; i < 6; i++) this.space(true);
-  }
-}
-
-function VariableDeclaration(node, parent) {
-  if (node.declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  this.word(node.kind);
-  this.space();
-  let hasInits = false;
-
-  if (!isFor(parent)) {
-    for (const declar of node.declarations) {
-      if (declar.init) {
-        hasInits = true;
-      }
-    }
-  }
-
-  let separator;
-
-  if (hasInits) {
-    separator =
-      node.kind === 'const' ?
-        constDeclarationIndent
-      : variableDeclarationIndent;
-  }
-
-  this.printList(node.declarations, node, {
-    separator,
-  });
-
-  if (isFor(parent)) {
-    if (isForStatement(parent)) {
-      if (parent.init === node) return;
-    } else {
-      if (parent.left === node) return;
-    }
-  }
-
-  this.semicolon();
-}
-
-function VariableDeclarator(node) {
-  this.print(node.id, node);
-  if (node.definite) this.token('!');
-  this.print(node.id.typeAnnotation, node);
-
-  if (node.init) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(node.init, node);
-  }
-}

node_modules/@babel/generator/lib/generators/template-literals.js

@@ -1,33 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.TaggedTemplateExpression = TaggedTemplateExpression;
-exports.TemplateElement = TemplateElement;
-exports.TemplateLiteral = TemplateLiteral;
-
-function TaggedTemplateExpression(node) {
-  this.print(node.tag, node);
-  this.print(node.typeParameters, node);
-  this.print(node.quasi, node);
-}
-
-function TemplateElement(node, parent) {
-  const isFirst = parent.quasis[0] === node;
-  const isLast = parent.quasis[parent.quasis.length - 1] === node;
-  const value = (isFirst ? '`' : '}') + node.value.raw + (isLast ? '`' : '${');
-  this.token(value);
-}
-
-function TemplateLiteral(node) {
-  const quasis = node.quasis;
-
-  for (let i = 0; i < quasis.length; i++) {
-    this.print(quasis[i], node);
-
-    if (i + 1 < quasis.length) {
-      this.print(node.expressions[i], node);
-    }
-  }
-}

node_modules/@babel/generator/lib/generators/types.js

@@ -1,295 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.ArgumentPlaceholder = ArgumentPlaceholder;
-exports.ArrayPattern = exports.ArrayExpression = ArrayExpression;
-exports.BigIntLiteral = BigIntLiteral;
-exports.BooleanLiteral = BooleanLiteral;
-exports.DecimalLiteral = DecimalLiteral;
-exports.Identifier = Identifier;
-exports.NullLiteral = NullLiteral;
-exports.NumericLiteral = NumericLiteral;
-exports.ObjectPattern = exports.ObjectExpression = ObjectExpression;
-exports.ObjectMethod = ObjectMethod;
-exports.ObjectProperty = ObjectProperty;
-exports.PipelineBareFunction = PipelineBareFunction;
-exports.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
-exports.PipelineTopicExpression = PipelineTopicExpression;
-exports.RecordExpression = RecordExpression;
-exports.RegExpLiteral = RegExpLiteral;
-exports.SpreadElement = exports.RestElement = RestElement;
-exports.StringLiteral = StringLiteral;
-exports.TopicReference = TopicReference;
-exports.TupleExpression = TupleExpression;
-
-var _t = require('@babel/types');
-
-var _jsesc = require('jsesc');
-
-const { isAssignmentPattern, isIdentifier } = _t;
-
-function Identifier(node) {
-  this.exactSource(node.loc, () => {
-    this.word(node.name);
-  });
-}
-
-function ArgumentPlaceholder() {
-  this.token('?');
-}
-
-function RestElement(node) {
-  this.token('...');
-  this.print(node.argument, node);
-}
-
-function ObjectExpression(node) {
-  const props = node.properties;
-  this.token('{');
-  this.printInnerComments(node);
-
-  if (props.length) {
-    this.space();
-    this.printList(props, node, {
-      indent: true,
-      statement: true,
-    });
-    this.space();
-  }
-
-  this.token('}');
-}
-
-function ObjectMethod(node) {
-  this.printJoin(node.decorators, node);
-
-  this._methodHead(node);
-
-  this.space();
-  this.print(node.body, node);
-}
-
-function ObjectProperty(node) {
-  this.printJoin(node.decorators, node);
-
-  if (node.computed) {
-    this.token('[');
-    this.print(node.key, node);
-    this.token(']');
-  } else {
-    if (
-      isAssignmentPattern(node.value) &&
-      isIdentifier(node.key) &&
-      node.key.name === node.value.left.name
-    ) {
-      this.print(node.value, node);
-      return;
-    }
-
-    this.print(node.key, node);
-
-    if (
-      node.shorthand &&
-      isIdentifier(node.key) &&
-      isIdentifier(node.value) &&
-      node.key.name === node.value.name
-    ) {
-      return;
-    }
-  }
-
-  this.token(':');
-  this.space();
-  this.print(node.value, node);
-}
-
-function ArrayExpression(node) {
-  const elems = node.elements;
-  const len = elems.length;
-  this.token('[');
-  this.printInnerComments(node);
-
-  for (let i = 0; i < elems.length; i++) {
-    const elem = elems[i];
-
-    if (elem) {
-      if (i > 0) this.space();
-      this.print(elem, node);
-      if (i < len - 1) this.token(',');
-    } else {
-      this.token(',');
-    }
-  }
-
-  this.token(']');
-}
-
-function RecordExpression(node) {
-  const props = node.properties;
-  let startToken;
-  let endToken;
-
-  if (this.format.recordAndTupleSyntaxType === 'bar') {
-    startToken = '{|';
-    endToken = '|}';
-  } else if (this.format.recordAndTupleSyntaxType === 'hash') {
-    startToken = '#{';
-    endToken = '}';
-  } else {
-    throw new Error(
-      `The "recordAndTupleSyntaxType" generator option must be "bar" or "hash" (${JSON.stringify(this.format.recordAndTupleSyntaxType)} received).`
-    );
-  }
-
-  this.token(startToken);
-  this.printInnerComments(node);
-
-  if (props.length) {
-    this.space();
-    this.printList(props, node, {
-      indent: true,
-      statement: true,
-    });
-    this.space();
-  }
-
-  this.token(endToken);
-}
-
-function TupleExpression(node) {
-  const elems = node.elements;
-  const len = elems.length;
-  let startToken;
-  let endToken;
-
-  if (this.format.recordAndTupleSyntaxType === 'bar') {
-    startToken = '[|';
-    endToken = '|]';
-  } else if (this.format.recordAndTupleSyntaxType === 'hash') {
-    startToken = '#[';
-    endToken = ']';
-  } else {
-    throw new Error(
-      `${this.format.recordAndTupleSyntaxType} is not a valid recordAndTuple syntax type`
-    );
-  }
-
-  this.token(startToken);
-  this.printInnerComments(node);
-
-  for (let i = 0; i < elems.length; i++) {
-    const elem = elems[i];
-
-    if (elem) {
-      if (i > 0) this.space();
-      this.print(elem, node);
-      if (i < len - 1) this.token(',');
-    }
-  }
-
-  this.token(endToken);
-}
-
-function RegExpLiteral(node) {
-  this.word(`/${node.pattern}/${node.flags}`);
-}
-
-function BooleanLiteral(node) {
-  this.word(node.value ? 'true' : 'false');
-}
-
-function NullLiteral() {
-  this.word('null');
-}
-
-function NumericLiteral(node) {
-  const raw = this.getPossibleRaw(node);
-  const opts = this.format.jsescOption;
-  const value = node.value + '';
-
-  if (opts.numbers) {
-    this.number(_jsesc(node.value, opts));
-  } else if (raw == null) {
-    this.number(value);
-  } else if (this.format.minified) {
-    this.number(raw.length < value.length ? raw : value);
-  } else {
-    this.number(raw);
-  }
-}
-
-function StringLiteral(node) {
-  const raw = this.getPossibleRaw(node);
-
-  if (!this.format.minified && raw != null) {
-    this.token(raw);
-    return;
-  }
-
-  const val = _jsesc(
-    node.value,
-    Object.assign(
-      this.format.jsescOption,
-      this.format.jsonCompatibleStrings && {
-        json: true,
-      }
-    )
-  );
-
-  return this.token(val);
-}
-
-function BigIntLiteral(node) {
-  const raw = this.getPossibleRaw(node);
-
-  if (!this.format.minified && raw != null) {
-    this.word(raw);
-    return;
-  }
-
-  this.word(node.value + 'n');
-}
-
-function DecimalLiteral(node) {
-  const raw = this.getPossibleRaw(node);
-
-  if (!this.format.minified && raw != null) {
-    this.word(raw);
-    return;
-  }
-
-  this.word(node.value + 'm');
-}
-
-const validTopicTokenSet = new Set(['^^', '@@', '^', '%', '#']);
-
-function TopicReference() {
-  const { topicToken } = this.format;
-
-  if (validTopicTokenSet.has(topicToken)) {
-    this.token(topicToken);
-  } else {
-    const givenTopicTokenJSON = JSON.stringify(topicToken);
-    const validTopics = Array.from(validTopicTokenSet, (v) =>
-      JSON.stringify(v)
-    );
-    throw new Error(
-      `The "topicToken" generator option must be one of ` +
-        `${validTopics.join(', ')} (${givenTopicTokenJSON} received instead).`
-    );
-  }
-}
-
-function PipelineTopicExpression(node) {
-  this.print(node.expression, node);
-}
-
-function PipelineBareFunction(node) {
-  this.print(node.callee, node);
-}
-
-function PipelinePrimaryTopicReference() {
-  this.token('#');
-}

node_modules/@babel/generator/lib/generators/typescript.js

@@ -1,780 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.TSAnyKeyword = TSAnyKeyword;
-exports.TSArrayType = TSArrayType;
-exports.TSAsExpression = TSAsExpression;
-exports.TSBigIntKeyword = TSBigIntKeyword;
-exports.TSBooleanKeyword = TSBooleanKeyword;
-exports.TSCallSignatureDeclaration = TSCallSignatureDeclaration;
-exports.TSConditionalType = TSConditionalType;
-exports.TSConstructSignatureDeclaration = TSConstructSignatureDeclaration;
-exports.TSConstructorType = TSConstructorType;
-exports.TSDeclareFunction = TSDeclareFunction;
-exports.TSDeclareMethod = TSDeclareMethod;
-exports.TSEnumDeclaration = TSEnumDeclaration;
-exports.TSEnumMember = TSEnumMember;
-exports.TSExportAssignment = TSExportAssignment;
-exports.TSExpressionWithTypeArguments = TSExpressionWithTypeArguments;
-exports.TSExternalModuleReference = TSExternalModuleReference;
-exports.TSFunctionType = TSFunctionType;
-exports.TSImportEqualsDeclaration = TSImportEqualsDeclaration;
-exports.TSImportType = TSImportType;
-exports.TSIndexSignature = TSIndexSignature;
-exports.TSIndexedAccessType = TSIndexedAccessType;
-exports.TSInferType = TSInferType;
-exports.TSInstantiationExpression = TSInstantiationExpression;
-exports.TSInterfaceBody = TSInterfaceBody;
-exports.TSInterfaceDeclaration = TSInterfaceDeclaration;
-exports.TSIntersectionType = TSIntersectionType;
-exports.TSIntrinsicKeyword = TSIntrinsicKeyword;
-exports.TSLiteralType = TSLiteralType;
-exports.TSMappedType = TSMappedType;
-exports.TSMethodSignature = TSMethodSignature;
-exports.TSModuleBlock = TSModuleBlock;
-exports.TSModuleDeclaration = TSModuleDeclaration;
-exports.TSNamedTupleMember = TSNamedTupleMember;
-exports.TSNamespaceExportDeclaration = TSNamespaceExportDeclaration;
-exports.TSNeverKeyword = TSNeverKeyword;
-exports.TSNonNullExpression = TSNonNullExpression;
-exports.TSNullKeyword = TSNullKeyword;
-exports.TSNumberKeyword = TSNumberKeyword;
-exports.TSObjectKeyword = TSObjectKeyword;
-exports.TSOptionalType = TSOptionalType;
-exports.TSParameterProperty = TSParameterProperty;
-exports.TSParenthesizedType = TSParenthesizedType;
-exports.TSPropertySignature = TSPropertySignature;
-exports.TSQualifiedName = TSQualifiedName;
-exports.TSRestType = TSRestType;
-exports.TSStringKeyword = TSStringKeyword;
-exports.TSSymbolKeyword = TSSymbolKeyword;
-exports.TSThisType = TSThisType;
-exports.TSTupleType = TSTupleType;
-exports.TSTypeAliasDeclaration = TSTypeAliasDeclaration;
-exports.TSTypeAnnotation = TSTypeAnnotation;
-exports.TSTypeAssertion = TSTypeAssertion;
-exports.TSTypeLiteral = TSTypeLiteral;
-exports.TSTypeOperator = TSTypeOperator;
-exports.TSTypeParameter = TSTypeParameter;
-exports.TSTypeParameterDeclaration = exports.TSTypeParameterInstantiation =
-  TSTypeParameterInstantiation;
-exports.TSTypePredicate = TSTypePredicate;
-exports.TSTypeQuery = TSTypeQuery;
-exports.TSTypeReference = TSTypeReference;
-exports.TSUndefinedKeyword = TSUndefinedKeyword;
-exports.TSUnionType = TSUnionType;
-exports.TSUnknownKeyword = TSUnknownKeyword;
-exports.TSVoidKeyword = TSVoidKeyword;
-exports.tsPrintBraced = tsPrintBraced;
-exports.tsPrintClassMemberModifiers = tsPrintClassMemberModifiers;
-exports.tsPrintFunctionOrConstructorType = tsPrintFunctionOrConstructorType;
-exports.tsPrintPropertyOrMethodName = tsPrintPropertyOrMethodName;
-exports.tsPrintSignatureDeclarationBase = tsPrintSignatureDeclarationBase;
-exports.tsPrintTypeLiteralOrInterfaceBody = tsPrintTypeLiteralOrInterfaceBody;
-exports.tsPrintUnionOrIntersectionType = tsPrintUnionOrIntersectionType;
-
-function TSTypeAnnotation(node) {
-  this.token(':');
-  this.space();
-  if (node.optional) this.token('?');
-  this.print(node.typeAnnotation, node);
-}
-
-function TSTypeParameterInstantiation(node, parent) {
-  this.token('<');
-  this.printList(node.params, node, {});
-
-  if (parent.type === 'ArrowFunctionExpression' && node.params.length === 1) {
-    this.token(',');
-  }
-
-  this.token('>');
-}
-
-function TSTypeParameter(node) {
-  if (node.in) {
-    this.word('in');
-    this.space();
-  }
-
-  if (node.out) {
-    this.word('out');
-    this.space();
-  }
-
-  this.word(node.name);
-
-  if (node.constraint) {
-    this.space();
-    this.word('extends');
-    this.space();
-    this.print(node.constraint, node);
-  }
-
-  if (node.default) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(node.default, node);
-  }
-}
-
-function TSParameterProperty(node) {
-  if (node.accessibility) {
-    this.word(node.accessibility);
-    this.space();
-  }
-
-  if (node.readonly) {
-    this.word('readonly');
-    this.space();
-  }
-
-  this._param(node.parameter);
-}
-
-function TSDeclareFunction(node) {
-  if (node.declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  this._functionHead(node);
-
-  this.token(';');
-}
-
-function TSDeclareMethod(node) {
-  this._classMethodHead(node);
-
-  this.token(';');
-}
-
-function TSQualifiedName(node) {
-  this.print(node.left, node);
-  this.token('.');
-  this.print(node.right, node);
-}
-
-function TSCallSignatureDeclaration(node) {
-  this.tsPrintSignatureDeclarationBase(node);
-  this.token(';');
-}
-
-function TSConstructSignatureDeclaration(node) {
-  this.word('new');
-  this.space();
-  this.tsPrintSignatureDeclarationBase(node);
-  this.token(';');
-}
-
-function TSPropertySignature(node) {
-  const { readonly, initializer } = node;
-
-  if (readonly) {
-    this.word('readonly');
-    this.space();
-  }
-
-  this.tsPrintPropertyOrMethodName(node);
-  this.print(node.typeAnnotation, node);
-
-  if (initializer) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(initializer, node);
-  }
-
-  this.token(';');
-}
-
-function tsPrintPropertyOrMethodName(node) {
-  if (node.computed) {
-    this.token('[');
-  }
-
-  this.print(node.key, node);
-
-  if (node.computed) {
-    this.token(']');
-  }
-
-  if (node.optional) {
-    this.token('?');
-  }
-}
-
-function TSMethodSignature(node) {
-  const { kind } = node;
-
-  if (kind === 'set' || kind === 'get') {
-    this.word(kind);
-    this.space();
-  }
-
-  this.tsPrintPropertyOrMethodName(node);
-  this.tsPrintSignatureDeclarationBase(node);
-  this.token(';');
-}
-
-function TSIndexSignature(node) {
-  const { readonly, static: isStatic } = node;
-
-  if (isStatic) {
-    this.word('static');
-    this.space();
-  }
-
-  if (readonly) {
-    this.word('readonly');
-    this.space();
-  }
-
-  this.token('[');
-
-  this._parameters(node.parameters, node);
-
-  this.token(']');
-  this.print(node.typeAnnotation, node);
-  this.token(';');
-}
-
-function TSAnyKeyword() {
-  this.word('any');
-}
-
-function TSBigIntKeyword() {
-  this.word('bigint');
-}
-
-function TSUnknownKeyword() {
-  this.word('unknown');
-}
-
-function TSNumberKeyword() {
-  this.word('number');
-}
-
-function TSObjectKeyword() {
-  this.word('object');
-}
-
-function TSBooleanKeyword() {
-  this.word('boolean');
-}
-
-function TSStringKeyword() {
-  this.word('string');
-}
-
-function TSSymbolKeyword() {
-  this.word('symbol');
-}
-
-function TSVoidKeyword() {
-  this.word('void');
-}
-
-function TSUndefinedKeyword() {
-  this.word('undefined');
-}
-
-function TSNullKeyword() {
-  this.word('null');
-}
-
-function TSNeverKeyword() {
-  this.word('never');
-}
-
-function TSIntrinsicKeyword() {
-  this.word('intrinsic');
-}
-
-function TSThisType() {
-  this.word('this');
-}
-
-function TSFunctionType(node) {
-  this.tsPrintFunctionOrConstructorType(node);
-}
-
-function TSConstructorType(node) {
-  if (node.abstract) {
-    this.word('abstract');
-    this.space();
-  }
-
-  this.word('new');
-  this.space();
-  this.tsPrintFunctionOrConstructorType(node);
-}
-
-function tsPrintFunctionOrConstructorType(node) {
-  const { typeParameters } = node;
-  const parameters = node.parameters;
-  this.print(typeParameters, node);
-  this.token('(');
-
-  this._parameters(parameters, node);
-
-  this.token(')');
-  this.space();
-  this.token('=>');
-  this.space();
-  const returnType = node.typeAnnotation;
-  this.print(returnType.typeAnnotation, node);
-}
-
-function TSTypeReference(node) {
-  this.print(node.typeName, node);
-  this.print(node.typeParameters, node);
-}
-
-function TSTypePredicate(node) {
-  if (node.asserts) {
-    this.word('asserts');
-    this.space();
-  }
-
-  this.print(node.parameterName);
-
-  if (node.typeAnnotation) {
-    this.space();
-    this.word('is');
-    this.space();
-    this.print(node.typeAnnotation.typeAnnotation);
-  }
-}
-
-function TSTypeQuery(node) {
-  this.word('typeof');
-  this.space();
-  this.print(node.exprName);
-
-  if (node.typeParameters) {
-    this.print(node.typeParameters, node);
-  }
-}
-
-function TSTypeLiteral(node) {
-  this.tsPrintTypeLiteralOrInterfaceBody(node.members, node);
-}
-
-function tsPrintTypeLiteralOrInterfaceBody(members, node) {
-  this.tsPrintBraced(members, node);
-}
-
-function tsPrintBraced(members, node) {
-  this.token('{');
-
-  if (members.length) {
-    this.indent();
-    this.newline();
-
-    for (const member of members) {
-      this.print(member, node);
-      this.newline();
-    }
-
-    this.dedent();
-    this.rightBrace();
-  } else {
-    this.token('}');
-  }
-}
-
-function TSArrayType(node) {
-  this.print(node.elementType, node);
-  this.token('[]');
-}
-
-function TSTupleType(node) {
-  this.token('[');
-  this.printList(node.elementTypes, node);
-  this.token(']');
-}
-
-function TSOptionalType(node) {
-  this.print(node.typeAnnotation, node);
-  this.token('?');
-}
-
-function TSRestType(node) {
-  this.token('...');
-  this.print(node.typeAnnotation, node);
-}
-
-function TSNamedTupleMember(node) {
-  this.print(node.label, node);
-  if (node.optional) this.token('?');
-  this.token(':');
-  this.space();
-  this.print(node.elementType, node);
-}
-
-function TSUnionType(node) {
-  this.tsPrintUnionOrIntersectionType(node, '|');
-}
-
-function TSIntersectionType(node) {
-  this.tsPrintUnionOrIntersectionType(node, '&');
-}
-
-function tsPrintUnionOrIntersectionType(node, sep) {
-  this.printJoin(node.types, node, {
-    separator() {
-      this.space();
-      this.token(sep);
-      this.space();
-    },
-  });
-}
-
-function TSConditionalType(node) {
-  this.print(node.checkType);
-  this.space();
-  this.word('extends');
-  this.space();
-  this.print(node.extendsType);
-  this.space();
-  this.token('?');
-  this.space();
-  this.print(node.trueType);
-  this.space();
-  this.token(':');
-  this.space();
-  this.print(node.falseType);
-}
-
-function TSInferType(node) {
-  this.token('infer');
-  this.space();
-  this.print(node.typeParameter);
-}
-
-function TSParenthesizedType(node) {
-  this.token('(');
-  this.print(node.typeAnnotation, node);
-  this.token(')');
-}
-
-function TSTypeOperator(node) {
-  this.word(node.operator);
-  this.space();
-  this.print(node.typeAnnotation, node);
-}
-
-function TSIndexedAccessType(node) {
-  this.print(node.objectType, node);
-  this.token('[');
-  this.print(node.indexType, node);
-  this.token(']');
-}
-
-function TSMappedType(node) {
-  const { nameType, optional, readonly, typeParameter } = node;
-  this.token('{');
-  this.space();
-
-  if (readonly) {
-    tokenIfPlusMinus(this, readonly);
-    this.word('readonly');
-    this.space();
-  }
-
-  this.token('[');
-  this.word(typeParameter.name);
-  this.space();
-  this.word('in');
-  this.space();
-  this.print(typeParameter.constraint, typeParameter);
-
-  if (nameType) {
-    this.space();
-    this.word('as');
-    this.space();
-    this.print(nameType, node);
-  }
-
-  this.token(']');
-
-  if (optional) {
-    tokenIfPlusMinus(this, optional);
-    this.token('?');
-  }
-
-  this.token(':');
-  this.space();
-  this.print(node.typeAnnotation, node);
-  this.space();
-  this.token('}');
-}
-
-function tokenIfPlusMinus(self, tok) {
-  if (tok !== true) {
-    self.token(tok);
-  }
-}
-
-function TSLiteralType(node) {
-  this.print(node.literal, node);
-}
-
-function TSExpressionWithTypeArguments(node) {
-  this.print(node.expression, node);
-  this.print(node.typeParameters, node);
-}
-
-function TSInterfaceDeclaration(node) {
-  const { declare, id, typeParameters, extends: extendz, body } = node;
-
-  if (declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  this.word('interface');
-  this.space();
-  this.print(id, node);
-  this.print(typeParameters, node);
-
-  if (extendz != null && extendz.length) {
-    this.space();
-    this.word('extends');
-    this.space();
-    this.printList(extendz, node);
-  }
-
-  this.space();
-  this.print(body, node);
-}
-
-function TSInterfaceBody(node) {
-  this.tsPrintTypeLiteralOrInterfaceBody(node.body, node);
-}
-
-function TSTypeAliasDeclaration(node) {
-  const { declare, id, typeParameters, typeAnnotation } = node;
-
-  if (declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  this.word('type');
-  this.space();
-  this.print(id, node);
-  this.print(typeParameters, node);
-  this.space();
-  this.token('=');
-  this.space();
-  this.print(typeAnnotation, node);
-  this.token(';');
-}
-
-function TSAsExpression(node) {
-  const { expression, typeAnnotation } = node;
-  this.print(expression, node);
-  this.space();
-  this.word('as');
-  this.space();
-  this.print(typeAnnotation, node);
-}
-
-function TSTypeAssertion(node) {
-  const { typeAnnotation, expression } = node;
-  this.token('<');
-  this.print(typeAnnotation, node);
-  this.token('>');
-  this.space();
-  this.print(expression, node);
-}
-
-function TSInstantiationExpression(node) {
-  this.print(node.expression, node);
-  this.print(node.typeParameters, node);
-}
-
-function TSEnumDeclaration(node) {
-  const { declare, const: isConst, id, members } = node;
-
-  if (declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  if (isConst) {
-    this.word('const');
-    this.space();
-  }
-
-  this.word('enum');
-  this.space();
-  this.print(id, node);
-  this.space();
-  this.tsPrintBraced(members, node);
-}
-
-function TSEnumMember(node) {
-  const { id, initializer } = node;
-  this.print(id, node);
-
-  if (initializer) {
-    this.space();
-    this.token('=');
-    this.space();
-    this.print(initializer, node);
-  }
-
-  this.token(',');
-}
-
-function TSModuleDeclaration(node) {
-  const { declare, id } = node;
-
-  if (declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  if (!node.global) {
-    this.word(id.type === 'Identifier' ? 'namespace' : 'module');
-    this.space();
-  }
-
-  this.print(id, node);
-
-  if (!node.body) {
-    this.token(';');
-    return;
-  }
-
-  let body = node.body;
-
-  while (body.type === 'TSModuleDeclaration') {
-    this.token('.');
-    this.print(body.id, body);
-    body = body.body;
-  }
-
-  this.space();
-  this.print(body, node);
-}
-
-function TSModuleBlock(node) {
-  this.tsPrintBraced(node.body, node);
-}
-
-function TSImportType(node) {
-  const { argument, qualifier, typeParameters } = node;
-  this.word('import');
-  this.token('(');
-  this.print(argument, node);
-  this.token(')');
-
-  if (qualifier) {
-    this.token('.');
-    this.print(qualifier, node);
-  }
-
-  if (typeParameters) {
-    this.print(typeParameters, node);
-  }
-}
-
-function TSImportEqualsDeclaration(node) {
-  const { isExport, id, moduleReference } = node;
-
-  if (isExport) {
-    this.word('export');
-    this.space();
-  }
-
-  this.word('import');
-  this.space();
-  this.print(id, node);
-  this.space();
-  this.token('=');
-  this.space();
-  this.print(moduleReference, node);
-  this.token(';');
-}
-
-function TSExternalModuleReference(node) {
-  this.token('require(');
-  this.print(node.expression, node);
-  this.token(')');
-}
-
-function TSNonNullExpression(node) {
-  this.print(node.expression, node);
-  this.token('!');
-}
-
-function TSExportAssignment(node) {
-  this.word('export');
-  this.space();
-  this.token('=');
-  this.space();
-  this.print(node.expression, node);
-  this.token(';');
-}
-
-function TSNamespaceExportDeclaration(node) {
-  this.word('export');
-  this.space();
-  this.word('as');
-  this.space();
-  this.word('namespace');
-  this.space();
-  this.print(node.id, node);
-}
-
-function tsPrintSignatureDeclarationBase(node) {
-  const { typeParameters } = node;
-  const parameters = node.parameters;
-  this.print(typeParameters, node);
-  this.token('(');
-
-  this._parameters(parameters, node);
-
-  this.token(')');
-  const returnType = node.typeAnnotation;
-  this.print(returnType, node);
-}
-
-function tsPrintClassMemberModifiers(node, isField) {
-  if (isField && node.declare) {
-    this.word('declare');
-    this.space();
-  }
-
-  if (node.accessibility) {
-    this.word(node.accessibility);
-    this.space();
-  }
-
-  if (node.static) {
-    this.word('static');
-    this.space();
-  }
-
-  if (node.override) {
-    this.word('override');
-    this.space();
-  }
-
-  if (node.abstract) {
-    this.word('abstract');
-    this.space();
-  }
-
-  if (isField && node.readonly) {
-    this.word('readonly');
-    this.space();
-  }
-}

node_modules/@babel/generator/lib/index.js

@@ -1,107 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.CodeGenerator = void 0;
-exports.default = generate;
-
-var _sourceMap = require('./source-map');
-
-var _printer = require('./printer');
-
-class Generator extends _printer.default {
-  constructor(ast, opts = {}, code) {
-    const format = normalizeOptions(code, opts);
-    const map = opts.sourceMaps ? new _sourceMap.default(opts, code) : null;
-    super(format, map);
-    this.ast = void 0;
-    this.ast = ast;
-  }
-
-  generate() {
-    return super.generate(this.ast);
-  }
-}
-
-function normalizeOptions(code, opts) {
-  const format = {
-    auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
-    auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
-    shouldPrintComment: opts.shouldPrintComment,
-    retainLines: opts.retainLines,
-    retainFunctionParens: opts.retainFunctionParens,
-    comments: opts.comments == null || opts.comments,
-    compact: opts.compact,
-    minified: opts.minified,
-    concise: opts.concise,
-    indent: {
-      adjustMultilineComment: true,
-      style: '  ',
-      base: 0,
-    },
-    decoratorsBeforeExport: !!opts.decoratorsBeforeExport,
-    jsescOption: Object.assign(
-      {
-        quotes: 'double',
-        wrap: true,
-        minimal: false,
-      },
-      opts.jsescOption
-    ),
-    recordAndTupleSyntaxType: opts.recordAndTupleSyntaxType,
-    topicToken: opts.topicToken,
-  };
-  {
-    format.jsonCompatibleStrings = opts.jsonCompatibleStrings;
-  }
-
-  if (format.minified) {
-    format.compact = true;
-
-    format.shouldPrintComment =
-      format.shouldPrintComment || (() => format.comments);
-  } else {
-    format.shouldPrintComment =
-      format.shouldPrintComment ||
-      ((value) =>
-        format.comments ||
-        value.indexOf('@license') >= 0 ||
-        value.indexOf('@preserve') >= 0);
-  }
-
-  if (format.compact === 'auto') {
-    format.compact = code.length > 500000;
-
-    if (format.compact) {
-      console.error(
-        '[BABEL] Note: The code generator has deoptimised the styling of ' +
-          `${opts.filename} as it exceeds the max of ${'500KB'}.`
-      );
-    }
-  }
-
-  if (format.compact) {
-    format.indent.adjustMultilineComment = false;
-  }
-
-  return format;
-}
-
-class CodeGenerator {
-  constructor(ast, opts, code) {
-    this._generator = void 0;
-    this._generator = new Generator(ast, opts, code);
-  }
-
-  generate() {
-    return this._generator.generate();
-  }
-}
-
-exports.CodeGenerator = CodeGenerator;
-
-function generate(ast, opts, code) {
-  const gen = new Generator(ast, opts, code);
-  return gen.generate();
-}

node_modules/@babel/generator/lib/node/index.js

@@ -1,114 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.needsParens = needsParens;
-exports.needsWhitespace = needsWhitespace;
-exports.needsWhitespaceAfter = needsWhitespaceAfter;
-exports.needsWhitespaceBefore = needsWhitespaceBefore;
-
-var whitespace = require('./whitespace');
-
-var parens = require('./parentheses');
-
-var _t = require('@babel/types');
-
-const {
-  FLIPPED_ALIAS_KEYS,
-  isCallExpression,
-  isExpressionStatement,
-  isMemberExpression,
-  isNewExpression,
-} = _t;
-
-function expandAliases(obj) {
-  const newObj = {};
-
-  function add(type, func) {
-    const fn = newObj[type];
-    newObj[type] =
-      fn ?
-        function (node, parent, stack) {
-          const result = fn(node, parent, stack);
-          return result == null ? func(node, parent, stack) : result;
-        }
-      : func;
-  }
-
-  for (const type of Object.keys(obj)) {
-    const aliases = FLIPPED_ALIAS_KEYS[type];
-
-    if (aliases) {
-      for (const alias of aliases) {
-        add(alias, obj[type]);
-      }
-    } else {
-      add(type, obj[type]);
-    }
-  }
-
-  return newObj;
-}
-
-const expandedParens = expandAliases(parens);
-const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
-const expandedWhitespaceList = expandAliases(whitespace.list);
-
-function find(obj, node, parent, printStack) {
-  const fn = obj[node.type];
-  return fn ? fn(node, parent, printStack) : null;
-}
-
-function isOrHasCallExpression(node) {
-  if (isCallExpression(node)) {
-    return true;
-  }
-
-  return isMemberExpression(node) && isOrHasCallExpression(node.object);
-}
-
-function needsWhitespace(node, parent, type) {
-  if (!node) return 0;
-
-  if (isExpressionStatement(node)) {
-    node = node.expression;
-  }
-
-  let linesInfo = find(expandedWhitespaceNodes, node, parent);
-
-  if (!linesInfo) {
-    const items = find(expandedWhitespaceList, node, parent);
-
-    if (items) {
-      for (let i = 0; i < items.length; i++) {
-        linesInfo = needsWhitespace(items[i], node, type);
-        if (linesInfo) break;
-      }
-    }
-  }
-
-  if (typeof linesInfo === 'object' && linesInfo !== null) {
-    return linesInfo[type] || 0;
-  }
-
-  return 0;
-}
-
-function needsWhitespaceBefore(node, parent) {
-  return needsWhitespace(node, parent, 'before');
-}
-
-function needsWhitespaceAfter(node, parent) {
-  return needsWhitespace(node, parent, 'after');
-}
-
-function needsParens(node, parent, printStack) {
-  if (!parent) return false;
-
-  if (isNewExpression(parent) && parent.callee === node) {
-    if (isOrHasCallExpression(node)) return true;
-  }
-
-  return find(expandedParens, node, parent, printStack);
-}

node_modules/@babel/generator/lib/node/parentheses.js

@@ -1,473 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.ArrowFunctionExpression = ArrowFunctionExpression;
-exports.AssignmentExpression = AssignmentExpression;
-exports.Binary = Binary;
-exports.BinaryExpression = BinaryExpression;
-exports.ClassExpression = ClassExpression;
-exports.ConditionalExpression = ConditionalExpression;
-exports.DoExpression = DoExpression;
-exports.FunctionExpression = FunctionExpression;
-exports.FunctionTypeAnnotation = FunctionTypeAnnotation;
-exports.Identifier = Identifier;
-exports.LogicalExpression = LogicalExpression;
-exports.NullableTypeAnnotation = NullableTypeAnnotation;
-exports.ObjectExpression = ObjectExpression;
-exports.OptionalIndexedAccessType = OptionalIndexedAccessType;
-exports.OptionalCallExpression = exports.OptionalMemberExpression =
-  OptionalMemberExpression;
-exports.SequenceExpression = SequenceExpression;
-exports.TSAsExpression = TSAsExpression;
-exports.TSInferType = TSInferType;
-exports.TSInstantiationExpression = TSInstantiationExpression;
-exports.TSTypeAssertion = TSTypeAssertion;
-exports.TSIntersectionType = exports.TSUnionType = TSUnionType;
-exports.UnaryLike = UnaryLike;
-exports.IntersectionTypeAnnotation = exports.UnionTypeAnnotation =
-  UnionTypeAnnotation;
-exports.UpdateExpression = UpdateExpression;
-exports.AwaitExpression = exports.YieldExpression = YieldExpression;
-
-var _t = require('@babel/types');
-
-const {
-  isArrayTypeAnnotation,
-  isArrowFunctionExpression,
-  isAssignmentExpression,
-  isAwaitExpression,
-  isBinary,
-  isBinaryExpression,
-  isUpdateExpression,
-  isCallExpression,
-  isClassDeclaration,
-  isClassExpression,
-  isConditional,
-  isConditionalExpression,
-  isExportDeclaration,
-  isExportDefaultDeclaration,
-  isExpressionStatement,
-  isFor,
-  isForInStatement,
-  isForOfStatement,
-  isForStatement,
-  isFunctionExpression,
-  isIfStatement,
-  isIndexedAccessType,
-  isIntersectionTypeAnnotation,
-  isLogicalExpression,
-  isMemberExpression,
-  isNewExpression,
-  isNullableTypeAnnotation,
-  isObjectPattern,
-  isOptionalCallExpression,
-  isOptionalMemberExpression,
-  isReturnStatement,
-  isSequenceExpression,
-  isSwitchStatement,
-  isTSArrayType,
-  isTSAsExpression,
-  isTSInstantiationExpression,
-  isTSIntersectionType,
-  isTSNonNullExpression,
-  isTSOptionalType,
-  isTSRestType,
-  isTSTypeAssertion,
-  isTSUnionType,
-  isTaggedTemplateExpression,
-  isThrowStatement,
-  isTypeAnnotation,
-  isUnaryLike,
-  isUnionTypeAnnotation,
-  isVariableDeclarator,
-  isWhileStatement,
-  isYieldExpression,
-} = _t;
-const PRECEDENCE = {
-  '||': 0,
-  '??': 0,
-  '&&': 1,
-  '|': 2,
-  '^': 3,
-  '&': 4,
-  '==': 5,
-  '===': 5,
-  '!=': 5,
-  '!==': 5,
-  '<': 6,
-  '>': 6,
-  '<=': 6,
-  '>=': 6,
-  in: 6,
-  instanceof: 6,
-  '>>': 7,
-  '<<': 7,
-  '>>>': 7,
-  '+': 8,
-  '-': 8,
-  '*': 9,
-  '/': 9,
-  '%': 9,
-  '**': 10,
-};
-
-const isClassExtendsClause = (node, parent) =>
-  (isClassDeclaration(parent) || isClassExpression(parent)) &&
-  parent.superClass === node;
-
-const hasPostfixPart = (node, parent) =>
-  ((isMemberExpression(parent) || isOptionalMemberExpression(parent)) &&
-    parent.object === node) ||
-  ((isCallExpression(parent) ||
-    isOptionalCallExpression(parent) ||
-    isNewExpression(parent)) &&
-    parent.callee === node) ||
-  (isTaggedTemplateExpression(parent) && parent.tag === node) ||
-  isTSNonNullExpression(parent);
-
-function NullableTypeAnnotation(node, parent) {
-  return isArrayTypeAnnotation(parent);
-}
-
-function FunctionTypeAnnotation(node, parent, printStack) {
-  return (
-    isUnionTypeAnnotation(parent) ||
-    isIntersectionTypeAnnotation(parent) ||
-    isArrayTypeAnnotation(parent) ||
-    (isTypeAnnotation(parent) &&
-      isArrowFunctionExpression(printStack[printStack.length - 3]))
-  );
-}
-
-function UpdateExpression(node, parent) {
-  return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
-}
-
-function ObjectExpression(node, parent, printStack) {
-  return isFirstInContext(printStack, {
-    expressionStatement: true,
-    arrowBody: true,
-  });
-}
-
-function DoExpression(node, parent, printStack) {
-  return (
-    !node.async &&
-    isFirstInContext(printStack, {
-      expressionStatement: true,
-    })
-  );
-}
-
-function Binary(node, parent) {
-  if (
-    node.operator === '**' &&
-    isBinaryExpression(parent, {
-      operator: '**',
-    })
-  ) {
-    return parent.left === node;
-  }
-
-  if (isClassExtendsClause(node, parent)) {
-    return true;
-  }
-
-  if (
-    hasPostfixPart(node, parent) ||
-    isUnaryLike(parent) ||
-    isAwaitExpression(parent)
-  ) {
-    return true;
-  }
-
-  if (isBinary(parent)) {
-    const parentOp = parent.operator;
-    const parentPos = PRECEDENCE[parentOp];
-    const nodeOp = node.operator;
-    const nodePos = PRECEDENCE[nodeOp];
-
-    if (
-      (parentPos === nodePos &&
-        parent.right === node &&
-        !isLogicalExpression(parent)) ||
-      parentPos > nodePos
-    ) {
-      return true;
-    }
-  }
-}
-
-function UnionTypeAnnotation(node, parent) {
-  return (
-    isArrayTypeAnnotation(parent) ||
-    isNullableTypeAnnotation(parent) ||
-    isIntersectionTypeAnnotation(parent) ||
-    isUnionTypeAnnotation(parent)
-  );
-}
-
-function OptionalIndexedAccessType(node, parent) {
-  return isIndexedAccessType(parent, {
-    objectType: node,
-  });
-}
-
-function TSAsExpression() {
-  return true;
-}
-
-function TSTypeAssertion() {
-  return true;
-}
-
-function TSUnionType(node, parent) {
-  return (
-    isTSArrayType(parent) ||
-    isTSOptionalType(parent) ||
-    isTSIntersectionType(parent) ||
-    isTSUnionType(parent) ||
-    isTSRestType(parent)
-  );
-}
-
-function TSInferType(node, parent) {
-  return isTSArrayType(parent) || isTSOptionalType(parent);
-}
-
-function TSInstantiationExpression(node, parent) {
-  return (
-    (isCallExpression(parent) ||
-      isOptionalCallExpression(parent) ||
-      isNewExpression(parent) ||
-      isTSInstantiationExpression(parent)) &&
-    !!parent.typeParameters
-  );
-}
-
-function BinaryExpression(node, parent) {
-  return (
-    node.operator === 'in' && (isVariableDeclarator(parent) || isFor(parent))
-  );
-}
-
-function SequenceExpression(node, parent) {
-  if (
-    isForStatement(parent) ||
-    isThrowStatement(parent) ||
-    isReturnStatement(parent) ||
-    (isIfStatement(parent) && parent.test === node) ||
-    (isWhileStatement(parent) && parent.test === node) ||
-    (isForInStatement(parent) && parent.right === node) ||
-    (isSwitchStatement(parent) && parent.discriminant === node) ||
-    (isExpressionStatement(parent) && parent.expression === node)
-  ) {
-    return false;
-  }
-
-  return true;
-}
-
-function YieldExpression(node, parent) {
-  return (
-    isBinary(parent) ||
-    isUnaryLike(parent) ||
-    hasPostfixPart(node, parent) ||
-    (isAwaitExpression(parent) && isYieldExpression(node)) ||
-    (isConditionalExpression(parent) && node === parent.test) ||
-    isClassExtendsClause(node, parent)
-  );
-}
-
-function ClassExpression(node, parent, printStack) {
-  return isFirstInContext(printStack, {
-    expressionStatement: true,
-    exportDefault: true,
-  });
-}
-
-function UnaryLike(node, parent) {
-  return (
-    hasPostfixPart(node, parent) ||
-    isBinaryExpression(parent, {
-      operator: '**',
-      left: node,
-    }) ||
-    isClassExtendsClause(node, parent)
-  );
-}
-
-function FunctionExpression(node, parent, printStack) {
-  return isFirstInContext(printStack, {
-    expressionStatement: true,
-    exportDefault: true,
-  });
-}
-
-function ArrowFunctionExpression(node, parent) {
-  return isExportDeclaration(parent) || ConditionalExpression(node, parent);
-}
-
-function ConditionalExpression(node, parent) {
-  if (
-    isUnaryLike(parent) ||
-    isBinary(parent) ||
-    isConditionalExpression(parent, {
-      test: node,
-    }) ||
-    isAwaitExpression(parent) ||
-    isTSTypeAssertion(parent) ||
-    isTSAsExpression(parent)
-  ) {
-    return true;
-  }
-
-  return UnaryLike(node, parent);
-}
-
-function OptionalMemberExpression(node, parent) {
-  return (
-    isCallExpression(parent, {
-      callee: node,
-    }) ||
-    isMemberExpression(parent, {
-      object: node,
-    })
-  );
-}
-
-function AssignmentExpression(node, parent) {
-  if (isObjectPattern(node.left)) {
-    return true;
-  } else {
-    return ConditionalExpression(node, parent);
-  }
-}
-
-function LogicalExpression(node, parent) {
-  switch (node.operator) {
-    case '||':
-      if (!isLogicalExpression(parent)) return false;
-      return parent.operator === '??' || parent.operator === '&&';
-
-    case '&&':
-      return isLogicalExpression(parent, {
-        operator: '??',
-      });
-
-    case '??':
-      return isLogicalExpression(parent) && parent.operator !== '??';
-  }
-}
-
-function Identifier(node, parent, printStack) {
-  var _node$extra;
-
-  if (
-    (_node$extra = node.extra) != null &&
-    _node$extra.parenthesized &&
-    isAssignmentExpression(parent, {
-      left: node,
-    }) &&
-    (isFunctionExpression(parent.right) || isClassExpression(parent.right)) &&
-    parent.right.id == null
-  ) {
-    return true;
-  }
-
-  if (node.name === 'let') {
-    const isFollowedByBracket =
-      isMemberExpression(parent, {
-        object: node,
-        computed: true,
-      }) ||
-      isOptionalMemberExpression(parent, {
-        object: node,
-        computed: true,
-        optional: false,
-      });
-    return isFirstInContext(printStack, {
-      expressionStatement: isFollowedByBracket,
-      forHead: isFollowedByBracket,
-      forInHead: isFollowedByBracket,
-      forOfHead: true,
-    });
-  }
-
-  return (
-    node.name === 'async' && isForOfStatement(parent) && node === parent.left
-  );
-}
-
-function isFirstInContext(
-  printStack,
-  {
-    expressionStatement = false,
-    arrowBody = false,
-    exportDefault = false,
-    forHead = false,
-    forInHead = false,
-    forOfHead = false,
-  }
-) {
-  let i = printStack.length - 1;
-  let node = printStack[i];
-  i--;
-  let parent = printStack[i];
-
-  while (i >= 0) {
-    if (
-      (expressionStatement &&
-        isExpressionStatement(parent, {
-          expression: node,
-        })) ||
-      (exportDefault &&
-        isExportDefaultDeclaration(parent, {
-          declaration: node,
-        })) ||
-      (arrowBody &&
-        isArrowFunctionExpression(parent, {
-          body: node,
-        })) ||
-      (forHead &&
-        isForStatement(parent, {
-          init: node,
-        })) ||
-      (forInHead &&
-        isForInStatement(parent, {
-          left: node,
-        })) ||
-      (forOfHead &&
-        isForOfStatement(parent, {
-          left: node,
-        }))
-    ) {
-      return true;
-    }
-
-    if (
-      (hasPostfixPart(node, parent) && !isNewExpression(parent)) ||
-      (isSequenceExpression(parent) && parent.expressions[0] === node) ||
-      (isUpdateExpression(parent) && !parent.prefix) ||
-      isConditional(parent, {
-        test: node,
-      }) ||
-      isBinary(parent, {
-        left: node,
-      }) ||
-      isAssignmentExpression(parent, {
-        left: node,
-      })
-    ) {
-      node = parent;
-      i--;
-      parent = printStack[i];
-    } else {
-      return false;
-    }
-  }
-
-  return false;
-}

node_modules/@babel/generator/lib/node/whitespace.js

@@ -1,259 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.nodes = exports.list = void 0;
-
-var _t = require('@babel/types');
-
-const {
-  FLIPPED_ALIAS_KEYS,
-  isArrayExpression,
-  isAssignmentExpression,
-  isBinary,
-  isBlockStatement,
-  isCallExpression,
-  isFunction,
-  isIdentifier,
-  isLiteral,
-  isMemberExpression,
-  isObjectExpression,
-  isOptionalCallExpression,
-  isOptionalMemberExpression,
-  isStringLiteral,
-} = _t;
-
-function crawl(node, state = {}) {
-  if (isMemberExpression(node) || isOptionalMemberExpression(node)) {
-    crawl(node.object, state);
-    if (node.computed) crawl(node.property, state);
-  } else if (isBinary(node) || isAssignmentExpression(node)) {
-    crawl(node.left, state);
-    crawl(node.right, state);
-  } else if (isCallExpression(node) || isOptionalCallExpression(node)) {
-    state.hasCall = true;
-    crawl(node.callee, state);
-  } else if (isFunction(node)) {
-    state.hasFunction = true;
-  } else if (isIdentifier(node)) {
-    state.hasHelper = state.hasHelper || isHelper(node.callee);
-  }
-
-  return state;
-}
-
-function isHelper(node) {
-  if (isMemberExpression(node)) {
-    return isHelper(node.object) || isHelper(node.property);
-  } else if (isIdentifier(node)) {
-    return node.name === 'require' || node.name[0] === '_';
-  } else if (isCallExpression(node)) {
-    return isHelper(node.callee);
-  } else if (isBinary(node) || isAssignmentExpression(node)) {
-    return (
-      (isIdentifier(node.left) && isHelper(node.left)) || isHelper(node.right)
-    );
-  } else {
-    return false;
-  }
-}
-
-function isType(node) {
-  return (
-    isLiteral(node) ||
-    isObjectExpression(node) ||
-    isArrayExpression(node) ||
-    isIdentifier(node) ||
-    isMemberExpression(node)
-  );
-}
-
-const nodes = {
-  AssignmentExpression(node) {
-    const state = crawl(node.right);
-
-    if ((state.hasCall && state.hasHelper) || state.hasFunction) {
-      return {
-        before: state.hasFunction,
-        after: true,
-      };
-    }
-  },
-
-  SwitchCase(node, parent) {
-    return {
-      before: !!node.consequent.length || parent.cases[0] === node,
-      after:
-        !node.consequent.length &&
-        parent.cases[parent.cases.length - 1] === node,
-    };
-  },
-
-  LogicalExpression(node) {
-    if (isFunction(node.left) || isFunction(node.right)) {
-      return {
-        after: true,
-      };
-    }
-  },
-
-  Literal(node) {
-    if (isStringLiteral(node) && node.value === 'use strict') {
-      return {
-        after: true,
-      };
-    }
-  },
-
-  CallExpression(node) {
-    if (isFunction(node.callee) || isHelper(node)) {
-      return {
-        before: true,
-        after: true,
-      };
-    }
-  },
-
-  OptionalCallExpression(node) {
-    if (isFunction(node.callee)) {
-      return {
-        before: true,
-        after: true,
-      };
-    }
-  },
-
-  VariableDeclaration(node) {
-    for (let i = 0; i < node.declarations.length; i++) {
-      const declar = node.declarations[i];
-      let enabled = isHelper(declar.id) && !isType(declar.init);
-
-      if (!enabled) {
-        const state = crawl(declar.init);
-        enabled = (isHelper(declar.init) && state.hasCall) || state.hasFunction;
-      }
-
-      if (enabled) {
-        return {
-          before: true,
-          after: true,
-        };
-      }
-    }
-  },
-
-  IfStatement(node) {
-    if (isBlockStatement(node.consequent)) {
-      return {
-        before: true,
-        after: true,
-      };
-    }
-  },
-};
-exports.nodes = nodes;
-
-nodes.ObjectProperty =
-  nodes.ObjectTypeProperty =
-  nodes.ObjectMethod =
-    function (node, parent) {
-      if (parent.properties[0] === node) {
-        return {
-          before: true,
-        };
-      }
-    };
-
-nodes.ObjectTypeCallProperty = function (node, parent) {
-  var _parent$properties;
-
-  if (
-    parent.callProperties[0] === node &&
-    !(
-      (_parent$properties = parent.properties) != null &&
-      _parent$properties.length
-    )
-  ) {
-    return {
-      before: true,
-    };
-  }
-};
-
-nodes.ObjectTypeIndexer = function (node, parent) {
-  var _parent$properties2, _parent$callPropertie;
-
-  if (
-    parent.indexers[0] === node &&
-    !(
-      (_parent$properties2 = parent.properties) != null &&
-      _parent$properties2.length
-    ) &&
-    !(
-      (_parent$callPropertie = parent.callProperties) != null &&
-      _parent$callPropertie.length
-    )
-  ) {
-    return {
-      before: true,
-    };
-  }
-};
-
-nodes.ObjectTypeInternalSlot = function (node, parent) {
-  var _parent$properties3, _parent$callPropertie2, _parent$indexers;
-
-  if (
-    parent.internalSlots[0] === node &&
-    !(
-      (_parent$properties3 = parent.properties) != null &&
-      _parent$properties3.length
-    ) &&
-    !(
-      (_parent$callPropertie2 = parent.callProperties) != null &&
-      _parent$callPropertie2.length
-    ) &&
-    !((_parent$indexers = parent.indexers) != null && _parent$indexers.length)
-  ) {
-    return {
-      before: true,
-    };
-  }
-};
-
-const list = {
-  VariableDeclaration(node) {
-    return node.declarations.map((decl) => decl.init);
-  },
-
-  ArrayExpression(node) {
-    return node.elements;
-  },
-
-  ObjectExpression(node) {
-    return node.properties;
-  },
-};
-exports.list = list;
-[
-  ['Function', true],
-  ['Class', true],
-  ['Loop', true],
-  ['LabeledStatement', true],
-  ['SwitchStatement', true],
-  ['TryStatement', true],
-].forEach(function ([type, amounts]) {
-  if (typeof amounts === 'boolean') {
-    amounts = {
-      after: amounts,
-      before: amounts,
-    };
-  }
-
-  [type].concat(FLIPPED_ALIAS_KEYS[type] || []).forEach(function (type) {
-    nodes[type] = function () {
-      return amounts;
-    };
-  });
-});

node_modules/@babel/generator/lib/printer.js

@@ -1,582 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.default = void 0;
-
-var _buffer = require('./buffer');
-
-var n = require('./node');
-
-var _t = require('@babel/types');
-
-var generatorFunctions = require('./generators');
-
-const { isProgram, isFile, isEmptyStatement } = _t;
-const SCIENTIFIC_NOTATION = /e/i;
-const ZERO_DECIMAL_INTEGER = /\.0+$/;
-const NON_DECIMAL_LITERAL = /^0[box]/;
-const PURE_ANNOTATION_RE = /^\s*[@#]__PURE__\s*$/;
-const { needsParens, needsWhitespaceAfter, needsWhitespaceBefore } = n;
-
-class Printer {
-  constructor(format, map) {
-    this.inForStatementInitCounter = 0;
-    this._printStack = [];
-    this._indent = 0;
-    this._insideAux = false;
-    this._parenPushNewlineState = null;
-    this._noLineTerminator = false;
-    this._printAuxAfterOnNextUserNode = false;
-    this._printedComments = new WeakSet();
-    this._endsWithInteger = false;
-    this._endsWithWord = false;
-    this.format = format;
-    this._buf = new _buffer.default(map);
-  }
-
-  generate(ast) {
-    this.print(ast);
-
-    this._maybeAddAuxComment();
-
-    return this._buf.get();
-  }
-
-  indent() {
-    if (this.format.compact || this.format.concise) return;
-    this._indent++;
-  }
-
-  dedent() {
-    if (this.format.compact || this.format.concise) return;
-    this._indent--;
-  }
-
-  semicolon(force = false) {
-    this._maybeAddAuxComment();
-
-    this._append(';', !force);
-  }
-
-  rightBrace() {
-    if (this.format.minified) {
-      this._buf.removeLastSemicolon();
-    }
-
-    this.token('}');
-  }
-
-  space(force = false) {
-    if (this.format.compact) return;
-
-    if (force) {
-      this._space();
-    } else if (this._buf.hasContent()) {
-      const lastCp = this.getLastChar();
-
-      if (lastCp !== 32 && lastCp !== 10) {
-        this._space();
-      }
-    }
-  }
-
-  word(str) {
-    if (this._endsWithWord || (this.endsWith(47) && str.charCodeAt(0) === 47)) {
-      this._space();
-    }
-
-    this._maybeAddAuxComment();
-
-    this._append(str);
-
-    this._endsWithWord = true;
-  }
-
-  number(str) {
-    this.word(str);
-    this._endsWithInteger =
-      Number.isInteger(+str) &&
-      !NON_DECIMAL_LITERAL.test(str) &&
-      !SCIENTIFIC_NOTATION.test(str) &&
-      !ZERO_DECIMAL_INTEGER.test(str) &&
-      str.charCodeAt(str.length - 1) !== 46;
-  }
-
-  token(str) {
-    const lastChar = this.getLastChar();
-    const strFirst = str.charCodeAt(0);
-
-    if (
-      (str === '--' && lastChar === 33) ||
-      (strFirst === 43 && lastChar === 43) ||
-      (strFirst === 45 && lastChar === 45) ||
-      (strFirst === 46 && this._endsWithInteger)
-    ) {
-      this._space();
-    }
-
-    this._maybeAddAuxComment();
-
-    this._append(str);
-  }
-
-  newline(i = 1) {
-    if (this.format.retainLines || this.format.compact) return;
-
-    if (this.format.concise) {
-      this.space();
-      return;
-    }
-
-    const charBeforeNewline = this.endsWithCharAndNewline();
-    if (charBeforeNewline === 10) return;
-
-    if (charBeforeNewline === 123 || charBeforeNewline === 58) {
-      i--;
-    }
-
-    if (i <= 0) return;
-
-    for (let j = 0; j < i; j++) {
-      this._newline();
-    }
-  }
-
-  endsWith(char) {
-    return this.getLastChar() === char;
-  }
-
-  getLastChar() {
-    return this._buf.getLastChar();
-  }
-
-  endsWithCharAndNewline() {
-    return this._buf.endsWithCharAndNewline();
-  }
-
-  removeTrailingNewline() {
-    this._buf.removeTrailingNewline();
-  }
-
-  exactSource(loc, cb) {
-    this._catchUp('start', loc);
-
-    this._buf.exactSource(loc, cb);
-  }
-
-  source(prop, loc) {
-    this._catchUp(prop, loc);
-
-    this._buf.source(prop, loc);
-  }
-
-  withSource(prop, loc, cb) {
-    this._catchUp(prop, loc);
-
-    this._buf.withSource(prop, loc, cb);
-  }
-
-  _space() {
-    this._append(' ', true);
-  }
-
-  _newline() {
-    this._append('\n', true);
-  }
-
-  _append(str, queue = false) {
-    this._maybeAddParen(str);
-
-    this._maybeIndent(str);
-
-    if (queue) this._buf.queue(str);
-    else this._buf.append(str);
-    this._endsWithWord = false;
-    this._endsWithInteger = false;
-  }
-
-  _maybeIndent(str) {
-    if (this._indent && this.endsWith(10) && str.charCodeAt(0) !== 10) {
-      this._buf.queueIndentation(this._getIndent());
-    }
-  }
-
-  _maybeAddParen(str) {
-    const parenPushNewlineState = this._parenPushNewlineState;
-    if (!parenPushNewlineState) return;
-    let i;
-
-    for (i = 0; i < str.length && str[i] === ' '; i++) continue;
-
-    if (i === str.length) {
-      return;
-    }
-
-    const cha = str[i];
-
-    if (cha !== '\n') {
-      if (cha !== '/' || i + 1 === str.length) {
-        this._parenPushNewlineState = null;
-        return;
-      }
-
-      const chaPost = str[i + 1];
-
-      if (chaPost === '*') {
-        if (PURE_ANNOTATION_RE.test(str.slice(i + 2, str.length - 2))) {
-          return;
-        }
-      } else if (chaPost !== '/') {
-        this._parenPushNewlineState = null;
-        return;
-      }
-    }
-
-    this.token('(');
-    this.indent();
-    parenPushNewlineState.printed = true;
-  }
-
-  _catchUp(prop, loc) {
-    if (!this.format.retainLines) return;
-    const pos = loc ? loc[prop] : null;
-
-    if ((pos == null ? void 0 : pos.line) != null) {
-      const count = pos.line - this._buf.getCurrentLine();
-
-      for (let i = 0; i < count; i++) {
-        this._newline();
-      }
-    }
-  }
-
-  _getIndent() {
-    return this.format.indent.style.repeat(this._indent);
-  }
-
-  startTerminatorless(isLabel = false) {
-    if (isLabel) {
-      this._noLineTerminator = true;
-      return null;
-    } else {
-      return (this._parenPushNewlineState = {
-        printed: false,
-      });
-    }
-  }
-
-  endTerminatorless(state) {
-    this._noLineTerminator = false;
-
-    if (state != null && state.printed) {
-      this.dedent();
-      this.newline();
-      this.token(')');
-    }
-  }
-
-  print(node, parent) {
-    if (!node) return;
-    const oldConcise = this.format.concise;
-
-    if (node._compact) {
-      this.format.concise = true;
-    }
-
-    const printMethod = this[node.type];
-
-    if (!printMethod) {
-      throw new ReferenceError(
-        `unknown node of type ${JSON.stringify(node.type)} with constructor ${JSON.stringify(node == null ? void 0 : node.constructor.name)}`
-      );
-    }
-
-    this._printStack.push(node);
-
-    const oldInAux = this._insideAux;
-    this._insideAux = !node.loc;
-
-    this._maybeAddAuxComment(this._insideAux && !oldInAux);
-
-    let shouldPrintParens = needsParens(node, parent, this._printStack);
-
-    if (
-      this.format.retainFunctionParens &&
-      node.type === 'FunctionExpression' &&
-      node.extra &&
-      node.extra.parenthesized
-    ) {
-      shouldPrintParens = true;
-    }
-
-    if (shouldPrintParens) this.token('(');
-
-    this._printLeadingComments(node);
-
-    const loc = isProgram(node) || isFile(node) ? null : node.loc;
-    this.withSource('start', loc, () => {
-      printMethod.call(this, node, parent);
-    });
-
-    this._printTrailingComments(node);
-
-    if (shouldPrintParens) this.token(')');
-
-    this._printStack.pop();
-
-    this.format.concise = oldConcise;
-    this._insideAux = oldInAux;
-  }
-
-  _maybeAddAuxComment(enteredPositionlessNode) {
-    if (enteredPositionlessNode) this._printAuxBeforeComment();
-    if (!this._insideAux) this._printAuxAfterComment();
-  }
-
-  _printAuxBeforeComment() {
-    if (this._printAuxAfterOnNextUserNode) return;
-    this._printAuxAfterOnNextUserNode = true;
-    const comment = this.format.auxiliaryCommentBefore;
-
-    if (comment) {
-      this._printComment({
-        type: 'CommentBlock',
-        value: comment,
-      });
-    }
-  }
-
-  _printAuxAfterComment() {
-    if (!this._printAuxAfterOnNextUserNode) return;
-    this._printAuxAfterOnNextUserNode = false;
-    const comment = this.format.auxiliaryCommentAfter;
-
-    if (comment) {
-      this._printComment({
-        type: 'CommentBlock',
-        value: comment,
-      });
-    }
-  }
-
-  getPossibleRaw(node) {
-    const extra = node.extra;
-
-    if (
-      extra &&
-      extra.raw != null &&
-      extra.rawValue != null &&
-      node.value === extra.rawValue
-    ) {
-      return extra.raw;
-    }
-  }
-
-  printJoin(nodes, parent, opts = {}) {
-    if (!(nodes != null && nodes.length)) return;
-    if (opts.indent) this.indent();
-    const newlineOpts = {
-      addNewlines: opts.addNewlines,
-    };
-
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      if (!node) continue;
-      if (opts.statement) this._printNewline(true, node, parent, newlineOpts);
-      this.print(node, parent);
-
-      if (opts.iterator) {
-        opts.iterator(node, i);
-      }
-
-      if (opts.separator && i < nodes.length - 1) {
-        opts.separator.call(this);
-      }
-
-      if (opts.statement) this._printNewline(false, node, parent, newlineOpts);
-    }
-
-    if (opts.indent) this.dedent();
-  }
-
-  printAndIndentOnComments(node, parent) {
-    const indent = node.leadingComments && node.leadingComments.length > 0;
-    if (indent) this.indent();
-    this.print(node, parent);
-    if (indent) this.dedent();
-  }
-
-  printBlock(parent) {
-    const node = parent.body;
-
-    if (!isEmptyStatement(node)) {
-      this.space();
-    }
-
-    this.print(node, parent);
-  }
-
-  _printTrailingComments(node) {
-    this._printComments(this._getComments(false, node));
-  }
-
-  _printLeadingComments(node) {
-    this._printComments(this._getComments(true, node), true);
-  }
-
-  printInnerComments(node, indent = true) {
-    var _node$innerComments;
-
-    if (
-      !(
-        (_node$innerComments = node.innerComments) != null &&
-        _node$innerComments.length
-      )
-    )
-      return;
-    if (indent) this.indent();
-
-    this._printComments(node.innerComments);
-
-    if (indent) this.dedent();
-  }
-
-  printSequence(nodes, parent, opts = {}) {
-    opts.statement = true;
-    return this.printJoin(nodes, parent, opts);
-  }
-
-  printList(items, parent, opts = {}) {
-    if (opts.separator == null) {
-      opts.separator = commaSeparator;
-    }
-
-    return this.printJoin(items, parent, opts);
-  }
-
-  _printNewline(leading, node, parent, opts) {
-    if (this.format.retainLines || this.format.compact) return;
-
-    if (this.format.concise) {
-      this.space();
-      return;
-    }
-
-    let lines = 0;
-
-    if (this._buf.hasContent()) {
-      if (!leading) lines++;
-      if (opts.addNewlines) lines += opts.addNewlines(leading, node) || 0;
-      const needs = leading ? needsWhitespaceBefore : needsWhitespaceAfter;
-      if (needs(node, parent)) lines++;
-    }
-
-    this.newline(Math.min(2, lines));
-  }
-
-  _getComments(leading, node) {
-    return (
-      (node && (leading ? node.leadingComments : node.trailingComments)) || []
-    );
-  }
-
-  _printComment(comment, skipNewLines) {
-    if (!this.format.shouldPrintComment(comment.value)) return;
-    if (comment.ignore) return;
-    if (this._printedComments.has(comment)) return;
-
-    this._printedComments.add(comment);
-
-    const isBlockComment = comment.type === 'CommentBlock';
-    const printNewLines =
-      isBlockComment && !skipNewLines && !this._noLineTerminator;
-    if (printNewLines && this._buf.hasContent()) this.newline(1);
-    const lastCharCode = this.getLastChar();
-
-    if (lastCharCode !== 91 && lastCharCode !== 123) {
-      this.space();
-    }
-
-    let val =
-      !isBlockComment && !this._noLineTerminator ?
-        `//${comment.value}\n`
-      : `/*${comment.value}*/`;
-
-    if (isBlockComment && this.format.indent.adjustMultilineComment) {
-      var _comment$loc;
-
-      const offset =
-        (_comment$loc = comment.loc) == null ?
-          void 0
-        : _comment$loc.start.column;
-
-      if (offset) {
-        const newlineRegex = new RegExp('\\n\\s{1,' + offset + '}', 'g');
-        val = val.replace(newlineRegex, '\n');
-      }
-
-      const indentSize = Math.max(
-        this._getIndent().length,
-        this.format.retainLines ? 0 : this._buf.getCurrentColumn()
-      );
-      val = val.replace(/\n(?!$)/g, `\n${' '.repeat(indentSize)}`);
-    }
-
-    if (this.endsWith(47)) this._space();
-    this.withSource('start', comment.loc, () => {
-      this._append(val);
-    });
-    if (printNewLines) this.newline(1);
-  }
-
-  _printComments(comments, inlinePureAnnotation) {
-    if (!(comments != null && comments.length)) return;
-
-    if (
-      inlinePureAnnotation &&
-      comments.length === 1 &&
-      PURE_ANNOTATION_RE.test(comments[0].value)
-    ) {
-      this._printComment(
-        comments[0],
-        this._buf.hasContent() && !this.endsWith(10)
-      );
-    } else {
-      for (const comment of comments) {
-        this._printComment(comment);
-      }
-    }
-  }
-
-  printAssertions(node) {
-    var _node$assertions;
-
-    if (
-      (_node$assertions = node.assertions) != null &&
-      _node$assertions.length
-    ) {
-      this.space();
-      this.word('assert');
-      this.space();
-      this.token('{');
-      this.space();
-      this.printList(node.assertions, node);
-      this.space();
-      this.token('}');
-    }
-  }
-}
-
-Object.assign(Printer.prototype, generatorFunctions);
-{
-  Printer.prototype.Noop = function Noop() {};
-}
-var _default = Printer;
-exports.default = _default;
-
-function commaSeparator() {
-  this.token(',');
-  this.space();
-}

node_modules/@babel/generator/lib/source-map.js

@@ -1,78 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.default = void 0;
-
-var _genMapping = require('@jridgewell/gen-mapping');
-
-class SourceMap {
-  constructor(opts, code) {
-    var _opts$sourceFileName;
-
-    this._map = void 0;
-    this._rawMappings = void 0;
-    this._sourceFileName = void 0;
-    this._lastGenLine = 0;
-    this._lastSourceLine = 0;
-    this._lastSourceColumn = 0;
-    const map = (this._map = new _genMapping.GenMapping({
-      sourceRoot: opts.sourceRoot,
-    }));
-    this._sourceFileName =
-      (_opts$sourceFileName = opts.sourceFileName) == null ?
-        void 0
-      : _opts$sourceFileName.replace(/\\/g, '/');
-    this._rawMappings = undefined;
-
-    if (typeof code === 'string') {
-      (0, _genMapping.setSourceContent)(map, this._sourceFileName, code);
-    } else if (typeof code === 'object') {
-      Object.keys(code).forEach((sourceFileName) => {
-        (0, _genMapping.setSourceContent)(
-          map,
-          sourceFileName.replace(/\\/g, '/'),
-          code[sourceFileName]
-        );
-      });
-    }
-  }
-
-  get() {
-    return (0, _genMapping.toEncodedMap)(this._map);
-  }
-
-  getDecoded() {
-    return (0, _genMapping.toDecodedMap)(this._map);
-  }
-
-  getRawMappings() {
-    return (
-      this._rawMappings ||
-      (this._rawMappings = (0, _genMapping.allMappings)(this._map))
-    );
-  }
-
-  mark(generated, line, column, identifierName, filename) {
-    this._rawMappings = undefined;
-    (0, _genMapping.maybeAddMapping)(this._map, {
-      name: identifierName,
-      generated,
-      source:
-        line == null ? undefined : (
-          (filename == null ? void 0 : filename.replace(/\\/g, '/')) ||
-          this._sourceFileName
-        ),
-      original:
-        line == null ? undefined : (
-          {
-            line: line,
-            column: column,
-          }
-        ),
-    });
-  }
-}
-
-exports.default = SourceMap;

node_modules/@babel/generator/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "@babel/generator",
-  "version": "7.18.2",
-  "description": "Turns an AST into code.",
-  "author": "The Babel Team (https://babel.dev/team)",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/babel/babel.git",
-    "directory": "packages/babel-generator"
-  },
-  "homepage": "https://babel.dev/docs/en/next/babel-generator",
-  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20generator%22+is%3Aopen",
-  "main": "./lib/index.js",
-  "files": [
-    "lib"
-  ],
-  "dependencies": {
-    "@babel/types": "^7.18.2",
-    "@jridgewell/gen-mapping": "^0.3.0",
-    "jsesc": "^2.5.1"
-  },
-  "devDependencies": {
-    "@babel/helper-fixtures": "^7.17.10",
-    "@babel/parser": "^7.18.0",
-    "@jridgewell/trace-mapping": "^0.3.8",
-    "@types/jsesc": "^2.5.0",
-    "charcodes": "^0.2.0"
-  },
-  "engines": {
-    "node": ">=6.9.0"
-  }
-}

node_modules/@babel/helper-string-parser/lib/index.js

@@ -1,362 +0,0 @@
-'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

node_modules/@babel/helper-string-parser/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "@babel/helper-string-parser",
-  "version": "7.25.9",
-  "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"
-}

node_modules/@babel/helper-validator-identifier/lib/identifier.js

@@ -1,126 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.isIdentifierChar = isIdentifierChar;
-exports.isIdentifierName = isIdentifierName;
-exports.isIdentifierStart = isIdentifierStart;
-let nonASCIIidentifierStartChars =
-  '\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7cd\ua7d0\ua7d1\ua7d3\ua7d5-\ua7dc\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc';
-let nonASCIIidentifierChars =
-  '\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65';
-const nonASCIIidentifierStart = new RegExp(
-  '[' + nonASCIIidentifierStartChars + ']'
-);
-const nonASCIIidentifier = new RegExp(
-  '[' + nonASCIIidentifierStartChars + nonASCIIidentifierChars + ']'
-);
-nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
-const astralIdentifierStartCodes = [
-  0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48,
-  31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39,
-  9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310,
-  10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11,
-  22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2,
-  28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56,
-  50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 2, 60, 28, 11, 0, 9,
-  21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30,
-  0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6,
-  2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0,
-  19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21,
-  2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26,
-  38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7,
-  3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200,
-  32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2,
-  31, 15, 0, 328, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195,
-  2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18,
-  78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 129, 74, 6, 0, 67,
-  12, 65, 1, 2, 0, 29, 6135, 9, 1237, 42, 9, 8936, 3, 2, 6, 2, 1, 2, 290, 16, 0,
-  30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2,
-  1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3,
-  2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2,
-  24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322,
-  29, 19, 43, 485, 27, 229, 29, 3, 0, 496, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67,
-  8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2,
-  0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2,
-  6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4153, 7,
-  221, 3, 5761, 15, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 4191,
-];
-const astralIdentifierCodes = [
-  509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574,
-  3, 9, 9, 7, 9, 32, 4, 318, 1, 80, 3, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3,
-  1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13,
-  9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2,
-  10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17,
-  10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9,
-  7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9,
-  120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 343, 9, 54, 7,
-  2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1,
-  2, 4, 9, 9, 330, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465,
-  27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0,
-  12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3,
-  149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16,
-  3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2,
-  9, 726, 6, 110, 6, 6, 9, 4759, 9, 787719, 239,
-];
-function isInAstralSet(code, set) {
-  let pos = 0x10000;
-  for (let i = 0, length = set.length; i < length; i += 2) {
-    pos += set[i];
-    if (pos > code) return false;
-    pos += set[i + 1];
-    if (pos >= code) return true;
-  }
-  return false;
-}
-function isIdentifierStart(code) {
-  if (code < 65) return code === 36;
-  if (code <= 90) return true;
-  if (code < 97) return code === 95;
-  if (code <= 122) return true;
-  if (code <= 0xffff) {
-    return (
-      code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code))
-    );
-  }
-  return isInAstralSet(code, astralIdentifierStartCodes);
-}
-function isIdentifierChar(code) {
-  if (code < 48) return code === 36;
-  if (code < 58) return true;
-  if (code < 65) return false;
-  if (code <= 90) return true;
-  if (code < 97) return code === 95;
-  if (code <= 122) return true;
-  if (code <= 0xffff) {
-    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
-  }
-  return (
-    isInAstralSet(code, astralIdentifierStartCodes) ||
-    isInAstralSet(code, astralIdentifierCodes)
-  );
-}
-function isIdentifierName(name) {
-  let isFirst = true;
-  for (let i = 0; i < name.length; i++) {
-    let cp = name.charCodeAt(i);
-    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
-      const trail = name.charCodeAt(++i);
-      if ((trail & 0xfc00) === 0xdc00) {
-        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
-      }
-    }
-    if (isFirst) {
-      isFirst = false;
-      if (!isIdentifierStart(cp)) {
-        return false;
-      }
-    } else if (!isIdentifierChar(cp)) {
-      return false;
-    }
-  }
-  return !isFirst;
-}
-
-//# sourceMappingURL=identifier.js.map

node_modules/@babel/helper-validator-identifier/lib/index.js

@@ -1,57 +0,0 @@
-'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

node_modules/@babel/helper-validator-identifier/lib/index.js.map

@@ -1 +0,0 @@
-{"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":[]}

node_modules/@babel/helper-validator-identifier/lib/keyword.js

@@ -1,83 +0,0 @@
-'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

node_modules/@babel/helper-validator-identifier/lib/keyword.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["reservedWords","keyword","strict","strictBind","keywords","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword"],"sources":["../src/keyword.ts"],"sourcesContent":["const reservedWords = {\n  keyword: [\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"do\",\n    \"else\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"return\",\n    \"switch\",\n    \"throw\",\n    \"try\",\n    \"var\",\n    \"const\",\n    \"while\",\n    \"with\",\n    \"new\",\n    \"this\",\n    \"super\",\n    \"class\",\n    \"extends\",\n    \"export\",\n    \"import\",\n    \"null\",\n    \"true\",\n    \"false\",\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"void\",\n    \"delete\",\n  ],\n  strict: [\n    \"implements\",\n    \"interface\",\n    \"let\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"static\",\n    \"yield\",\n  ],\n  strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n  return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n  return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n  word: string,\n  inModule: boolean,\n): boolean {\n  return (\n    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n  );\n}\n\nexport function isKeyword(word: string): boolean {\n  return keywords.has(word);\n}\n"],"mappings":";;;;;;;;;;AAAA,MAAMA,aAAa,GAAG;EACpBC,OAAO,EAAE,CACP,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,CACT;EACDC,MAAM,EAAE,CACN,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;EACDC,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW;AAClC,CAAC;AACD,MAAMC,QAAQ,GAAG,IAAIC,GAAG,CAACL,aAAa,CAACC,OAAO,CAAC;AAC/C,MAAMK,sBAAsB,GAAG,IAAID,GAAG,CAACL,aAAa,CAACE,MAAM,CAAC;AAC5D,MAAMK,0BAA0B,GAAG,IAAIF,GAAG,CAACL,aAAa,CAACG,UAAU,CAAC;AAK7D,SAASK,cAAcA,CAACC,IAAY,EAAEC,QAAiB,EAAW;EACvE,OAAQA,QAAQ,IAAID,IAAI,KAAK,OAAO,IAAKA,IAAI,KAAK,MAAM;AAC1D;AAOO,SAASE,oBAAoBA,CAACF,IAAY,EAAEC,QAAiB,EAAW;EAC7E,OAAOF,cAAc,CAACC,IAAI,EAAEC,QAAQ,CAAC,IAAIJ,sBAAsB,CAACM,GAAG,CAACH,IAAI,CAAC;AAC3E;AAMO,SAASI,4BAA4BA,CAACJ,IAAY,EAAW;EAClE,OAAOF,0BAA0B,CAACK,GAAG,CAACH,IAAI,CAAC;AAC7C;AAOO,SAASK,wBAAwBA,CACtCL,IAAY,EACZC,QAAiB,EACR;EACT,OACEC,oBAAoB,CAACF,IAAI,EAAEC,QAAQ,CAAC,IAAIG,4BAA4B,CAACJ,IAAI,CAAC;AAE9E;AAEO,SAASM,SAASA,CAACN,IAAY,EAAW;EAC/C,OAAOL,QAAQ,CAACQ,GAAG,CAACH,IAAI,CAAC;AAC3B","ignoreList":[]}

node_modules/@babel/helper-validator-identifier/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "@babel/helper-validator-identifier",
-  "version": "7.25.9",
-  "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-16.0.0": "^1.0.0",
-    "charcodes": "^0.2.0"
-  },
-  "engines": {
-    "node": ">=6.9.0"
-  },
-  "author": "The Babel Team (https://babel.dev/team)",
-  "type": "commonjs"
-}

node_modules/@babel/parser/bin/babel-parser.js

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-/* eslint no-var: 0 */
-
-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, '  '));
-}

node_modules/@babel/parser/package.json

@@ -1,43 +0,0 @@
-{
-  "name": "@babel/parser",
-  "version": "7.18.4",
-  "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"
-  ],
-  "engines": {
-    "node": ">=6.0.0"
-  },
-  "devDependencies": {
-    "@babel/code-frame": "^7.16.7",
-    "@babel/helper-check-duplicate-nodes": "^7.18.4",
-    "@babel/helper-fixtures": "^7.17.10",
-    "@babel/helper-validator-identifier": "^7.16.7",
-    "charcodes": "^0.2.0"
-  },
-  "bin": "./bin/babel-parser.js"
-}

node_modules/@babel/parser/typings/babel-parser.d.ts

@@ -1,214 +0,0 @@
-// Type definitions for @babel/parser
-// Project: https://github.com/babel/babel/tree/main/packages/babel-parser
-// Definitions by: Troy Gerwien <https://github.com/yortus>
-//                 Marvin Hagemeister <https://github.com/marvinhagemeister>
-//                 Avi Vahl <https://github.com/AviVahl>
-// TypeScript Version: 2.9
-
-/**
- * Parse the provided code as an entire ECMAScript program.
- */
-export function parse(
-  input: string,
-  options?: ParserOptions
-): ParseResult<import('@babel/types').File>;
-
-/**
- * Parse the provided code as a single expression.
- */
-export function parseExpression(
-  input: string,
-  options?: ParserOptions
-): ParseResult<import('@babel/types').Expression>;
-
-export interface ParserOptions {
-  /**
-   * 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;
-
-  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, 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", "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".
-   */
-  sourceType?: 'script' | 'module' | 'unambiguous';
-
-  /**
-   * 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, 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?: ParserPlugin[];
-
-  /**
-   * 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;
-}
-
-export type ParserPlugin =
-  | 'asyncDoExpressions'
-  | 'asyncGenerators'
-  | 'bigInt'
-  | 'classPrivateMethods'
-  | 'classPrivateProperties'
-  | 'classProperties'
-  | 'classStaticBlock' // Enabled by default
-  | 'decimal'
-  | 'decorators'
-  | 'decorators-legacy'
-  | 'decoratorAutoAccessors'
-  | 'destructuringPrivate'
-  | 'doExpressions'
-  | 'dynamicImport'
-  | 'estree'
-  | 'exportDefaultFrom'
-  | 'exportNamespaceFrom' // deprecated
-  | 'flow'
-  | 'flowComments'
-  | 'functionBind'
-  | 'functionSent'
-  | 'importMeta'
-  | 'jsx'
-  | 'logicalAssignment'
-  | 'importAssertions'
-  | 'moduleBlocks'
-  | 'moduleStringNames'
-  | 'nullishCoalescingOperator'
-  | 'numericSeparator'
-  | 'objectRestSpread'
-  | 'optionalCatchBinding'
-  | 'optionalChaining'
-  | 'partialApplication'
-  | 'pipelineOperator'
-  | 'placeholders'
-  | 'privateIn' // Enabled by default
-  | 'regexpUnicodeSets'
-  | 'throwExpressions'
-  | 'topLevelAwait'
-  | 'typescript'
-  | 'v8intrinsic'
-  | ParserPluginWithOptions;
-
-export type ParserPluginWithOptions =
-  | ['decorators', DecoratorsPluginOptions]
-  | ['pipelineOperator', PipelineOperatorPluginOptions]
-  | ['recordAndTuple', RecordAndTuplePluginOptions]
-  | ['flow', FlowPluginOptions]
-  | ['typescript', TypeScriptPluginOptions];
-
-export interface DecoratorsPluginOptions {
-  decoratorsBeforeExport?: boolean;
-}
-
-export interface PipelineOperatorPluginOptions {
-  proposal: 'minimal' | 'fsharp' | 'hack' | 'smart';
-  topicToken?: '%' | '#' | '@@' | '^^' | '^';
-}
-
-export interface RecordAndTuplePluginOptions {
-  syntaxType: 'bar' | 'hash';
-}
-
-export interface FlowPluginOptions {
-  all?: boolean;
-  enums?: boolean;
-}
-
-export interface TypeScriptPluginOptions {
-  dts?: boolean;
-  disallowAmbiguousJSXLike?: boolean;
-}
-
-export const tokTypes: {
-  // todo(flow->ts) real token type
-  [name: string]: any;
-};
-
-export interface ParseError {
-  code: string;
-  reasonCode: string;
-}
-
-type ParseResult<Result> = Result & {
-  errors: ParseError[];
-};

node_modules/@babel/types/lib/asserts/assertNode.js

@@ -1,22 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.default = assertNode;
-
-var _isNode = require('../validators/isNode');
-
-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

node_modules/@babel/types/lib/asserts/assertNode.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["assertNode","node","isNode","type","JSON","stringify","TypeError"],"sources":["../../src/asserts/assertNode.ts"],"sourcesContent":["import isNode from \"../validators/isNode\";\nimport type * as t from \"..\";\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 as any}\"`);\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AAGe,SAASA,UAAT,CAAoBC,IAApB,EAAwD;EACrE,IAAI,CAAC,IAAAC,eAAA,EAAOD,IAAP,CAAL,EAAmB;IAAA;;IACjB,MAAME,IAAI,iBAAGF,IAAH,oBAAGA,IAAI,CAAEE,IAAT,yBAAiBC,IAAI,CAACC,SAAL,CAAeJ,IAAf,CAA3B;IACA,MAAM,IAAIK,SAAJ,CAAe,6BAA4BH,IAAY,GAAvD,CAAN;EACD;AACF"}

node_modules/@babel/types/lib/ast-types/generated/index.js

@@ -1 +0,0 @@
-//# sourceMappingURL=index.js.map

node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js

@@ -1,22 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.default = createFlowUnionType;
-
-var _generated = require('../generated');
-
-var _removeTypeDuplicates = require('../../modifications/flow/removeTypeDuplicates');
-
-function createFlowUnionType(types) {
-  const flattened = (0, _removeTypeDuplicates.default)(types);
-
-  if (flattened.length === 1) {
-    return flattened[0];
-  } else {
-    return (0, _generated.unionTypeAnnotation)(flattened);
-  }
-}
-
-//# sourceMappingURL=createFlowUnionType.js.map

node_modules/@babel/types/lib/builders/flow/createFlowUnionType.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["createFlowUnionType","types","flattened","removeTypeDuplicates","length","unionTypeAnnotation"],"sources":["../../../src/builders/flow/createFlowUnionType.ts"],"sourcesContent":["import { unionTypeAnnotation } from \"../generated\";\nimport removeTypeDuplicates from \"../../modifications/flow/removeTypeDuplicates\";\nimport type * as t from \"../..\";\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] | Array<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;;AACA;;AAOe,SAASA,mBAAT,CACbC,KADa,EAEc;EAC3B,MAAMC,SAAS,GAAG,IAAAC,6BAAA,EAAqBF,KAArB,CAAlB;;EAEA,IAAIC,SAAS,CAACE,MAAV,KAAqB,CAAzB,EAA4B;IAC1B,OAAOF,SAAS,CAAC,CAAD,CAAhB;EACD,CAFD,MAEO;IACL,OAAO,IAAAG,8BAAA,EAAoBH,SAApB,CAAP;EACD;AACF"}

node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js

@@ -1,49 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.default = void 0;
-
-var _generated = require('../generated');
-
-var _default = createTypeAnnotationBasedOnTypeof;
-exports.default = _default;
-
-function createTypeAnnotationBasedOnTypeof(type) {
-  switch (type) {
-    case 'string':
-      return (0, _generated.stringTypeAnnotation)();
-
-    case 'number':
-      return (0, _generated.numberTypeAnnotation)();
-
-    case 'undefined':
-      return (0, _generated.voidTypeAnnotation)();
-
-    case 'boolean':
-      return (0, _generated.booleanTypeAnnotation)();
-
-    case 'function':
-      return (0, _generated.genericTypeAnnotation)(
-        (0, _generated.identifier)('Function')
-      );
-
-    case 'object':
-      return (0, _generated.genericTypeAnnotation)(
-        (0, _generated.identifier)('Object')
-      );
-
-    case 'symbol':
-      return (0, _generated.genericTypeAnnotation)(
-        (0, _generated.identifier)('Symbol')
-      );
-
-    case 'bigint':
-      return (0, _generated.anyTypeAnnotation)();
-  }
-
-  throw new Error('Invalid typeof value: ' + type);
-}
-
-//# sourceMappingURL=createTypeAnnotationBasedOnTypeof.js.map

node_modules/@babel/types/lib/builders/flow/createTypeAnnotationBasedOnTypeof.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["createTypeAnnotationBasedOnTypeof","type","stringTypeAnnotation","numberTypeAnnotation","voidTypeAnnotation","booleanTypeAnnotation","genericTypeAnnotation","identifier","anyTypeAnnotation","Error"],"sources":["../../../src/builders/flow/createTypeAnnotationBasedOnTypeof.ts"],"sourcesContent":["import {\n  anyTypeAnnotation,\n  stringTypeAnnotation,\n  numberTypeAnnotation,\n  voidTypeAnnotation,\n  booleanTypeAnnotation,\n  genericTypeAnnotation,\n  identifier,\n} from \"../generated\";\nimport type * as t from \"../..\";\n\nexport default createTypeAnnotationBasedOnTypeof as {\n  (type: \"string\"): t.StringTypeAnnotation;\n  (type: \"number\"): t.NumberTypeAnnotation;\n  (type: \"undefined\"): t.VoidTypeAnnotation;\n  (type: \"boolean\"): t.BooleanTypeAnnotation;\n  (type: \"function\"): t.GenericTypeAnnotation;\n  (type: \"object\"): t.GenericTypeAnnotation;\n  (type: \"symbol\"): t.GenericTypeAnnotation;\n  (type: \"bigint\"): t.AnyTypeAnnotation;\n};\n\n/**\n * Create a type annotation based on typeof expression.\n */\nfunction createTypeAnnotationBasedOnTypeof(type: string): t.FlowType {\n  switch (type) {\n    case \"string\":\n      return stringTypeAnnotation();\n    case \"number\":\n      return numberTypeAnnotation();\n    case \"undefined\":\n      return voidTypeAnnotation();\n    case \"boolean\":\n      return booleanTypeAnnotation();\n    case \"function\":\n      return genericTypeAnnotation(identifier(\"Function\"));\n    case \"object\":\n      return genericTypeAnnotation(identifier(\"Object\"));\n    case \"symbol\":\n      return genericTypeAnnotation(identifier(\"Symbol\"));\n    case \"bigint\":\n      // todo: use BigInt annotation when Flow supports BigInt\n      // https://github.com/facebook/flow/issues/6639\n      return anyTypeAnnotation();\n  }\n  throw new Error(\"Invalid typeof value: \" + type);\n}\n"],"mappings":";;;;;;;AAAA;;eAWeA,iC;;;AAcf,SAASA,iCAAT,CAA2CC,IAA3C,EAAqE;EACnE,QAAQA,IAAR;IACE,KAAK,QAAL;MACE,OAAO,IAAAC,+BAAA,GAAP;;IACF,KAAK,QAAL;MACE,OAAO,IAAAC,+BAAA,GAAP;;IACF,KAAK,WAAL;MACE,OAAO,IAAAC,6BAAA,GAAP;;IACF,KAAK,SAAL;MACE,OAAO,IAAAC,gCAAA,GAAP;;IACF,KAAK,UAAL;MACE,OAAO,IAAAC,gCAAA,EAAsB,IAAAC,qBAAA,EAAW,UAAX,CAAtB,CAAP;;IACF,KAAK,QAAL;MACE,OAAO,IAAAD,gCAAA,EAAsB,IAAAC,qBAAA,EAAW,QAAX,CAAtB,CAAP;;IACF,KAAK,QAAL;MACE,OAAO,IAAAD,gCAAA,EAAsB,IAAAC,qBAAA,EAAW,QAAX,CAAtB,CAAP;;IACF,KAAK,QAAL;MAGE,OAAO,IAAAC,4BAAA,GAAP;EAlBJ;;EAoBA,MAAM,IAAIC,KAAJ,CAAU,2BAA2BR,IAArC,CAAN;AACD"}