Using The Block Collection And Block Party

#!/usr/bin/env node

/*
 * Copyright 2025 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */

/**
 * Fetch and parse block structure examples from Adobe Block Collection
 *
 * This script retrieves the .plain.html version of a block's documentation page,
 * which contains pre-decoration HTML structure examples showing the expected
 * content model for the block.
 *
 * Usage:
 *   node get-block-structure.js <block-name>
 *   node get-block-structure.js accordion
 *   node get-block-structure.js cards
 *
 * Output: JSON with block metadata, variants, and HTML structure examples
 */

import { JSDOM } from 'jsdom';

const BLOCK_COLLECTION_BASE = 'https://main--aem-block-collection--adobe.aem.live';

/**
 * Simplify HTML by removing optimized picture elements and showing essential structure
 */
function simplifyHTML(html) {
  // Remove picture optimization attributes that clutter the output
  let simplified = html
    .replace(/\s+srcset="[^"]*"/g, '')
    .replace(/\s+type="[^"]*"/g, '')
    .replace(/\s+media="[^"]*"/g, '')
    .replace(/\s+loading="[^"]*"/g, '')
    .replace(/\s+width="[^"]*"/g, '')
    .replace(/\s+height="[^"]*"/g, '')
    .replace(/\?width=[^"'\s]*/g, ''); // Remove image optimization params

  // Replace multi-line picture elements with simplified version
  simplified = simplified.replace(
    /<picture>\s*(<source[^>]*>\s*)*\s*<img\s+([^>]*?)src="([^"]*)"([^>]*?)>\s*<\/picture>/gs,
    (match, sources, beforeSrc, src, afterSrc) => {
      const altMatch = match.match(/alt="([^"]*)"/);
      const alt = altMatch ? ` alt="${altMatch[1]}"` : '';
      return `<picture><img src="${src}"${alt}></picture>`;
    }
  );

  // Compact whitespace but preserve structure
  simplified = simplified
    .replace(/>\s+</g, '>\n<')
    .replace(/\n\s*\n/g, '\n')
    .trim();

  return simplified;
}

/**
 * Analyze HTML structure to provide a human-readable description
 */
function analyzeStructure(html, blockName) {
  const dom = new JSDOM(html);
  const doc = dom.window.document;
  const block = doc.querySelector(`.${blockName}`);

  if (!block) return 'Structure analysis unavailable';

  const rows = Array.from(block.children);
  const analysis = [];

  analysis.push(`Block has ${rows.length} row(s)`);

  rows.forEach((row, i) => {
    const cols = Array.from(row.children);
    const colDescriptions = cols.map(col => {
      const elements = [];
      if (col.querySelector('picture')) elements.push('image');
      if (col.querySelector('h1, h2, h3, h4, h5, h6')) elements.push('heading');
      if (col.querySelector('p')) elements.push('paragraph(s)');
      if (col.querySelector('ul, ol')) elements.push('list');
      if (col.querySelector('a')) elements.push('link(s)');
      return elements.length > 0 ? elements.join(', ') : 'content';
    });

    analysis.push(`  Row ${i + 1}: ${cols.length} column(s) [${colDescriptions.join(' | ')}]`);
  });

  return analysis.join('\n');
}

/**
 * Fetch and parse block structure from Block Collection
 */
async function getBlockStructure(blockName) {
  const url = `${BLOCK_COLLECTION_BASE}/block-collection/${blockName}.plain.html`;

  try {
    const response = await fetch(url);

    if (!response.ok) {
      if (response.status === 404) {
        return {
          success: false,
          error: `Block "${blockName}" not found in Block Collection`,
          url,
          suggestion: 'Use search-block-collection-github.js to find available blocks'
        };
      }
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }

    const html = await response.text();
    const dom = new JSDOM(html);
    const doc = dom.window.document;

    // Find all sections (top-level divs in body)
    const sections = Array.from(doc.body.children);

    const variants = [];
    let description = null;
    let sourceCodeUrl = null;

    // Process each section
    sections.forEach(section => {
      const metadata = section.querySelector('.library-metadata');

      if (metadata) {
        // Extract metadata
        const metadataRows = Array.from(metadata.children);
        const metadataObj = {};

        metadataRows.forEach(row => {
          const cells = Array.from(row.children);
          if (cells.length === 2) {
            const key = cells[0].textContent.trim();
            const value = cells[1].textContent.trim();
            metadataObj[key] = value;

            // Extract source code link if present
            const link = cells[1].querySelector('a[href*="github.com"]');
            if (link) {
              sourceCodeUrl = link.href;
            }
          }
        });

        // Store description (usually in last metadata block)
        if (metadataObj.description) {
          description = metadataObj.description.replace(/\s*Source Code\s*$/, '').trim();
        }

        // Find the block content (div with class matching block name)
        const blockDiv = section.querySelector(`[class*="${blockName}"]`);

        if (blockDiv && metadataObj.name) {
          const blockHTML = blockDiv.outerHTML;
          const simplifiedHTML = simplifyHTML(blockHTML);
          const structure = analyzeStructure(blockHTML, blockName);

          variants.push({
            name: metadataObj.name,
            html: simplifiedHTML,
            structure
          });
        }
      }
    });

    if (variants.length === 0) {
      return {
        success: false,
        error: `No block examples found in ${url}`,
        url
      };
    }

    return {
      success: true,
      blockName,
      url,
      description,
      sourceCodeUrl,
      liveExampleUrl: `${BLOCK_COLLECTION_BASE}/block-collection/${blockName}`,
      variants,
      totalVariants: variants.length,
      usage: {
        purpose: 'Pre-decoration HTML structure examples',
        note: 'This shows the HTML structure BEFORE JavaScript decoration. Use this to understand the expected content model when authoring content or generating HTML.'
      }
    };

  } catch (error) {
    return {
      success: false,
      error: error.message,
      url,
      blockName
    };
  }
}

// CLI execution
async function main() {
  const blockName = process.argv[2];

  if (!blockName) {
    console.error(JSON.stringify({
      success: false,
      error: 'Missing block name argument',
      usage: 'node get-block-structure.js <block-name>',
      examples: [
        'node get-block-structure.js accordion',
        'node get-block-structure.js cards',
        'node get-block-structure.js tabs'
      ]
    }, null, 2));
    process.exit(1);
  }

  const result = await getBlockStructure(blockName);
  console.log(JSON.stringify(result, null, 2));

  if (!result.success) {
    process.exit(1);
  }
}

// Run if called directly
if (import.meta.url === `file://${process.argv[1]}`) {
  main();
}

{
  "type": "module"
}

#!/usr/bin/env node

/**
 * Search the Adobe AEM Block Collection for blocks matching a search term
 * This version uses GitHub API to get actual block folders
 *
 * Usage: node search-block-collection-github.js <search-term>
 *
 * Example: node search-block-collection-github.js accordion
 */

import https from 'https';

// Block Collection constants
const REPO_OWNER = 'adobe';
const REPO_NAME = 'aem-block-collection';
const BLOCKS_PATH = 'blocks';
const REPO_BASE_URL = `https://github.com/${REPO_OWNER}/${REPO_NAME}`;
const SITE_BASE_URL = 'https://main--aem-block-collection--adobe.aem.live';
const API_URL = `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/contents/${BLOCKS_PATH}`;

/**
 * Fetch JSON from a URL using HTTPS
 */
function fetchUrl(url) {
  return new Promise((resolve, reject) => {
    https.get(url, {
      headers: {
        'User-Agent': 'AEM-Block-Search-Script',
        'Accept': 'application/vnd.github.v3+json'
      }
    }, (res) => {
      let data = '';

      res.on('data', (chunk) => {
        data += chunk;
      });

      res.on('end', () => {
        if (res.statusCode === 200) {
          try {
            resolve(JSON.parse(data));
          } catch (e) {
            reject(new Error(`Failed to parse JSON: ${e.message}`));
          }
        } else {
          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
        }
      });
    }).on('error', (err) => {
      reject(err);
    });
  });
}

/**
 * Get all block folders from the GitHub repository
 */
async function getBlocks() {
  try {
    const contents = await fetchUrl(API_URL);

    // Filter for directories only
    return contents
      .filter(item => item.type === 'dir')
      .map(item => ({
        name: item.name,
        displayName: item.name.split('-').map(word =>
          word.charAt(0).toUpperCase() + word.slice(1)
        ).join(' ')
      }));
  } catch (error) {
    throw new Error(`Failed to fetch Block Collection from GitHub: ${error.message}`);
  }
}

/**
 * Determine if a block is "Default Content" (no block code) or a "Sample Block"
 */
function isDefaultContent(blockName) {
  // Default Content items don't have block implementations
  const defaultContentItems = [
    'breadcrumbs', 'buttons', 'code', 'headings', 'icons', 'images',
    'links', 'lists', 'metadata', 'section-metadata', 'sections', 'text'
  ];
  return defaultContentItems.includes(blockName.toLowerCase());
}

/**
 * Search for blocks matching the search term
 */
function searchBlocks(blocks, searchTerm) {
  const lowerSearchTerm = searchTerm.toLowerCase();

  return blocks
    .filter(block => {
      // Search in both the URL slug and display name
      return block.name.toLowerCase().includes(lowerSearchTerm) ||
             block.displayName.toLowerCase().includes(lowerSearchTerm);
    })
    .map(block => {
      const result = {
        name: block.name,
        displayName: block.displayName,
        type: isDefaultContent(block.name) ? 'default-content' : 'block',
        liveExampleUrl: `${SITE_BASE_URL}/block-collection/${block.name}`
      };

      // Only add code URLs for actual blocks (not default content)
      if (result.type === 'block') {
        result.jsUrl = `${REPO_BASE_URL}/blob/main/${BLOCKS_PATH}/${block.name}/${block.name}.js`;
        result.cssUrl = `${REPO_BASE_URL}/blob/main/${BLOCKS_PATH}/${block.name}/${block.name}.css`;
      } else {
        result.note = 'This is default content documentation, not a standalone block. Code may be part of other blocks (e.g., breadcrumbs are in the header block). Visit https://www.aem.live/developer/block-collection and the live example URL for implementation guidance.';
        result.documentationUrl = 'https://www.aem.live/developer/block-collection';
      }

      return result;
    });
}

/**
 * Main function
 */
async function main() {
  const args = process.argv.slice(2);

  if (args.length === 0) {
    console.error('Usage: node search-block-collection-github.js <search-term>');
    console.error('Example: node search-block-collection-github.js accordion');
    process.exit(1);
  }

  const searchTerm = args[0];

  try {
    // Fetch all blocks from GitHub API
    const blocks = await getBlocks();

    // Search for matching blocks
    const results = searchBlocks(blocks, searchTerm);

    // Output results as JSON
    const output = {
      query: searchTerm,
      source: 'Adobe AEM Block Collection (via GitHub API)',
      repository: `${REPO_BASE_URL}`,
      totalItems: blocks.length,
      matchCount: results.length,
      results: results
    };

    console.log(JSON.stringify(output, null, 2));

    // Exit with code 0 if results found, 1 if no results
    process.exit(results.length > 0 ? 0 : 1);

  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
}

// Run the script
main();

#!/usr/bin/env node

/**
 * Search the Adobe AEM Block Collection for blocks matching a search term
 *
 * Usage: node search-block-collection.js <search-term>
 *
 * Example: node search-block-collection.js accordion
 */

import https from 'https';

// Block Collection constants
const REPO_OWNER = 'adobe';
const REPO_NAME = 'aem-block-collection';
const BLOCKS_PATH = 'blocks';
const REPO_BASE_URL = `https://github.com/${REPO_OWNER}/${REPO_NAME}`;
const SITE_BASE_URL = 'https://main--aem-block-collection--adobe.aem.live';
const NAV_URL = `${SITE_BASE_URL}/nav.plain.html`;

/**
 * Fetch HTML/text from a URL using HTTPS
 */
function fetchUrl(url, parseJson = false) {
  return new Promise((resolve, reject) => {
    https.get(url, {
      headers: {
        'User-Agent': 'AEM-Block-Search-Script'
      }
    }, (res) => {
      let data = '';

      res.on('data', (chunk) => {
        data += chunk;
      });

      res.on('end', () => {
        if (res.statusCode === 200) {
          if (parseJson) {
            try {
              resolve(JSON.parse(data));
            } catch (e) {
              reject(new Error(`Failed to parse JSON: ${e.message}`));
            }
          } else {
            resolve(data);
          }
        } else {
          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
        }
      });
    }).on('error', (err) => {
      reject(err);
    });
  });
}

/**
 * Parse nav.plain.html to extract block names
 */
function parseBlocksFromNav(html) {
  const blocks = [];

  // Match all <a href="/block-collection/{block-name}">Display Name</a>
  const linkPattern = /<a href="\/block-collection\/([^"]+)">([^<]+)<\/a>/g;
  let match;

  while ((match = linkPattern.exec(html)) !== null) {
    const urlSlug = match[1];
    const displayName = match[2];

    blocks.push({
      name: urlSlug,
      displayName: displayName
    });
  }

  return blocks;
}

/**
 * Get all blocks from the Block Collection navigation
 */
async function getBlocks() {
  try {
    const html = await fetchUrl(NAV_URL, false);
    return parseBlocksFromNav(html);
  } catch (error) {
    throw new Error(`Failed to fetch Block Collection navigation: ${error.message}`);
  }
}

/**
 * Determine if a block is "Default Content" (no block code) or a "Sample Block"
 */
function isDefaultContent(blockName) {
  // Default Content items don't have block implementations
  const defaultContentItems = [
    'breadcrumbs', 'buttons', 'code', 'headings', 'icons', 'images',
    'links', 'lists', 'metadata', 'section-metadata', 'sections', 'text'
  ];
  return defaultContentItems.includes(blockName.toLowerCase());
}

/**
 * Search for blocks matching the search term
 */
function searchBlocks(blocks, searchTerm) {
  const lowerSearchTerm = searchTerm.toLowerCase();

  return blocks
    .filter(block => {
      // Search in both the URL slug and display name
      return block.name.toLowerCase().includes(lowerSearchTerm) ||
             block.displayName.toLowerCase().includes(lowerSearchTerm);
    })
    .map(block => {
      const result = {
        name: block.name,
        displayName: block.displayName,
        type: isDefaultContent(block.name) ? 'default-content' : 'block',
        liveExampleUrl: `${SITE_BASE_URL}/block-collection/${block.name}`
      };

      // Only add code URLs for actual blocks (not default content)
      if (result.type === 'block') {
        result.jsUrl = `${REPO_BASE_URL}/blob/main/${BLOCKS_PATH}/${block.name}/${block.name}.js`;
        result.cssUrl = `${REPO_BASE_URL}/blob/main/${BLOCKS_PATH}/${block.name}/${block.name}.css`;
      } else {
        result.note = 'This is default content documentation, not a standalone block. Code may be part of other blocks (e.g., breadcrumbs are in the header block). Visit https://www.aem.live/developer/block-collection and the live example URL for implementation guidance.';
        result.documentationUrl = 'https://www.aem.live/developer/block-collection';
      }

      return result;
    });
}

/**
 * Main function
 */
async function main() {
  const args = process.argv.slice(2);

  if (args.length === 0) {
    console.error('Usage: node search-block-collection.js <search-term>');
    console.error('Example: node search-block-collection.js accordion');
    process.exit(1);
  }

  const searchTerm = args[0];

  try {
    // Fetch all blocks from navigation
    const blocks = await getBlocks();

    // Search for matching blocks
    const results = searchBlocks(blocks, searchTerm);

    // Output results as JSON
    const output = {
      query: searchTerm,
      source: 'Adobe AEM Block Collection',
      repository: `${REPO_BASE_URL}`,
      totalItems: blocks.length,
      matchCount: results.length,
      results: results
    };

    console.log(JSON.stringify(output, null, 2));

    // Exit with code 0 if results found, 1 if no results
    process.exit(results.length > 0 ? 0 : 1);

  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
}

// Run the script
main();

#!/usr/bin/env node

/**
 * Search the AEM Block Party index for blocks, plugins, tools, and integrations
 *
 * Note: Only searches approved entries from the Block Party index
 *
 * Usage: node search-block-party.js [--category <category>] <search-term> [additional-terms...]
 *
 * Examples:
 *   node search-block-party.js breadcrumb
 *   node search-block-party.js --category "Build Tooling" sass
 *   node search-block-party.js adobe target integration
 */

import https from 'https';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Block Party constants
const BLOCK_PARTY_INDEX_URL = 'https://www.aem.live/developer/block-party/block-party.json?sheet=curated-list-new';
const CACHE_DIR = path.join(__dirname, '..', '.cache');
const CACHE_FILE = path.join(CACHE_DIR, 'block-party-index.json');
const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours in milliseconds

/**
 * Fetch data from a URL using HTTPS
 */
function fetchUrl(url) {
  return new Promise((resolve, reject) => {
    https.get(url, {
      headers: {
        'User-Agent': 'AEM-Block-Party-Search-Script'
      }
    }, (res) => {
      let data = '';

      res.on('data', (chunk) => {
        data += chunk;
      });

      res.on('end', () => {
        if (res.statusCode === 200) {
          try {
            resolve(JSON.parse(data));
          } catch (e) {
            reject(new Error(`Failed to parse JSON: ${e.message}`));
          }
        } else {
          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
        }
      });
    }).on('error', (err) => {
      reject(err);
    });
  });
}

/**
 * Check if cached index is still valid
 */
function isCacheValid() {
  if (!fs.existsSync(CACHE_FILE)) {
    return false;
  }

  const stats = fs.statSync(CACHE_FILE);
  const age = Date.now() - stats.mtimeMs;

  return age < CACHE_TTL;
}

/**
 * Load index from cache
 */
function loadFromCache() {
  try {
    const data = fs.readFileSync(CACHE_FILE, 'utf8');
    return JSON.parse(data);
  } catch (error) {
    return null;
  }
}

/**
 * Save index to cache
 */
function saveToCache(data) {
  try {
    if (!fs.existsSync(CACHE_DIR)) {
      fs.mkdirSync(CACHE_DIR, { recursive: true });
    }
    fs.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2), 'utf8');
  } catch (error) {
    // Silently fail - caching is not critical
    console.error('Warning: Failed to save cache:', error.message);
  }
}

/**
 * Fetch the Block Party index (with caching)
 */
async function getBlockPartyIndex() {
  // Try cache first
  if (isCacheValid()) {
    const cached = loadFromCache();
    if (cached) {
      return cached;
    }
  }

  // Fetch fresh data
  try {
    const data = await fetchUrl(BLOCK_PARTY_INDEX_URL);
    saveToCache(data);
    return data;
  } catch (error) {
    throw new Error(`Failed to fetch Block Party index: ${error.message}`);
  }
}

/**
 * Get all unique categories from entries (case-insensitive, preserving first occurrence)
 */
function getUniqueCategories(entries) {
  const categoryMap = new Map(); // lowercase -> original case
  entries.forEach(entry => {
    if (entry.category && entry.category.trim()) {
      const trimmed = entry.category.trim();
      const lower = trimmed.toLowerCase();
      if (!categoryMap.has(lower)) {
        categoryMap.set(lower, trimmed);
      }
    }
  });
  return Array.from(categoryMap.values()).sort((a, b) =>
    a.toLowerCase().localeCompare(b.toLowerCase())
  );
}

/**
 * Validate category against available categories
 */
function validateCategory(category, availableCategories) {
  if (!category) {
    return { valid: true };
  }

  const lowerCategory = category.toLowerCase();
  const matchingCategory = availableCategories.find(cat =>
    cat.toLowerCase() === lowerCategory || cat.toLowerCase().includes(lowerCategory)
  );

  if (!matchingCategory) {
    return {
      valid: false,
      error: `Category "${category}" not found.`,
      availableCategories
    };
  }

  return { valid: true };
}

/**
 * Filter entries by category
 */
function filterByCategory(entries, category) {
  if (!category) {
    return entries;
  }

  const lowerCategory = category.toLowerCase();

  return entries.filter(entry => {
    const entryCategory = (entry.category || '').toLowerCase();
    return entryCategory.includes(lowerCategory);
  });
}

/**
 * Search entries by search terms
 */
function searchEntries(entries, searchTerms) {
  if (searchTerms.length === 0) {
    return entries;
  }

  return entries.filter(entry => {
    const searchableText = [
      entry.title || '',
      entry.description || '',
      entry.category || '',
      entry.githubProfile || ''
    ].join(' ').toLowerCase();

    // Match all search terms (AND logic)
    return searchTerms.every(term =>
      searchableText.includes(term.toLowerCase())
    );
  });
}

/**
 * Format results for output
 */
function formatResults(entries) {
  return entries.map(entry => ({
    title: entry.title || 'Untitled',
    category: entry.category || 'Unknown',
    description: entry.description || '',
    githubUrl: entry.githubUrl || '',
    showcaseUrl: entry.showcaseUrl || '',
    githubProfile: entry.githubProfile || ''
  }));
}

/**
 * Parse command line arguments
 */
function parseArgs(args) {
  const result = {
    category: null,
    searchTerms: []
  };

  for (let i = 0; i < args.length; i++) {
    if (args[i] === '--category') {
      if (i + 1 < args.length) {
        result.category = args[i + 1];
        i++; // Skip the next argument
      } else {
        throw new Error('--category flag requires a value');
      }
    } else {
      result.searchTerms.push(args[i]);
    }
  }

  return result;
}

/**
 * Main function
 */
async function main() {
  const args = process.argv.slice(2);

  if (args.length === 0) {
    console.error('Usage: node search-block-party.js [--category <category>] <search-term> [additional-terms...]');
    console.error('');
    console.error('Examples:');
    console.error('  node search-block-party.js breadcrumb');
    console.error('  node search-block-party.js --category "Build Tooling" sass');
    console.error('  node search-block-party.js adobe target integration');
    console.error('');
    console.error('Common categories:');
    console.error('  - Block');
    console.error('  - Sidekick Plugin');
    console.error('  - DA Plugin');
    console.error('  - Code Snippet');
    console.error('  - Build Tooling');
    process.exit(1);
  }

  try {
    // Parse arguments
    const { category, searchTerms } = parseArgs(args);

    // Fetch the index
    const indexData = await getBlockPartyIndex();
    const allEntries = indexData.data || [];

    // Filter to only approved entries
    const approvedEntries = allEntries.filter(entry =>
      entry.approved === 'Yes' || entry.approved === true || entry.approved === 'true'
    );

    // Get available categories (from approved entries only)
    const availableCategories = getUniqueCategories(approvedEntries);

    // Validate category if provided
    const validation = validateCategory(category, availableCategories);
    if (!validation.valid) {
      console.error('Error:', validation.error);
      console.error('');
      console.error('Available categories:');
      validation.availableCategories.forEach(cat => {
        console.error(`  - ${cat}`);
      });
      process.exit(1);
    }

    // Filter by category if specified (using approved entries only)
    let entries = filterByCategory(approvedEntries, category);

    // Search by terms
    entries = searchEntries(entries, searchTerms);

    // Format results
    const results = formatResults(entries);

    // Output results as JSON
    const output = {
      query: searchTerms.join(' '),
      category: category || 'All categories',
      source: 'AEM Block Party (Approved Only)',
      indexUrl: BLOCK_PARTY_INDEX_URL,
      totalEntries: allEntries.length,
      approvedEntries: approvedEntries.length,
      matchCount: results.length,
      results: results
    };

    console.log(JSON.stringify(output, null, 2));

    // Exit with code 0 if results found, 1 if no results
    process.exit(results.length > 0 ? 0 : 1);

  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
}

// Run the script
main();