onbuzz 4.9.1 → 4.9.5

package/src/tools/office/pres/palettes.js

@@ -0,0 +1,179 @@
+/**
+ * pres/palettes — named palettes with six semantic roles.
+ *
+ * Every component (text, shape, chart, divider, background) reads from
+ * the six roles. Swapping a palette restyles the entire deck because
+ * nothing hardcodes a hex.
+ *
+ * Roles:
+ *   bg       — slide background (or base background under decoration)
+ *   surface  — cards, callouts, light blocks placed on top of bg
+ *   text     — primary body text colour
+ *   subtle   — captions, secondary labels, muted dividers
+ *   primary  — brand-leading accent: titles, key data points, CTAs
+ *   accent   — secondary accent: highlights, chart series #2, eyebrows
+ *
+ * Hex strings are stored without the leading "#" because pptxgenjs
+ * accepts both but the no-# form is canonical in PPTX XML.
+ */
+
+export const PALETTES = {
+  // ─── editorial-warm family ─────────────────────────────────────────
+  'cream-charcoal': {
+    family: 'editorial',
+    bg:      'FAF6EE',
+    surface: 'FFFFFF',
+    text:    '1A1A1A',
+    subtle:  '7A7368',
+    primary: 'C04A2D',
+    accent:  'E0B872',
+  },
+  'ink-paper': {
+    family: 'editorial',
+    bg:      'FCFCF7',
+    surface: 'FFFFFF',
+    text:    '0E0E0E',
+    subtle:  '5A5A5A',
+    primary: '1B1B1B',
+    accent:  'B89060',
+  },
+  'mint-charcoal': {
+    family: 'editorial',
+    bg:      'F2F7F4',
+    surface: 'FFFFFF',
+    text:    '1A2620',
+    subtle:  '6A7B73',
+    primary: '2E5E50',
+    accent:  'A8C9B4',
+  },
+
+  // ─── tech-bold family ──────────────────────────────────────────────
+  'electric-night': {
+    family: 'tech',
+    bg:      '0A0E1B',
+    surface: '151B2E',
+    text:    'F5F7FA',
+    subtle:  '8A93A8',
+    primary: '5B8DEF',
+    accent:  'F25F4C',
+  },
+  'cyber-dawn': {
+    family: 'tech',
+    bg:      'FFFFFF',
+    surface: 'F4F6FA',
+    text:    '0A0E1B',
+    subtle:  '6E7488',
+    primary: '4F6DF5',
+    accent:  'F25F4C',
+  },
+  'neon-violet': {
+    family: 'tech',
+    bg:      '0F0A1B',
+    surface: '1A1330',
+    text:    'F5F0FF',
+    subtle:  '8E84B5',
+    primary: 'A87FFF',
+    accent:  'FFD166',
+  },
+
+  // ─── data-heavy family ─────────────────────────────────────────────
+  'bloomberg': {
+    family: 'data',
+    bg:      'FFFFFF',
+    surface: 'F4F4F4',
+    text:    '1A1A1A',
+    subtle:  '6B6B6B',
+    primary: 'FF6600',
+    accent:  '0066CC',
+  },
+  'mono-data': {
+    family: 'data',
+    bg:      'FFFFFF',
+    surface: 'F2F2F2',
+    text:    '1A1A1A',
+    subtle:  '8C8C8C',
+    primary: '111111',
+    accent:  'D62728',
+  },
+  'finch': {
+    family: 'data',
+    bg:      'FAFAF7',
+    surface: 'FFFFFF',
+    text:    '1D1D1F',
+    subtle:  '86868B',
+    primary: '055CA8',
+    accent:  '00A878',
+  },
+};
+
+/**
+ * Curated chart series for each palette — used by the chart wrapper so
+ * multi-series visuals stay on-palette and visually distinguishable.
+ * Five colours is enough for ~90% of business charts; beyond that we
+ * recycle and rely on legend + shape differentiation.
+ */
+export const CHART_SERIES = {
+  'cream-charcoal': ['C04A2D', '7A7368', 'E0B872', '4A8580', '3E2723'],
+  'ink-paper':      ['1B1B1B', '5A5A5A', 'B89060', '7B4A24', 'A5A5A5'],
+  'mint-charcoal':  ['2E5E50', 'A8C9B4', '6A7B73', '8B4513', '1A2620'],
+  'electric-night': ['5B8DEF', 'F25F4C', '6DD3CE', 'FFD166', 'BC83FF'],
+  'cyber-dawn':     ['4F6DF5', 'F25F4C', '14B8A6', 'F59E0B', '7C3AED'],
+  'neon-violet':    ['A87FFF', 'FFD166', 'FF6FA3', '4ECDC4', 'A5D8FF'],
+  'bloomberg':      ['FF6600', '0066CC', 'CC3300', '009933', '6633CC'],
+  'mono-data':      ['111111', '8C8C8C', 'D62728', '2CA02C', 'C5B0D5'],
+  'finch':          ['055CA8', '00A878', 'F4A261', 'E76F51', '264653'],
+};
+
+/**
+ * Default palette per theme family. The theme's id determines which
+ * family it belongs to; the agent can override with `palette: 'x'`.
+ */
+export const DEFAULT_PALETTE_BY_FAMILY = {
+  editorial: 'cream-charcoal',
+  tech:      'electric-night',
+  data:      'bloomberg',
+};
+
+/**
+ * Resolve a palette name → palette object. Falls back to the family
+ * default if the name is unknown. Always returns a valid palette so
+ * downstream code doesn't have to null-check.
+ */
+export function resolvePalette(name, themeFamily = 'editorial') {
+  if (name && PALETTES[name]) return { name, ...PALETTES[name] };
+  const fallback = DEFAULT_PALETTE_BY_FAMILY[themeFamily] || 'cream-charcoal';
+  return { name: fallback, ...PALETTES[fallback] };
+}
+
+/**
+ * Lighten / darken a hex by a percentage (0-100). Used by background
+ * generators to derive secondary stops from a single palette role,
+ * which keeps generated backgrounds anchored to the palette.
+ */
+export function shade(hex, percent) {
+  const h = String(hex).replace(/^#/, '');
+  if (!/^[0-9A-Fa-f]{6}$/.test(h)) return hex;
+  const r = parseInt(h.slice(0, 2), 16);
+  const g = parseInt(h.slice(2, 4), 16);
+  const b = parseInt(h.slice(4, 6), 16);
+  const k = percent / 100;
+  const blend = (c) => Math.round(k < 0 ? c * (1 + k) : c + (255 - c) * k);
+  const toHex = (n) => n.toString(16).padStart(2, '0').toUpperCase();
+  return `${toHex(blend(r))}${toHex(blend(g))}${toHex(blend(b))}`;
+}
+
+/**
+ * Mix two hex colours by `t` (0 → a, 1 → b). Useful for gradient stops
+ * derived from palette roles.
+ */
+export function mix(a, b, t) {
+  const parse = (hex) => {
+    const s = String(hex).replace(/^#/, '');
+    return [parseInt(s.slice(0, 2), 16), parseInt(s.slice(2, 4), 16), parseInt(s.slice(4, 6), 16)];
+  };
+  const [ar, ag, ab] = parse(a);
+  const [br, bg, bb] = parse(b);
+  const lerp = (x, y) => Math.round(x + (y - x) * t);
+  const toHex = (n) => n.toString(16).padStart(2, '0').toUpperCase();
+  return `${toHex(lerp(ar, br))}${toHex(lerp(ag, bg))}${toHex(lerp(ab, bb))}`;
+}

package/src/tools/office/pres/shapes.js

@@ -0,0 +1,83 @@
+/**
+ * pres/shapes — shape tokens.
+ *
+ * One knob ('sharp' | 'soft' | 'round' | 'pill') decides corner radius,
+ * shadow weight, and stroke style for every shape primitive used in
+ * the deck. The agent sets it once at the theme level (or overrides
+ * per slide); archetypes call `resolveShape(shape)` and read tokens.
+ *
+ * pptxgenjs corner-radius units are inches. PPTX shadow units we
+ * package as a plain object that pptxgenjs accepts on shape options.
+ */
+
+const SHAPE_PRESETS = {
+  sharp: {
+    cornerRadius: 0,
+    shadow: null,
+    strokeWeight: 0.5,
+    dividerWeight: 0.5,
+  },
+  soft: {
+    cornerRadius: 0.05,
+    shadow: { type: 'outer', blur: 6, offset: 1, angle: 90, color: '000000', opacity: 0.08 },
+    strokeWeight: 0,
+    dividerWeight: 0.5,
+  },
+  round: {
+    cornerRadius: 0.18,
+    shadow: { type: 'outer', blur: 12, offset: 3, angle: 90, color: '000000', opacity: 0.12 },
+    strokeWeight: 0,
+    dividerWeight: 0,
+  },
+  pill: {
+    // Used for "pill" buttons and tags. The actual corner is rounded
+    // to whichever value pptxgenjs accepts as "fully rounded" — using
+    // half the typical shape height as a safe approximation.
+    cornerRadius: 0.5,
+    shadow: { type: 'outer', blur: 16, offset: 4, angle: 90, color: '000000', opacity: 0.14 },
+    strokeWeight: 0,
+    dividerWeight: 0,
+  },
+};
+
+export function resolveShape(preset = 'soft') {
+  const base = SHAPE_PRESETS[preset] || SHAPE_PRESETS.soft;
+  return { preset, ...base };
+}
+
+/**
+ * Convert a logical shape token into pptxgenjs `addShape` options.
+ * `kind`: 'card' | 'pill' | 'divider' | 'dot'. The caller still
+ * supplies position + fill colour; this fills in the styling.
+ */
+export function shapeOpts(tokens, kind, fillHex, opts = {}) {
+  const out = { fill: { color: fillHex } };
+  if (kind === 'card' || kind === 'pill') {
+    if (tokens.cornerRadius > 0) {
+      out.rectRadius = tokens.cornerRadius;
+    }
+    if (tokens.shadow) {
+      out.shadow = tokens.shadow;
+    }
+    if (tokens.strokeWeight > 0 && opts.stroke) {
+      out.line = { color: opts.stroke, width: tokens.strokeWeight };
+    } else {
+      out.line = { type: 'none' };
+    }
+  } else if (kind === 'divider') {
+    out.line = { color: fillHex, width: opts.width ?? tokens.dividerWeight ?? 0.5 };
+  }
+  return out;
+}
+
+/**
+ * pptxgenjs has two ways to draw a rectangle:
+ *   - `addShape('rect', opts)` — sharp corners
+ *   - `addShape('roundRect', opts)` — corners use opts.rectRadius
+ * `cardShape(tokens)` returns whichever one the current shape token
+ * wants, so archetypes call `slide.addShape(cardShape(tokens), …)`
+ * without branching.
+ */
+export function cardShape(tokens) {
+  return tokens.cornerRadius > 0 ? 'roundRect' : 'rect';
+}

package/src/tools/office/pres/themes/data-heavy.js

@@ -0,0 +1,79 @@
+/**
+ * Theme: data-heavy
+ *
+ * Reference: financial / analytics reporting — Bloomberg terminals,
+ * McKinsey decks, FT Lex columns. Tight spacing, gridded backgrounds,
+ * monospace numerals, restrained accents, lots of small data labels.
+ * Reads as "rigorous" and "trustworthy".
+ *
+ * Best fit: KPI reviews, earnings reports, research summaries, any
+ * deck where the numbers ARE the message.
+ */
+import { buildScale } from '../typography.js';
+
+export default {
+  id: 'data-heavy',
+  family: 'data',
+  description: 'Analyst-style: tight grid, monospace numerals, gridded backgrounds, restrained accents.',
+  defaults: {
+    palette:    'finch',
+    spacing:    'tight',
+    shape:      'sharp',
+    background: 'grid',
+  },
+  typography: buildScale({
+    display: 'Calibri',
+    body:    'Calibri',
+    mono:    'Consolas',
+    sizes: {
+      display:  48,
+      title:    24,
+      subtitle: 14,
+      body:     12,
+      caption:  9,
+      stat:     72,
+      eyebrow:  9,
+    },
+    weights: { display: 'bold', title: 'bold', subtitle: 'normal' },
+    letterSpacing: { display: -1, title: 0, eyebrow: 2 },
+  }),
+  archetypes: {
+    hero: {
+      align: 'left',
+      reportMeta: true,             // small "Q4 2026 · Report" line over title
+    },
+    statCallout: {
+      statColor: 'primary',
+      labelStyle: 'mono',           // mono labels feel "data"
+      sourceFootnote: true,         // source line at bottom
+    },
+    quote: {
+      bigQuotes: false,
+      attributionStyle: 'block',
+    },
+    twoColChart: {
+      gridlinesOnChart: true,
+      smallMultiples: true,
+    },
+    table: {
+      striped: true,
+      monospaceNumbers: true,
+    },
+  },
+  decoration: {
+    grid: {
+      lineColor: 'subtle',
+      lineOpacity: 8,
+      spacing: 0.5,                  // grid line every 0.5"
+    },
+    geometric: {
+      style: 'data',
+      density: 'minimal',
+    },
+    noiseOpacity: 0,
+    mesh: {
+      stops: 2,
+      saturation: 'muted',
+    },
+  },
+};

package/src/tools/office/pres/themes/editorial-warm.js

@@ -0,0 +1,73 @@
+/**
+ * Theme: editorial-warm
+ *
+ * Reference: long-read magazines — Wired, NYT Magazine, The Atlantic.
+ * Serif display + sans body; cream paper background with hairline
+ * rules; sharp corners (no shadows); large breathing room; small
+ * eyebrow labels above titles. Reads as "considered" and "literary".
+ *
+ * Best fit: research reports, design reviews, brand-story decks, any
+ * narrative-driven presentation where the words carry the room.
+ */
+import { buildScale } from '../typography.js';
+
+export default {
+  id: 'editorial-warm',
+  family: 'editorial',
+  description: 'Magazine-style: serif display + sans body, generous whitespace, hairline rules, sharp corners.',
+  defaults: {
+    palette:    'cream-charcoal',
+    spacing:    'airy',
+    shape:      'sharp',
+    background: 'noise',
+  },
+  typography: buildScale({
+    display: 'Georgia',
+    body:    'Calibri',
+    mono:    'Consolas',
+    sizes: {
+      display:  60,
+      title:    32,
+      subtitle: 18,
+      body:     14,
+      caption:  10,
+      stat:     108,
+      eyebrow:  10,
+    },
+    weights: { subtitle: 'normal' },
+    letterSpacing: { display: -2, title: -1, eyebrow: 3 },
+  }),
+  /** Archetype-specific tweaks. Each archetype reads `theme.archetypes[id]`
+   *  with falls back to {}. Used to shift defaults without forking the
+   *  whole archetype implementation. */
+  archetypes: {
+    hero: {
+      align: 'left',
+      eyebrowDivider: true,   // a tiny accent rule under the eyebrow
+      drop: 'small-caps',     // titles are mixed-case, no all-caps
+    },
+    statCallout: {
+      statColor: 'primary',
+      labelStyle: 'eyebrow',
+    },
+    quote: {
+      bigQuotes: true,        // huge serif quote marks
+      attributionRule: true,  // hairline rule above attribution
+    },
+    sectionHeader: {
+      ruleAbove: true,
+    },
+  },
+  /** Generated-background tuning: noise opacity, mesh saturation, etc. */
+  decoration: {
+    noiseOpacity: 12,         // 0-100, applied to subtle dots over bg
+    geometric: {
+      style: 'editorial',     // small accent rules, blocks, no blobs
+      density: 'sparse',
+    },
+    mesh: {
+      stops: 3,
+      saturation: 'muted',
+    },
+  },
+};

package/src/tools/office/pres/themes/index.js

@@ -0,0 +1,82 @@
+/**
+ * pres/themes — theme registry + resolver.
+ *
+ * The agent passes `theme: 'editorial-warm'` (or one of the other
+ * presets). This module turns that string + optional per-axis overrides
+ * (palette, spacing, shape, background) into a fully-resolved Theme
+ * object that downstream archetypes consume.
+ *
+ * Adding a theme:
+ *   1. Create `themes/<id>.js` exporting the shape these three follow
+ *   2. Register it below in THEMES
+ *   3. Pick a default palette + defaults for the other 4 axes
+ */
+import editorialWarm from './editorial-warm.js';
+import techBold from './tech-bold.js';
+import dataHeavy from './data-heavy.js';
+
+import { resolvePalette } from '../palettes.js';
+import { resolveSpacing } from '../grid.js';
+import { resolveShape } from '../shapes.js';
+
+const THEMES = {
+  'editorial-warm': editorialWarm,
+  'tech-bold':      techBold,
+  'data-heavy':     dataHeavy,
+};
+
+/**
+ * List the available theme presets — used by the showcase verifier
+ * and by the agent-facing tool description.
+ */
+export function listThemes() {
+  return Object.values(THEMES).map(t => ({
+    id: t.id,
+    family: t.family,
+    description: t.description,
+    defaults: t.defaults,
+  }));
+}
+
+/**
+ * Resolve a theme spec into the full runtime object every archetype
+ * + background generator consumes.
+ *
+ * Inputs:
+ *   spec.theme       — 'editorial-warm' | 'tech-bold' | 'data-heavy'
+ *   spec.palette     — optional palette override
+ *   spec.spacing     — optional spacing override
+ *   spec.shape       — optional shape override
+ *   spec.background  — optional background-style override (theme-wide)
+ *
+ * The returned object holds:
+ *   theme            — the registered theme module (typography, archetypes config)
+ *   palette          — resolved palette object (6 semantic roles)
+ *   spacing          — resolved spacing metrics (margins, grid, body/header regions)
+ *   shape            — resolved shape tokens (corner radius, shadow)
+ *   bg               — resolved background style id (used by backgrounds/index.js)
+ *   decoration       — passthrough decoration config from the theme module
+ */
+export function resolveTheme(spec = {}) {
+  const id = spec.theme && THEMES[spec.theme] ? spec.theme : 'editorial-warm';
+  const theme = THEMES[id];
+
+  const palette = resolvePalette(spec.palette || theme.defaults.palette, theme.family);
+  const spacing = resolveSpacing(spec.spacing || theme.defaults.spacing);
+  const shape   = resolveShape(spec.shape   || theme.defaults.shape);
+  const bg      = spec.background || theme.defaults.background;
+
+  return {
+    theme,
+    palette,
+    spacing,
+    shape,
+    bg,
+    decoration: theme.decoration || {},
+    typography: theme.typography,
+    /** Convenience accessor: theme-specific archetype config. */
+    archetypeConfig(archetypeId) {
+      return (theme.archetypes && theme.archetypes[archetypeId]) || {};
+    },
+  };
+}

package/src/tools/office/pres/themes/tech-bold.js

@@ -0,0 +1,70 @@
+/**
+ * Theme: tech-bold
+ *
+ * Reference: modern SaaS keynotes — Linear, Stripe Sessions, Vercel
+ * Ship Week. Dark default background, electric accents, round corners
+ * with soft shadows on cards, tight typographic rhythm, mesh-gradient
+ * backgrounds for hero / section slides. Reads as "future-forward"
+ * and "confident".
+ *
+ * Best fit: investor pitches, product launches, engineering keynotes,
+ * any deck that needs visual energy without sacrificing readability.
+ */
+import { buildScale } from '../typography.js';
+
+export default {
+  id: 'tech-bold',
+  family: 'tech',
+  description: 'Modern SaaS keynote: dark, electric, round corners + soft shadows, mesh-gradient hero slides.',
+  defaults: {
+    palette:    'electric-night',
+    spacing:    'cozy',
+    shape:      'round',
+    background: 'mesh',
+  },
+  typography: buildScale({
+    display: 'Calibri',
+    body:    'Calibri',
+    mono:    'Consolas',
+    sizes: {
+      display:  64,
+      title:    34,
+      subtitle: 20,
+      body:     15,
+      caption:  11,
+      stat:     112,
+      eyebrow:  10,
+    },
+    weights: { display: 'bold', title: 'bold', subtitle: 'normal' },
+    letterSpacing: { display: -2, title: -1, eyebrow: 2 },
+  }),
+  archetypes: {
+    hero: {
+      align: 'left',
+      eyebrowOnAccent: true,    // eyebrow uses accent colour
+    },
+    statCallout: {
+      statColor: 'primary',
+      cardBackground: 'surface', // wrap the stat in a surface card with glow
+    },
+    quote: {
+      bigQuotes: false,
+      attributionStyle: 'inline-rule',
+    },
+    twoColChart: {
+      chartElevated: true,       // chart sits in a "card" with shadow
+    },
+  },
+  decoration: {
+    mesh: {
+      stops: 4,
+      saturation: 'vivid',
+      blur: 'high',
+    },
+    geometric: {
+      style: 'tech',             // floating blob + diagonal line accents
+      density: 'medium',
+    },
+    noiseOpacity: 0,             // no grain — mesh is the texture
+  },
+};

package/src/tools/office/pres/typography.js

@@ -0,0 +1,113 @@
+/**
+ * pres/typography — type scales per theme family.
+ *
+ * Six named roles every theme defines, so archetypes can ask for
+ * "display" or "caption" without thinking about points. The agent
+ * never picks font size or font face — only the theme does.
+ *
+ * Font choices are deliberately conservative: each is either a
+ * Windows/Mac default or has a sensible substitution. The user's
+ * PowerPoint will best-effort substitute if missing, but starting
+ * from defaults means the deck looks the same to ~95% of viewers.
+ */
+
+/** Typography scale shape. */
+export const ROLES = ['display', 'title', 'subtitle', 'body', 'caption', 'mono'];
+
+/**
+ * Build a typography scale from a theme's font pair + base sizes.
+ * Lets each theme override only what differs from the family default.
+ *
+ *   buildScale({
+ *     display: 'Georgia',
+ *     body:    'Calibri',
+ *     mono:    'Consolas',
+ *     sizes: { display: 60, title: 36, subtitle: 18, body: 14, caption: 11, mono: 12 },
+ *   })
+ */
+export function buildScale({
+  display,
+  body,
+  mono,
+  sizes = {},
+  weights = {},
+  letterSpacing = {},
+  textColor = null,
+}) {
+  const s = {
+    display:  sizes.display  ?? 56,
+    title:    sizes.title    ?? 34,
+    subtitle: sizes.subtitle ?? 18,
+    body:     sizes.body     ?? 14,
+    caption:  sizes.caption  ?? 11,
+    mono:     sizes.mono     ?? 12,
+  };
+  return {
+    display: {
+      fontFace: display,
+      fontSize: s.display,
+      bold: weights.display === 'bold' || weights.display === undefined,
+      charSpacing: letterSpacing.display ?? -1, // tight tracking on huge text
+    },
+    title: {
+      fontFace: display,
+      fontSize: s.title,
+      bold: weights.title !== 'normal',
+      charSpacing: letterSpacing.title ?? 0,
+    },
+    subtitle: {
+      fontFace: body,
+      fontSize: s.subtitle,
+      bold: weights.subtitle === 'bold',
+      charSpacing: letterSpacing.subtitle ?? 0,
+    },
+    body: {
+      fontFace: body,
+      fontSize: s.body,
+      charSpacing: letterSpacing.body ?? 0,
+    },
+    caption: {
+      fontFace: body,
+      fontSize: s.caption,
+      charSpacing: letterSpacing.caption ?? 0.5, // a bit looser for small text
+    },
+    mono: {
+      fontFace: mono,
+      fontSize: s.mono,
+    },
+    /** Big-stat numeric override that data-heavy themes can opt into. */
+    stat: {
+      fontFace: display,
+      fontSize: sizes.stat ?? 96,
+      bold: true,
+      charSpacing: -2,
+    },
+    /** Tiny pill / eyebrow label sitting above titles. */
+    eyebrow: {
+      fontFace: body,
+      fontSize: sizes.eyebrow ?? 10,
+      bold: true,
+      charSpacing: 2,
+    },
+    /** Optional default text colour the archetype falls back to when
+     *  the palette doesn't dictate. */
+    defaultColor: textColor,
+  };
+}
+
+/**
+ * Merge a role's base style with overrides (colour, alignment, etc.)
+ * the archetype passes through. Used in every archetype so the agent
+ * never sets font/size directly.
+ */
+export function textStyle(scale, role, overrides = {}) {
+  const base = scale[role] || scale.body;
+  return {
+    fontFace: base.fontFace,
+    fontSize: base.fontSize,
+    bold: base.bold,
+    italic: base.italic,
+    charSpacing: base.charSpacing,
+    ...overrides,
+  };
+}

package/web-ui/build/index.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Loxia Autopilot One</title>
     <meta name="description" content="AI Agents System - No-code/vibe-code/companion-coder platform" />
-    <script type="module" crossorigin src="/static/index-CTtNXVAZ.js"></script>
+    <script type="module" crossorigin src="/static/index-IiLN4TYi.js"></script>
     <link rel="stylesheet" crossorigin href="/static/index-DkBBEGYj.css">
   </head>
   <body>

package/web-ui/build/static/1c-CIpm7shn.js

@@ -0,0 +1,2 @@
+import{g as f}from"./index-IiLN4TYi.js";import{r as s}from"./index-B15_bH1N.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const c=Object.getOwnPropertyDescriptor(e,r);c&&Object.defineProperty(t,r,c.get?c:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=s();const p=f(a),l=i({__proto__:null,default:p},[a]);export{l as _};
+//# sourceMappingURL=1c-CIpm7shn.js.map