Baoyu Design

#!/usr/bin/env node
// check-design-system.mjs — READ-ONLY validator for a portable design system.
// Usage: node check-design-system.mjs <projectDir> [--verbose]
//
// Reimplements the web product's `check_design_system` tool: it parses the
// design-system folder with ds-core (which writes NOTHING) and prints the
// namespace, components, @dsCard cards (by group), starting points, tokens and
// fonts, followed by any issues to fix. This script imports only ds-core and
// never writes to disk — that is what makes it safe to run as a read-only
// subagent. Run it after edits to confirm an edit registered; fix what it
// reports and run again until clean.

import { buildModel } from './lib/ds-core.mjs';

const args = process.argv.slice(2);
const verbose = args.includes('--verbose') || args.includes('-v') || args.includes('verbose');
const projectDir = args.find((a) => !a.startsWith('-') && a !== 'verbose');

if (!projectDir) {
  process.stderr.write('Usage: node check-design-system.mjs <projectDir> [--verbose]\n');
  process.exit(64);
}

let model;
try {
  model = buildModel(projectDir);
} catch (e) {
  process.stderr.write(`check-design-system: ${(e && e.message) || e}\n`);
  process.exit(1);
}

const {
  namespace, components, cards, startingPoints, tokens, fonts, brandFonts,
  unexposedExports, allSources, issues, globalCssEntry, tokenHist,
} = model;

// --- summary line ---
// Cap the inline inventory: a 9000-component .fig import would otherwise bury
// the verdict in one ~150 KB line. --verbose still prints the full export map.
const COMPONENTS_SHOWN = 40;
const constantExports = components.filter((c) => c.kind === 'constant');
const realComponents = components.filter((c) => c.kind !== 'constant');
const constSeg = constantExports.length
  ? ` (+${constantExports.length} constant export${constantExports.length === 1 ? '' : 's'}: ${constantExports.map((c) => c.name).join(', ')})`
  : '';
const compSeg = realComponents.length
  ? `Components: ${realComponents.length}${constSeg} (${realComponents.slice(0, COMPONENTS_SHOWN).map((c) => c.name).join(', ')}${
      realComponents.length > COMPONENTS_SHOWN ? `, … +${realComponents.length - COMPONENTS_SHOWN} more — full list with --verbose` : ''}).`
  : `Components: (none)${constSeg}.`;

let cardSeg;
if (cards.length) {
  const byGroup = {};
  for (const c of cards) byGroup[c.group] = (byGroup[c.group] || 0) + 1;
  const groups = Object.keys(byGroup).sort().map((g) => `${g}: ${byGroup[g]}`).join(', ');
  cardSeg = `@dsCard cards: ${cards.length} (${groups}).`;
} else {
  cardSeg = '@dsCard cards: 0 (none — tag any .html with <!-- @dsCard group="…" --> on line 1).';
}

const spSeg = startingPoints.length
  ? `Starting points: ${startingPoints.length} (${startingPoints.map((s) => s.name).join(', ')}).`
  : 'Starting points: (none).';

const fontSeg = fonts.length
  ? `Fonts: ${fonts.map((f) => f.family).join(', ')}.`
  : 'Fonts: (none).';

const summary =
  `Namespace: ${namespace} (use \`const { X } = window.${namespace}\` in @dsCard HTML). ` +
  `${compSeg} ${cardSeg} ${spSeg} Tokens: ${tokens.length}. ${fontSeg}`;

const lines = [summary];

if (issues.length) {
  lines.push('');
  lines.push('Issues to fix:');
  lines.push('');
  for (const i of issues) lines.push(`• ${i}`);
} else {
  lines.push('');
  lines.push('No issues — clean. ✅');
}

if (verbose) {
  lines.push('');
  lines.push('Token kinds: ' + Object.keys(tokenHist).sort()
    .map((k) => `${k} ${tokenHist[k]}`).join(', ') + '.');
  if (brandFonts.length) {
    lines.push('Brand fonts (no @font-face — falls back to a system font): ' +
      brandFonts.map((b) => `${b.family} [${b.tokens.join(', ')}]`).join('; ') + '.');
  }
  lines.push('');
  lines.push('Export map (✓ = exposed on window namespace; lowercase names compile but are NOT exposed):');
  for (const s of allSources) {
    if (!s.exports.length) {
      lines.push(`  ${s.path}: (no exports${s.isModule ? '' : ', not a component module'})`);
      continue;
    }
    for (const name of s.exports) {
      const exposed = s.isModule && /^[A-Z]/.test(name);
      lines.push(`  ${exposed ? '✓' : '·'} ${name} — ${s.path}`);
    }
  }
}

process.stdout.write(lines.join('\n') + '\n');

// hard error: nothing to validate without a token entry point
process.exit(globalCssEntry ? 0 : 2);

#!/usr/bin/env node
// compile-design-system.mjs — the WRITE step of the portable design-system
// pipeline. It reimplements the web product's "automated compiler": it reads a
// design-system folder, transpiles every component .jsx/.tsx with the vendored
// @babel/standalone (JSX/TSX → React.createElement, classic runtime), and emits
// the three artifacts the runtime cards load:
//
//   _ds_bundle.js            — one IIFE that defines window.<Namespace>.<Component>
//   _ds_manifest.json        — namespace, components, cards, starting points, tokens, fonts
//   _adherence.oxlintrc.json — lint config (raw hex/px + per-component prop whitelists)
//
// Usage: node compile-design-system.mjs <projectDir>
//
// Only THIS script writes; the parser (ds-core.mjs) and checker
// (check-design-system.mjs) write nothing.

import fs from 'node:fs';
import path from 'node:path';
import crypto from 'node:crypto';
import { createRequire } from 'node:module';
import { buildModel } from './lib/ds-core.mjs';

const require = createRequire(import.meta.url);
const here = path.dirname(new URL(import.meta.url).pathname);

// --- load vendored Babel (UMD → CJS) ------------------------------------------
let Babel;
try {
  Babel = require('./vendor/babel.min.js');
  if (!Babel || typeof Babel.transform !== 'function') {
    throw new Error('vendored Babel did not expose transform()');
  }
} catch (e) {
  process.stderr.write(
    `compile-design-system: could not load agents/vendor/babel.min.js — ${(e && e.message) || e}\n` +
    'Fetch it once with: curl -L https://unpkg.com/@babel/standalone@7.29.0/babel.min.js -o agents/vendor/babel.min.js\n',
  );
  process.exit(1);
}

// --- Babel plugin: strip ESM, keep React/window globals -----------------------
// The reference sources read deps from globals (`const React = window.React`,
// `const { Icon } = window.<NS>`) and use no ESM imports. Authored components
// may instead `import React from 'react'` and import siblings with relative
// paths — we strip react/react-dom imports and rewrite relative imports to
// read from __ds_scope, so both styles bundle.
function makeStripPlugin({ types: t }) {
  return {
    visitor: {
      ExportNamedDeclaration(p) {
        if (p.node.declaration) p.replaceWith(p.node.declaration);
        else p.remove();
      },
      ExportDefaultDeclaration(p) {
        const d = p.node.declaration;
        if (t.isFunctionDeclaration(d) || t.isClassDeclaration(d)) {
          if (d.id) p.replaceWith(d);
          else p.remove();
        } else {
          p.remove();
        }
      },
      ExportAllDeclaration(p) { p.remove(); },
      ImportDeclaration(p) {
        const src = p.node.source.value;
        if (src === 'react' || src === 'react-dom' || src === 'react-dom/client') {
          p.remove();
          return;
        }
        if (src.startsWith('.') || src.startsWith('/')) {
          // relative sibling import → pull the names out of __ds_scope
          const names = [];
          for (const s of p.node.specifiers) {
            if (t.isImportDefaultSpecifier(s) || t.isImportNamespaceSpecifier(s)) {
              names.push(t.objectProperty(t.identifier(s.local.name), t.identifier(s.local.name), false, true));
            } else if (t.isImportSpecifier(s)) {
              const imported = s.imported.name || s.imported.value;
              names.push(t.objectProperty(t.identifier(imported), t.identifier(s.local.name), false, imported === s.local.name));
            }
          }
          if (names.length) {
            p.replaceWith(
              t.variableDeclaration('const', [
                t.variableDeclarator(t.objectPattern(names), t.identifier('__ds_scope')),
              ]),
            );
          } else {
            p.remove();
          }
        }
        // bare external imports (e.g. a CDN lib) are left as-is for the author to resolve
      },
    },
  };
}

function transpile(code, file) {
  const isTsx = /\.tsx$/.test(file);
  const isTs = /\.tsx?$/.test(file);
  const presets = [['react', { runtime: 'classic' }]];
  if (isTs) presets.push(['typescript', { isTSX: isTsx, allExtensions: true }]);
  const out = Babel.transform(code, {
    filename: file,
    presets,
    plugins: [makeStripPlugin],
    sourceType: 'module',
    compact: false,
    comments: true,
    retainLines: false,
  });
  return out.code;
}

// --- bundle assembly ----------------------------------------------------------
function sourceHash(code) {
  return crypto.createHash('sha256').update(code).digest('hex').slice(0, 12);
}

// The strip plugin turns relative imports into EAGER `const { X } = __ds_scope`
// reads at the top of each file's IIFE block, so a dependency's block must run
// before its importers' — alphabetical order breaks whenever a dependency sorts
// after a dependent (e.g. components/Button.jsx importing ./Icon.jsx works, but
// ./Zicon.jsx would be undefined). DFS post-order over the already-alphabetical
// source list keeps output deterministic; files in an import cycle stay in list
// order (any order is wrong for a cycle — the per-block try/catch contains it).
function orderForBundle(allSources, rawByPath) {
  const byPath = new Map(allSources.map((s) => [s.path, s]));
  // single-statement match: [^;'"] can't cross a side-effect import's quote or
  // a statement boundary, while still spanning multi-line specifier lists
  const IMPORT_RE = /import\s+(?:[^;'"]*?\sfrom\s*)?["']([^"']+)["']/g;
  const EXTS = ['', '.jsx', '.tsx', '.js', '.ts', '/index.jsx', '/index.tsx', '/index.js', '/index.ts'];
  const resolveSpec = (importer, spec) => {
    const base = spec.startsWith('/')
      ? path.posix.normalize(spec.slice(1)) // treat /x/y as DS-root-relative
      : path.posix.normalize(path.posix.join(path.posix.dirname(importer), spec));
    for (const ext of EXTS) {
      if (byPath.has(base + ext)) return base + ext;
    }
    return null;
  };
  const deps = new Map();
  for (const s of allSources) {
    const out = [];
    const raw = rawByPath.get(s.path) ?? '';
    IMPORT_RE.lastIndex = 0;
    let m;
    while ((m = IMPORT_RE.exec(raw))) {
      const spec = m[1];
      if (!spec.startsWith('.') && !spec.startsWith('/')) continue;
      const target = resolveSpec(s.path, spec);
      if (target && target !== s.path) out.push(target);
    }
    deps.set(s.path, out);
  }
  const ordered = [];
  const state = new Map(); // 1 = visiting (cycle guard), 2 = emitted
  const visit = (p) => {
    if (state.get(p)) return;
    state.set(p, 1);
    for (const d of deps.get(p) ?? []) visit(d);
    state.set(p, 2);
    ordered.push(byPath.get(p));
  };
  for (const s of allSources) visit(s.path);
  return ordered;
}

function buildBundle(model) {
  const { root, namespace, components, unexposedExports, allSources } = model;
  const sourceHashes = {};
  const blocks = [];
  const exposed = new Set(components.map((c) => c.name));

  // read every source first: hashes stay in allSources (alphabetical) order so
  // the manifest is stable, while blocks emit in dependency order
  const rawByPath = new Map();
  for (const s of allSources) {
    let raw = '';
    try { raw = fs.readFileSync(path.join(root, s.path), 'utf8'); } catch { /* skip */ }
    rawByPath.set(s.path, raw);
    sourceHashes[s.path] = sourceHash(raw);
  }

  for (const s of orderForBundle(allSources, rawByPath)) {
    const raw = rawByPath.get(s.path) ?? '';
    let body;
    try {
      body = transpile(raw, s.path);
    } catch (e) {
      // a file that fails to transpile becomes a runtime error entry, matching
      // the bundle's per-file try/catch contract
      body = `throw new Error(${JSON.stringify('transpile failed: ' + ((e && e.message) || e))});`;
    }
    // a non-module file never writes a .d.ts-backed component's name into
    // __ds_scope — the module implementation must win the namespace slot
    const assignNames = s.isModule ? s.exports : s.exports.filter((n) => !exposed.has(n));
    const assign = assignNames.length
      ? `\nObject.assign(__ds_scope, { ${assignNames.join(', ')} });`
      : '';
    blocks.push(
      `// ${s.path}\n` +
      `try { (() => {\n${body}${assign}\n})(); } catch (e) { ` +
      `__ds_ns.__errors.push({ path: ${JSON.stringify(s.path)}, error: String((e && e.message) || e) }); }`,
    );
  }

  const meta = {
    format: 3,
    namespace,
    components: components.map((c) => ({ name: c.name, sourcePath: c.sourcePath })),
    sourceHashes,
    inlinedExternals: [],
    unexposedExports: unexposedExports.map((u) => ({ name: u.name, sourcePath: u.sourcePath })),
  };

  // .d.ts-backed components first, then PascalCase exports of non-module
  // sources — bundled and exposed, but with no props contract / adherence /
  // starting-point eligibility. A module component always keeps its name.
  const extraExposed = [];
  for (const s of allSources) {
    if (s.isModule) continue;
    for (const name of s.exports) {
      if (/^[A-Z]/.test(name) && !exposed.has(name)) {
        exposed.add(name);
        extraExposed.push(name);
      }
    }
  }
  const tail = components
    .map((c) => `__ds_ns.${c.name} = __ds_scope.${c.name};`)
    .concat(extraExposed.map((n) => `__ds_ns.${n} = __ds_scope.${n};`))
    .join('\n\n');

  return (
    `/* @ds-bundle: ${JSON.stringify(meta)} */\n\n` +
    `(() => {\n\n` +
    `const __ds_ns = (window.${namespace} = window.${namespace} || {});\n\n` +
    `const __ds_scope = {};\n\n` +
    `(__ds_ns.__errors = __ds_ns.__errors || []);\n\n` +
    blocks.join('\n\n') +
    `\n\n` +
    (tail ? tail + '\n\n' : '') +
    `})();\n`
  );
}

// --- manifest -----------------------------------------------------------------
function buildManifest(model) {
  return {
    namespace: model.namespace,
    components: model.components,
    startingPoints: model.startingPoints,
    cards: model.cards,
    globalCssPaths: model.globalCssPaths,
    tokens: model.tokens,
    themes: model.themes,
    fonts: model.fonts,
    brandFonts: model.brandFonts,
    source: model.source,
  };
}

// --- adherence lint config ----------------------------------------------------
// One JSX prop-whitelist per exposed component, from the props contract ds-core
// parses out of the module's .d.ts (`<Name>Props` interface; both quote styles,
// multi-line unions, one alias hop). Enum-typed props additionally get a VALUE
// rule, so a literal like variant="ghost" warns when the union lacks 'ghost'.
// Constant exports (ICON_NAMES) and components whose contract didn't parse get
// no rule — fail open. This is advisory lint config.
const ALWAYS_PROPS = ['key', 'ref', 'className', 'style', 'children'];
const reEsc = (s) => s.replace(/[/\\^$.*+?()[\]{}|]/g, '\\$&');

function buildAdherence(model) {
  // import-restriction groups: each directory that holds source files
  const dirs = [...new Set(model.allSources.map((s) => path.posix.dirname(s.path)))]
    .filter((d) => d && d !== '.')
    .sort()
    .map((d) => `${d}/**`);

  const syntax = [
    {
      selector: 'Literal[value=/#[0-9a-fA-F]{3,8}\\b/]',
      message: 'Raw hex color — use a design-system color token via var().',
    },
    {
      selector: 'Literal[value=/\\b\\d+px\\b/]',
      message: 'Raw px value — use a design-system spacing token via var().',
    },
  ];

  const components = model.components
    .filter((c) => c.kind !== 'constant' && Array.isArray(c.props) && c.props.length)
    .slice()
    .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));

  for (const { name, props } of components) {
    const allowed = [...new Set([...props.map((p) => p.name), ...ALWAYS_PROPS])];
    const allowedRe = `^(?:${allowed.join('|')})$`;
    syntax.push({
      selector: `JSXOpeningElement[name.name='${name}'] > JSXAttribute > JSXIdentifier[name!=/${allowedRe}/]`,
      message: `<${name}> doesn't accept that prop. Declared props: ${props.map((p) => p.name).join(', ')}.`,
    });
    for (const p of props) {
      if (!p.values || !p.values.length) continue;
      const valRe = `^(?:${p.values.map(reEsc).join('|')})$`;
      syntax.push({
        selector: `JSXOpeningElement[name.name='${name}'] > JSXAttribute[name.name='${p.name}'] > Literal[value!=/${valRe}/]`,
        message: `<${name}> ${p.name} must be one of ${p.values.map((v) => `'${v}'`).join(' | ')}.`,
      });
    }
  }

  const tokensSorted = model.tokens.map((t) => t.name).sort();
  const tokenKinds = {};
  for (const t of model.tokens) tokenKinds[t.name] = t.kind;
  const componentsMap = {};
  for (const { name } of components) componentsMap[name] = { replaces: [] };

  return {
    plugins: ['react', 'import'],
    rules: {
      'react/forbid-elements': ['warn', { forbid: [] }],
      'no-restricted-imports': ['warn', {
        patterns: [{
          group: dirs,
          message: "Import design-system components from 'index.js', not component internals.",
        }],
      }],
      'no-restricted-syntax': ['warn', ...syntax],
    },
    overrides: [{ files: ['**/index.js'], rules: { 'no-restricted-imports': 'off' } }],
    'x-omelette': {
      components: componentsMap,
      tokens: tokensSorted,
      tokenKinds,
      fontFamilies: model.fonts.map((f) => f.family),
    },
  };
}

// --- main ---------------------------------------------------------------------
const projectDir = process.argv[2];
if (!projectDir) {
  process.stderr.write('Usage: node compile-design-system.mjs <projectDir>\n');
  process.exit(64);
}

let model;
try {
  model = buildModel(projectDir);
} catch (e) {
  process.stderr.write(`compile-design-system: ${(e && e.message) || e}\n`);
  process.exit(1);
}

const bundle = buildBundle(model);
const manifest = buildManifest(model);
const adherence = buildAdherence(model);

const w = (name, content) => {
  fs.writeFileSync(path.join(model.root, name), content);
  return name;
};

w('_ds_bundle.js', bundle);
w('_ds_manifest.json', JSON.stringify(manifest, null, 2));
w('_adherence.oxlintrc.json', JSON.stringify(adherence, null, 2));

const hist = model.tokenHist;
const histStr = Object.keys(hist).sort().map((k) => `${k} ${hist[k]}`).join(', ');
const constCount = model.components.filter((c) => c.kind === 'constant').length;
const constSeg = constCount ? ` (+${constCount} constant export${constCount === 1 ? '' : 's'})` : '';
process.stdout.write(
  `Compiled ${model.namespace}: ${model.components.length - constCount} components${constSeg}, ` +
  `${model.cards.length} cards, ${model.startingPoints.length} starting points, ` +
  `${model.tokens.length} tokens (${histStr}).\n` +
  'Wrote _ds_bundle.js, _ds_manifest.json, _adherence.oxlintrc.json.\n' +
  (model.unclassified.length
    ? `Note: ${model.unclassified.length} tokens unclassified by value — add /* @kind */ comments.\n`
    : ''),
);

node_modules/
*.log

{
  "name": "gen-pptx",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "gen-pptx",
      "version": "1.0.0",
      "dependencies": {
        "playwright": "^1.49.0",
        "pptxgenjs": "3.12.0"
      },
      "bin": {
        "gen-pptx": "dist/cli.mjs"
      },
      "devDependencies": {
        "@types/node": "^22.10.0",
        "esbuild": "^0.24.0",
        "typescript": "^5.7.0"
      }
    },
    "node_modules/@esbuild/aix-ppc64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.24.2.tgz",
      "integrity": "sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==",
      "cpu": [
        "ppc64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "aix"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/android-arm": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.24.2.tgz",
      "integrity": "sha512-tmwl4hJkCfNHwFB3nBa8z1Uy3ypZpxqxfTQOcHX+xRByyYgunVbZ9MzUUfb0RxaHIMnbHagwAxuTL+tnNM+1/Q==",
      "cpu": [
        "arm"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "android"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/android-arm64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.24.2.tgz",
      "integrity": "sha512-cNLgeqCqV8WxfcTIOeL4OAtSmL8JjcN6m09XIgro1Wi7cF4t/THaWEa7eL5CMoMBdjoHOTh/vwTO/o2TRXIyzg==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "android"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/android-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.24.2.tgz",
      "integrity": "sha512-B6Q0YQDqMx9D7rvIcsXfmJfvUYLoP722bgfBlO5cGvNVb5V/+Y7nhBE3mHV9OpxBf4eAS2S68KZztiPaWq4XYw==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "android"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/darwin-arm64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.24.2.tgz",
      "integrity": "sha512-kj3AnYWc+CekmZnS5IPu9D+HWtUI49hbnyqk0FLEJDbzCIQt7hg7ucF1SQAilhtYpIujfaHr6O0UHlzzSPdOeA==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "darwin"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/darwin-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.24.2.tgz",
      "integrity": "sha512-WeSrmwwHaPkNR5H3yYfowhZcbriGqooyu3zI/3GGpF8AyUdsrrP0X6KumITGA9WOyiJavnGZUwPGvxvwfWPHIA==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "darwin"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/freebsd-arm64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.24.2.tgz",
      "integrity": "sha512-UN8HXjtJ0k/Mj6a9+5u6+2eZ2ERD7Edt1Q9IZiB5UZAIdPnVKDoG7mdTVGhHJIeEml60JteamR3qhsr1r8gXvg==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "freebsd"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/freebsd-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.24.2.tgz",
      "integrity": "sha512-TvW7wE/89PYW+IevEJXZ5sF6gJRDY/14hyIGFXdIucxCsbRmLUcjseQu1SyTko+2idmCw94TgyaEZi9HUSOe3Q==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "freebsd"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-arm": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.24.2.tgz",
      "integrity": "sha512-n0WRM/gWIdU29J57hJyUdIsk0WarGd6To0s+Y+LwvlC55wt+GT/OgkwoXCXvIue1i1sSNWblHEig00GBWiJgfA==",
      "cpu": [
        "arm"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-arm64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.24.2.tgz",
      "integrity": "sha512-7HnAD6074BW43YvvUmE/35Id9/NB7BeX5EoNkK9obndmZBUk8xmJJeU7DwmUeN7tkysslb2eSl6CTrYz6oEMQg==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-ia32": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.24.2.tgz",
      "integrity": "sha512-sfv0tGPQhcZOgTKO3oBE9xpHuUqguHvSo4jl+wjnKwFpapx+vUDcawbwPNuBIAYdRAvIDBfZVvXprIj3HA+Ugw==",
      "cpu": [
        "ia32"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-loong64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.24.2.tgz",
      "integrity": "sha512-CN9AZr8kEndGooS35ntToZLTQLHEjtVB5n7dl8ZcTZMonJ7CCfStrYhrzF97eAecqVbVJ7APOEe18RPI4KLhwQ==",
      "cpu": [
        "loong64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-mips64el": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.24.2.tgz",
      "integrity": "sha512-iMkk7qr/wl3exJATwkISxI7kTcmHKE+BlymIAbHO8xanq/TjHaaVThFF6ipWzPHryoFsesNQJPE/3wFJw4+huw==",
      "cpu": [
        "mips64el"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-ppc64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.24.2.tgz",
      "integrity": "sha512-shsVrgCZ57Vr2L8mm39kO5PPIb+843FStGt7sGGoqiiWYconSxwTiuswC1VJZLCjNiMLAMh34jg4VSEQb+iEbw==",
      "cpu": [
        "ppc64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-riscv64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.24.2.tgz",
      "integrity": "sha512-4eSFWnU9Hhd68fW16GD0TINewo1L6dRrB+oLNNbYyMUAeOD2yCK5KXGK1GH4qD/kT+bTEXjsyTCiJGHPZ3eM9Q==",
      "cpu": [
        "riscv64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-s390x": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.24.2.tgz",
      "integrity": "sha512-S0Bh0A53b0YHL2XEXC20bHLuGMOhFDO6GN4b3YjRLK//Ep3ql3erpNcPlEFed93hsQAjAQDNsvcK+hV90FubSw==",
      "cpu": [
        "s390x"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/linux-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.24.2.tgz",
      "integrity": "sha512-8Qi4nQcCTbLnK9WoMjdC9NiTG6/E38RNICU6sUNqK0QFxCYgoARqVqxdFmWkdonVsvGqWhmm7MO0jyTqLqwj0Q==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "linux"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/netbsd-arm64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.24.2.tgz",
      "integrity": "sha512-wuLK/VztRRpMt9zyHSazyCVdCXlpHkKm34WUyinD2lzK07FAHTq0KQvZZlXikNWkDGoT6x3TD51jKQ7gMVpopw==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "netbsd"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/netbsd-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.24.2.tgz",
      "integrity": "sha512-VefFaQUc4FMmJuAxmIHgUmfNiLXY438XrL4GDNV1Y1H/RW3qow68xTwjZKfj/+Plp9NANmzbH5R40Meudu8mmw==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "netbsd"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/openbsd-arm64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.24.2.tgz",
      "integrity": "sha512-YQbi46SBct6iKnszhSvdluqDmxCJA+Pu280Av9WICNwQmMxV7nLRHZfjQzwbPs3jeWnuAhE9Jy0NrnJ12Oz+0A==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "openbsd"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/openbsd-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.24.2.tgz",
      "integrity": "sha512-+iDS6zpNM6EnJyWv0bMGLWSWeXGN/HTaF/LXHXHwejGsVi+ooqDfMCCTerNFxEkM3wYVcExkeGXNqshc9iMaOA==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "openbsd"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/sunos-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.24.2.tgz",
      "integrity": "sha512-hTdsW27jcktEvpwNHJU4ZwWFGkz2zRJUz8pvddmXPtXDzVKTTINmlmga3ZzwcuMpUvLw7JkLy9QLKyGpD2Yxig==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "sunos"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/win32-arm64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.24.2.tgz",
      "integrity": "sha512-LihEQ2BBKVFLOC9ZItT9iFprsE9tqjDjnbulhHoFxYQtQfai7qfluVODIYxt1PgdoyQkz23+01rzwNwYfutxUQ==",
      "cpu": [
        "arm64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "win32"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/win32-ia32": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.24.2.tgz",
      "integrity": "sha512-q+iGUwfs8tncmFC9pcnD5IvRHAzmbwQ3GPS5/ceCyHdjXubwQWI12MKWSNSMYLJMq23/IUCvJMS76PDqXe1fxA==",
      "cpu": [
        "ia32"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "win32"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@esbuild/win32-x64": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.24.2.tgz",
      "integrity": "sha512-7VTgWzgMGvup6aSqDPLiW5zHaxYJGTO4OokMjIlrCtf+VpEL+cXKtCvg723iguPYI5oaUNdS+/V7OU2gvXVWEg==",
      "cpu": [
        "x64"
      ],
      "dev": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "win32"
      ],
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/@types/node": {
      "version": "22.19.21",
      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.21.tgz",
      "integrity": "sha512-VMeFBSCKQKmm2swI2kW51SFusDqekC6q9trBCvJ/JliDchFSuoYYKN7yVNjPthP1HKZcx3U1gI/wTcEBjEFKTA==",
      "dev": true,
      "license": "MIT",
      "dependencies": {
        "undici-types": "~6.21.0"
      }
    },
    "node_modules/core-util-is": {
      "version": "1.0.3",
      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
      "license": "MIT"
    },
    "node_modules/esbuild": {
      "version": "0.24.2",
      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.24.2.tgz",
      "integrity": "sha512-+9egpBW8I3CD5XPe0n6BfT5fxLzxrlDzqydF3aviG+9ni1lDC/OvMHcxqEFV0+LANZG5R1bFMWfUrjVsdwxJvA==",
      "dev": true,
      "hasInstallScript": true,
      "license": "MIT",
      "bin": {
        "esbuild": "bin/esbuild"
      },
      "engines": {
        "node": ">=18"
      },
      "optionalDependencies": {
        "@esbuild/aix-ppc64": "0.24.2",
        "@esbuild/android-arm": "0.24.2",
        "@esbuild/android-arm64": "0.24.2",
        "@esbuild/android-x64": "0.24.2",
        "@esbuild/darwin-arm64": "0.24.2",
        "@esbuild/darwin-x64": "0.24.2",
        "@esbuild/freebsd-arm64": "0.24.2",
        "@esbuild/freebsd-x64": "0.24.2",
        "@esbuild/linux-arm": "0.24.2",
        "@esbuild/linux-arm64": "0.24.2",
        "@esbuild/linux-ia32": "0.24.2",
        "@esbuild/linux-loong64": "0.24.2",
        "@esbuild/linux-mips64el": "0.24.2",
        "@esbuild/linux-ppc64": "0.24.2",
        "@esbuild/linux-riscv64": "0.24.2",
        "@esbuild/linux-s390x": "0.24.2",
        "@esbuild/linux-x64": "0.24.2",
        "@esbuild/netbsd-arm64": "0.24.2",
        "@esbuild/netbsd-x64": "0.24.2",
        "@esbuild/openbsd-arm64": "0.24.2",
        "@esbuild/openbsd-x64": "0.24.2",
        "@esbuild/sunos-x64": "0.24.2",
        "@esbuild/win32-arm64": "0.24.2",
        "@esbuild/win32-ia32": "0.24.2",
        "@esbuild/win32-x64": "0.24.2"
      }
    },
    "node_modules/fsevents": {
      "version": "2.3.2",
      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
      "hasInstallScript": true,
      "license": "MIT",
      "optional": true,
      "os": [
        "darwin"
      ],
      "engines": {
        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
      }
    },
    "node_modules/https": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/https/-/https-1.0.0.tgz",
      "integrity": "sha512-4EC57ddXrkaF0x83Oj8sM6SLQHAWXw90Skqu2M4AEWENZ3F02dFJE/GARA8igO79tcgYqGrD7ae4f5L3um2lgg==",
      "license": "ISC"
    },
    "node_modules/image-size": {
      "version": "1.2.1",
      "resolved": "https://registry.npmjs.org/image-size/-/image-size-1.2.1.tgz",
      "integrity": "sha512-rH+46sQJ2dlwfjfhCyNx5thzrv+dtmBIhPHk0zgRUukHzZ/kRueTJXoYYsclBaKcSMBWuGbOFXtioLpzTb5euw==",
      "license": "MIT",
      "dependencies": {
        "queue": "6.0.2"
      },
      "bin": {
        "image-size": "bin/image-size.js"
      },
      "engines": {
        "node": ">=16.x"
      }
    },
    "node_modules/immediate": {
      "version": "3.0.6",
      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
      "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
      "license": "MIT"
    },
    "node_modules/inherits": {
      "version": "2.0.4",
      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
      "license": "ISC"
    },
    "node_modules/isarray": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
      "license": "MIT"
    },
    "node_modules/jszip": {
      "version": "3.10.1",
      "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
      "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==",
      "license": "(MIT OR GPL-3.0-or-later)",
      "dependencies": {
        "lie": "~3.3.0",
        "pako": "~1.0.2",
        "readable-stream": "~2.3.6",
        "setimmediate": "^1.0.5"
      }
    },
    "node_modules/lie": {
      "version": "3.3.0",
      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
      "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
      "license": "MIT",
      "dependencies": {
        "immediate": "~3.0.5"
      }
    },
    "node_modules/pako": {
      "version": "1.0.11",
      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
      "license": "(MIT AND Zlib)"
    },
    "node_modules/playwright": {
      "version": "1.61.0",
      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.61.0.tgz",
      "integrity": "sha512-Z+7BeeqQPRRzklHsVFP4KTGIyMxKUmfeRA4WisM6G3/XW6nwGeX6fX9qYaDa+CiUqpOkb2f6X3nar05R3kSuJQ==",
      "license": "Apache-2.0",
      "dependencies": {
        "playwright-core": "1.61.0"
      },
      "bin": {
        "playwright": "cli.js"
      },
      "engines": {
        "node": ">=18"
      },
      "optionalDependencies": {
        "fsevents": "2.3.2"
      }
    },
    "node_modules/playwright-core": {
      "version": "1.61.0",
      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.61.0.tgz",
      "integrity": "sha512-caX7TrY3Ml6egyDX0WUcTHDxodl/b51y5wJOdCEA36QviK/s2g081hvmGs8eaE3DWb6NYZQ6BjO/QkNRPenoPA==",
      "license": "Apache-2.0",
      "bin": {
        "playwright-core": "cli.js"
      },
      "engines": {
        "node": ">=18"
      }
    },
    "node_modules/pptxgenjs": {
      "version": "3.12.0",
      "resolved": "https://registry.npmjs.org/pptxgenjs/-/pptxgenjs-3.12.0.tgz",
      "integrity": "sha512-ZozkYKWb1MoPR4ucw3/aFYlHkVIJxo9czikEclcUVnS4Iw/M+r+TEwdlB3fyAWO9JY1USxJDt0Y0/r15IR/RUA==",
      "license": "MIT",
      "dependencies": {
        "@types/node": "^18.7.3",
        "https": "^1.0.0",
        "image-size": "^1.0.0",
        "jszip": "^3.7.1"
      }
    },
    "node_modules/pptxgenjs/node_modules/@types/node": {
      "version": "18.19.130",
      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.130.tgz",
      "integrity": "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg==",
      "license": "MIT",
      "dependencies": {
        "undici-types": "~5.26.4"
      }
    },
    "node_modules/pptxgenjs/node_modules/undici-types": {
      "version": "5.26.5",
      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
      "license": "MIT"
    },
    "node_modules/process-nextick-args": {
      "version": "2.0.1",
      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
      "license": "MIT"
    },
    "node_modules/queue": {
      "version": "6.0.2",
      "resolved": "https://registry.npmjs.org/queue/-/queue-6.0.2.tgz",
      "integrity": "sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==",
      "license": "MIT",
      "dependencies": {
        "inherits": "~2.0.3"
      }
    },
    "node_modules/readable-stream": {
      "version": "2.3.8",
      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
      "license": "MIT",
      "dependencies": {
        "core-util-is": "~1.0.0",
        "inherits": "~2.0.3",
        "isarray": "~1.0.0",
        "process-nextick-args": "~2.0.0",
        "safe-buffer": "~5.1.1",
        "string_decoder": "~1.1.1",
        "util-deprecate": "~1.0.1"
      }
    },
    "node_modules/safe-buffer": {
      "version": "5.1.2",
      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
      "license": "MIT"
    },
    "node_modules/setimmediate": {
      "version": "1.0.5",
      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
      "license": "MIT"
    },
    "node_modules/string_decoder": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
      "license": "MIT",
      "dependencies": {
        "safe-buffer": "~5.1.0"
      }
    },
    "node_modules/typescript": {
      "version": "5.9.3",
      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
      "dev": true,
      "license": "Apache-2.0",
      "bin": {
        "tsc": "bin/tsc",
        "tsserver": "bin/tsserver"
      },
      "engines": {
        "node": ">=14.17"
      }
    },
    "node_modules/undici-types": {
      "version": "6.21.0",
      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
      "dev": true,
      "license": "MIT"
    },
    "node_modules/util-deprecate": {
      "version": "1.0.2",
      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
      "license": "MIT"
    }
  }
}

{
  "name": "gen-pptx",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "description": "Export an HTML slide deck to PPTX (editable native objects or full-bleed screenshots) via a headless browser + PptxGenJS. Clean-TypeScript port of the claude.ai design gen_pptx tool.",
  "bin": {
    "gen-pptx": "dist/cli.mjs"
  },
  "scripts": {
    "build:cli": "esbuild src/cli.ts --bundle --platform=node --target=node18 --format=esm --outfile=dist/cli.mjs --external:playwright --external:pptxgenjs --banner:js=\"#!/usr/bin/env node\"",
    "build:page": "esbuild src/browser/entry.ts --bundle --platform=browser --target=es2020 --format=iife --outfile=dist/capture.iife.js",
    "build": "npm run build:cli && npm run build:page",
    "typecheck": "tsc --noEmit",
    "test": "node --test"
  },
  "dependencies": {
    "playwright": "^1.49.0",
    "pptxgenjs": "3.12.0"
  },
  "devDependencies": {
    "@types/node": "^22.10.0",
    "esbuild": "^0.24.0",
    "typescript": "^5.7.0"
  }
}

// Browser-context only. Reveals slide N, settles layout, waits for images, then
// walks the live DOM into a JSON tree the Node renderer consumes. (←_t)

import type { FontSwap, Rect, SlideNode, SlideSpec, StyleMap } from "../types.ts";
import {
  STYLE_KEYS,
  COLOR_KEYS,
  makeColorNormalizer,
  makeFontResolver,
} from "./dom-style.ts";

export interface EditableCapture {
  slide: { rect: Rect; root: SlideNode };
  hash: number;
  imagesWaited: number;
  imagesFailed: number;
}

const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
const settleFrame = (): Promise<void> =>
  Promise.race([
    new Promise<void>((r) => requestAnimationFrame(() => requestAnimationFrame(() => r()))),
    sleep(500),
  ]);

export async function captureEditable(
  spec: SlideSpec,
  fontSwaps: FontSwap[],
): Promise<EditableCapture> {
  if (spec.showJs) {
    try {
      new Function(spec.showJs)();
    } catch (e) {
      throw new Error("showJs threw: " + ((e as Error)?.message || e));
    }
  }
  await settleFrame();
  const delay = Number.isFinite(Number(spec.delay)) ? Number(spec.delay ?? 600) : 600;
  await sleep(delay);

  const rootEl = document.querySelector(spec.selector);
  if (!rootEl) throw new Error("selector " + JSON.stringify(spec.selector) + " matched nothing");

  // Image decode wait — shared budget that fits inside the eval timeout.
  const imgBudget = Math.max(1000, 8500 - delay);
  let waited = 0;
  let settled = 0;
  let failed = 0;
  const pending: Promise<void>[] = [];
  const queue = (img: HTMLImageElement): void => {
    waited++;
    pending.push(
      img.decode().then(
        () => {
          settled++;
        },
        () => {
          settled++;
          failed++;
        },
      ),
    );
  };
  for (const img of Array.from(rootEl.querySelectorAll("img"))) {
    if (img.complete && img.naturalWidth > 0) continue;
    queue(img);
  }
  for (const host of Array.from(rootEl.querySelectorAll("*"))) {
    if (!host.shadowRoot || host.firstElementChild || host.shadowRoot.querySelector("slot")) continue;
    for (const hImg of Array.from(host.shadowRoot.querySelectorAll("img"))) {
      if (!(hImg.currentSrc || hImg.src)) continue;
      const cs = getComputedStyle(hImg);
      if (cs.display === "none" || cs.visibility === "hidden" || cs.visibility === "collapse") continue;
      const rect = hImg.getBoundingClientRect();
      if (rect.width === 0 || rect.height === 0) continue;
      if (hImg.complete && hImg.naturalWidth > 0) continue;
      queue(hImg);
    }
  }
  if (pending.length) {
    await Promise.race([Promise.all(pending), sleep(imgBudget)]);
    failed += pending.length - settled;
  }

  const { normColor, isTransparentColor } = makeColorNormalizer();
  const swapMap: Record<string, string> = {};
  for (const s of fontSwaps) swapMap[s.from.toLowerCase()] = s.to;
  const resolveFontFace = makeFontResolver(swapMap);

  // djb2 — fast, non-crypto; just "did slide N === slide N+1".
  let h = 5381;
  const hashStr = (s: string): void => {
    for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) | 0;
  };
  const rectOf = (el: Element): Rect => {
    const r = el.getBoundingClientRect();
    return { x: r.x, y: r.y, w: r.width, h: r.height };
  };

  const readStyle = (cs: CSSStyleDeclaration): StyleMap => {
    const style: StyleMap = {};
    const csm = cs as unknown as Record<string, string>;
    for (const k of STYLE_KEYS) {
      let v = csm[k];
      if (COLOR_KEYS.indexOf(k) >= 0) v = normColor(v) ?? v;
      if (k === "fontFamily" && v) v = resolveFontFace(v);
      style[k] = v;
    }
    return style;
  };

  const walk = (el: Element): SlideNode | null => {
    const cs = getComputedStyle(el);
    if (cs.display === "none") return null;

    const r = rectOf(el);
    const kids = el.children;
    if (r.w === 0 && r.h === 0 && kids.length === 0) return null;

    const style = readStyle(cs);
    const node: SlideNode = { tag: el.tagName.toLowerCase(), rect: r, style, children: [] };

    hashStr(`${r.x},${r.y},${r.w},${r.h}`);

    if (el.tagName === "A") {
      const a = el as HTMLAnchorElement;
      if (a.href && !(el.getAttribute("href") || "").startsWith("#")) node.href = a.href;
    }

    if (el.tagName === "LI") {
      const lst = cs.listStyleType;
      if (lst && lst !== "none" && lst !== "disc" && lst !== "circle" && lst !== "square") {
        const sibs: Element[] = [];
        for (let s = el.parentElement?.firstElementChild ?? null; s; s = s.nextElementSibling) {
          if (s.tagName === "LI") sibs.push(s);
        }
        node.liIndex = sibs.indexOf(el) + 1;
      }
    }

    // Pre-transform AABB for rotated elements.
    if (cs.transform && cs.transform !== "none") {
      const ow = (el as HTMLElement).offsetWidth;
      const oh = (el as HTMLElement).offsetHeight;
      if (ow != null && oh != null && (ow !== r.w || oh !== r.h)) {
        node.untransformedRect = { x: r.x + r.w / 2 - ow / 2, y: r.y + r.h / 2 - oh / 2, w: ow, h: oh };
      }
    }

    if (el.tagName === "IMG") {
      const img = el as HTMLImageElement;
      node.imageUrl = img.currentSrc || img.src;
    } else if (el.tagName === "OBJECT" && (el as HTMLObjectElement).data) {
      node.imageUrl = (el as HTMLObjectElement).data;
      return node;
    } else if (el.tagName === "CANVAS") {
      try {
        node.imageUrl = (el as HTMLCanvasElement).toDataURL("image/png");
      } catch {
        /* tainted canvas — skip */
      }
    } else if (el.tagName.toLowerCase() === "svg") {
      const clone = el.cloneNode(true) as Element;
      for (const ref of Array.from(clone.querySelectorAll("image"))) {
        const href =
          ref.getAttribute("href") || ref.getAttributeNS("http://www.w3.org/1999/xlink", "href");
        if (href && href.indexOf("data:") !== 0) {
          try {
            ref.setAttribute("href", new URL(href, location.href).href);
            ref.removeAttributeNS("http://www.w3.org/1999/xlink", "href");
          } catch {
            /* leave href as-is */
          }
        }
      }
      node.svg = (clone as Element).outerHTML;
      return node;
    } else {
      // Shadow-hosted image (e.g. <image-slot>): a slotless light-empty host
      // renders only its shadow img, which IS the content.
      if (el.shadowRoot && !el.firstElementChild && !el.shadowRoot.querySelector("slot")) {
        for (const simg of Array.from(el.shadowRoot.querySelectorAll("img"))) {
          const scs = getComputedStyle(simg);
          if (scs.display === "none" || scs.visibility === "hidden" || scs.visibility === "collapse") continue;
          const ssrc = simg.currentSrc || simg.src;
          if (!ssrc) continue;
          const srect = simg.getBoundingClientRect();
          if (srect.width === 0 || srect.height === 0) continue;
          let sop = parseFloat(scs.opacity);
          if (isNaN(sop)) sop = 1;
          for (let anc = simg.parentElement; anc && sop > 0; anc = anc.parentElement) {
            const aop = parseFloat(getComputedStyle(anc).opacity);
            if (!isNaN(aop)) sop *= aop;
          }
          if (sop === 0) continue;
          node.imageUrl = ssrc;

          let sfit = el.getAttribute("fit");
          if (sfit !== "contain" && sfit !== "fill") {
            sfit = scs.objectFit === "contain" ? "contain" : "cover";
          }
          const override: StyleMap = { objectFit: sfit, backgroundSize: "auto", backgroundImage: "none" };

          const sideBorderPaints = (w: string, st: string, col: string): boolean =>
            (parseFloat(w) || 0) > 0 && !!st && st !== "none" && !isTransparentColor(normColor(col));
          const paintsOutsetShadow = (bs: string): boolean => {
            if (!bs || bs === "none") return false;
            for (const part of bs.split(/,(?![^(]*\))/)) {
              if (/\binset\b/.test(part)) continue;
              const shCol = part.match(/rgba?\([^)]*\)/);
              if (shCol && isTransparentColor(shCol[0])) continue;
              return true;
            }
            return false;
          };
          const hostHasBox =
            !isTransparentColor(normColor(cs.backgroundColor)) ||
            paintsOutsetShadow(cs.boxShadow) ||
            sideBorderPaints(cs.borderTopWidth, cs.borderTopStyle, cs.borderTopColor) ||
            sideBorderPaints(cs.borderRightWidth, cs.borderRightStyle, cs.borderRightColor) ||
            sideBorderPaints(cs.borderBottomWidth, cs.borderBottomStyle, cs.borderBottomColor) ||
            sideBorderPaints(cs.borderLeftWidth, cs.borderLeftStyle, cs.borderLeftColor);
          if (!hostHasBox) {
            const sradius = simg.parentElement ? getComputedStyle(simg.parentElement).borderRadius : "";
            if (sradius && sradius !== "0px") override.borderRadius = sradius;
            if (sop < 1) {
              const hop = parseFloat(cs.opacity);
              override.opacity = String((isNaN(hop) ? 1 : hop) * sop);
            } else {
              const fbg = simg.parentElement
                ? normColor(getComputedStyle(simg.parentElement).backgroundColor)
                : "";
              if (fbg && !isTransparentColor(fbg)) override.backgroundColor = fbg;
            }
          }
          node.style = Object.assign({}, node.style, override);
          return node;
        }
      }
      const bg = cs.backgroundImage;
      if (bg && bg !== "none") {
        const m = bg.match(/url\("([^"]*)"\)/);
        if (m && m[1].indexOf("data:") !== 0) {
          try {
            node.imageUrl = new URL(m[1], location.href).href;
          } catch {
            /* leave unset */
          }
        } else if (bg.indexOf("gradient(") >= 0) {
          // Rasterized later so alpha-fading overlays keep their fade. (←gradient)
          node.gradient = bg;
          const minSide = Math.min(r.w, r.h);
          const corner = (cs.borderTopLeftRadius || "").split(" ")[0] || "";
          let rad = 0;
          if (corner.endsWith("%")) rad = (parseFloat(corner) / 100) * minSide;
          else if (corner.endsWith("px")) rad = parseFloat(corner) || 0;
          if (isFinite(rad) && rad > 0) node.gradientRadius = Math.min(rad, minSide / 2);
        }
      }
    }

    // Single childNodes pass keeps text interleaved with element children.
    const ws = cs.whiteSpace;
    const keepWs = ws === "pre" || ws === "pre-wrap" || ws === "pre-line" || ws === "break-spaces";
    const parts: SlideNode[] = [];
    let elKids = 0;
    for (let cn = el.firstChild; cn; cn = cn.nextSibling) {
      if (cn.nodeType === 3) {
        const raw = cn.textContent ?? "";
        const t = keepWs ? raw : raw.trim();
        if (!t) continue;
        const rg = document.createRange();
        if (keepWs) {
          rg.selectNodeContents(cn);
        } else {
          const lead = raw.length - raw.replace(/^\s+/, "").length;
          rg.setStart(cn, lead);
          rg.setEnd(cn, lead + t.length);
        }
        const tr = rg.getBoundingClientRect();
        parts.push({
          tag: "#text",
          rect: { x: tr.x, y: tr.y, w: tr.width, h: tr.height },
          style,
          text: t,
          children: [],
        });
        hashStr(t);
      } else if (cn.nodeType === 1) {
        const kid = walk(cn as Element);
        if (kid) {
          parts.push(kid);
          elKids++;
        }
      }
    }
    if (elKids === 0) {
      const txt = parts.map((p) => p.text).join(keepWs ? "" : " ");
      if (txt) node.text = txt;
    } else {
      node.children = parts;
    }
    return node;
  };

  const rootRect = rectOf(rootEl);
  const rootNode = walk(rootEl);
  if (!rootNode) throw new Error("slide root walked to null (display:none?)");

  // Promote an ancestor's solid background when the slide root is transparent.
  const rootBg = rootNode.style.backgroundColor;
  const rootBgImg = rootNode.style.backgroundImage || "";
  if (
    rootBgImg.indexOf("gradient(") < 0 &&
    (!rootBg || rootBg === "transparent" || /rgba?\([^)]*,\s*0\)$/.test(rootBg))
  ) {
    for (let p = rootEl.parentElement; p; p = p.parentElement) {
      if (p.shadowRoot) continue;
      const pbg = normColor(getComputedStyle(p).backgroundColor);
      if (pbg && pbg !== "transparent" && !/rgba?\([^)]*,\s*0\)$/.test(pbg)) {
        rootNode.style = Object.assign({}, rootNode.style, { backgroundColor: pbg });
        break;
      }
    }
  }

  return {
    slide: { rect: rootRect, root: rootNode },
    hash: h >>> 0,
    imagesWaited: waited,
    imagesFailed: failed,
  };
}