Ls Design Huashu

/**
 * AndroidFrame — Android设备边框（参考Pixel 8系列）
 *
 * 含：punch-hole相机 + 状态栏 + 导航栏 + 圆角
 *
 * 用法：
 *   <AndroidFrame time="9:41" battery={85}>
 *     <YourAppContent />
 *   </AndroidFrame>
 */

const androidFrameStyles = {
  wrapper: {
    display: "inline-block",
    padding: 10,
    background: "#1a1a1a",
    borderRadius: 44,
    boxShadow: "0 0 0 2px #2a2a2a, 0 20px 60px rgba(0,0,0,0.3)",
    position: "relative",
  },
  screen: {
    position: "relative",
    borderRadius: 36,
    overflow: "hidden",
    background: "#fff",
  },
  statusBar: {
    position: "absolute",
    top: 0,
    left: 0,
    right: 0,
    height: 32,
    display: "flex",
    alignItems: "center",
    justifyContent: "space-between",
    padding: "0 24px",
    fontSize: 14,
    fontWeight: 500,
    fontFamily: "Roboto, -apple-system, sans-serif",
    zIndex: 20,
    pointerEvents: "none",
  },
  punchHole: {
    position: "absolute",
    top: 10,
    left: "50%",
    transform: "translateX(-50%)",
    width: 14,
    height: 14,
    background: "#000",
    borderRadius: "50%",
    zIndex: 30,
  },
  statusIcons: {
    display: "flex",
    alignItems: "center",
    gap: 6,
  },
  batteryText: {
    fontSize: 11,
    fontWeight: 600,
    marginLeft: 2,
  },
  content: {
    position: "absolute",
    top: 32,
    left: 0,
    right: 0,
    bottom: 24,
    overflow: "auto",
  },
  navBar: {
    position: "absolute",
    bottom: 0,
    left: 0,
    right: 0,
    height: 24,
    display: "flex",
    alignItems: "center",
    justifyContent: "center",
    gap: 60,
    zIndex: 10,
  },
  navButton: {
    width: 36,
    height: 4,
    background: "rgba(0,0,0,0.3)",
    borderRadius: 999,
  },
};

function AndroidFrame({
  children,
  width = 412,
  height = 892,
  time = "9:41",
  battery = 100,
  darkMode = false,
  navStyle = "gesture",
}) {
  const textColor = darkMode ? "#fff" : "#1a1a1a";

  return (
    <div style={androidFrameStyles.wrapper}>
      <div
        style={{
          ...androidFrameStyles.screen,
          width,
          height,
          background: darkMode ? "#000" : "#fff",
        }}
      >
        <div style={{ ...androidFrameStyles.statusBar, color: textColor }}>
          <span>{time}</span>
          <div style={androidFrameStyles.statusIcons}>
            <svg width="14" height="10" viewBox="0 0 14 10" fill="currentColor">
              <rect x="0" y="6" width="2" height="4" rx="0.5" />
              <rect x="4" y="4" width="2" height="6" rx="0.5" />
              <rect x="8" y="2" width="2" height="8" rx="0.5" />
              <rect x="12" y="0" width="2" height="10" rx="0.5" />
            </svg>
            <svg width="14" height="10" viewBox="0 0 14 10" fill="none">
              <path d="M7 9a1 1 0 100-2 1 1 0 000 2z" fill="currentColor" />
              <path d="M3 6a5 5 0 018 0" stroke="currentColor" strokeWidth="1.2" />
              <path
                d="M0.5 3.5a11 11 0 0113 0"
                stroke="currentColor"
                strokeWidth="1.2"
                opacity="0.6"
              />
            </svg>
            <div
              style={{
                width: 22,
                height: 10,
                border: "1.5px solid currentColor",
                borderRadius: 2,
                padding: 1,
                position: "relative",
              }}
            >
              <div
                style={{
                  width: `${battery}%`,
                  height: "100%",
                  background: "currentColor",
                  borderRadius: 1,
                }}
              />
            </div>
            <span style={androidFrameStyles.batteryText}>{battery}%</span>
          </div>
        </div>

        <div style={androidFrameStyles.punchHole} />

        <div style={androidFrameStyles.content}>{children}</div>

        {navStyle === "gesture" && (
          <div style={androidFrameStyles.navBar}>
            <div
              style={{
                ...androidFrameStyles.navButton,
                width: 100,
                height: 4,
                background: darkMode ? "rgba(255,255,255,0.5)" : "rgba(0,0,0,0.4)",
              }}
            />
          </div>
        )}

        {navStyle === "buttons" && (
          <div style={androidFrameStyles.navBar}>
            <span style={{ color: textColor, fontSize: 20 }}>◁</span>
            <span style={{ color: textColor, fontSize: 16 }}>○</span>
            <span style={{ color: textColor, fontSize: 16 }}>□</span>
          </div>
        )}
      </div>
    </div>
  );
}

if (typeof window !== "undefined") {
  window.AndroidFrame = AndroidFrame;
}

/**
 * animations.jsx — 时间轴动画引擎
 *
 * Stage + Sprite 模式，借鉴Remotion但轻量化。
 *
 * 导出（挂到 window.Animations）：
 * - Stage: 整个动画容器，提供时间+控制
 * - Sprite: 时间片段，start/end内显示，提供本地进度
 * - useTime(): 读全局时间（秒）
 * - useSprite(): 读本地进度 {t: 0→1, elapsed: seconds, duration: seconds}
 * - Easing: {linear, easeIn, easeOut, easeInOut, spring, anticipation}
 * - interpolate(t, [input0, input1], [output0, output1], easing?)
 *
 * 用法：
 *   <Stage duration={10}>
 *     <Sprite start={0} end={3}>
 *       <Title />
 *     </Sprite>
 *     <Sprite start={2} end={5}>
 *       <Subtitle />
 *     </Sprite>
 *   </Stage>
 *
 * 在Sprite子组件里用 useSprite() 读当前片段进度。
 */

(function () {
  const { createContext, useContext, useState, useEffect, useRef, useCallback } = React;

  const TimeContext = createContext({ time: 0, duration: 10, playing: false });
  const SpriteContext = createContext(null);

  const Easing = {
    linear: (t) => t,
    easeIn: (t) => t * t,
    easeOut: (t) => 1 - (1 - t) * (1 - t),
    easeInOut: (t) => (t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2),
    // expoOut: Anthropic-level 主 easing (cubic-bezier(0.16, 1, 0.3, 1))
    // 迅速启动 + 缓慢刹车，给数字元素物理重量感
    expoOut: (t) => (t === 1 ? 1 : 1 - Math.pow(2, -10 * t)),
    // overshoot: 带弹性的 toggle/按钮弹出 (cubic-bezier(0.34, 1.56, 0.64, 1))
    overshoot: (t) => {
      const c1 = 1.70158,
        c3 = c1 + 1;
      return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
    },
    spring: (t) => {
      const c = (2 * Math.PI) / 3;
      return t === 0 ? 0 : t === 1 ? 1 : Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c) + 1;
    },
    anticipation: (t) => {
      if (t < 0.2) return -0.3 * (t / 0.2) * (t / 0.2);
      const adjusted = (t - 0.2) / 0.8;
      return -0.012 + 1.012 * adjusted * adjusted * (3 - 2 * adjusted);
    },
  };

  function interpolate(t, input, output, easing) {
    const [inStart, inEnd] = input;
    const [outStart, outEnd] = output;

    if (t <= inStart) return outStart;
    if (t >= inEnd) return outEnd;

    let progress = (t - inStart) / (inEnd - inStart);
    if (easing) {
      progress = easing(progress);
    }

    return outStart + (outEnd - outStart) * progress;
  }

  function useTime() {
    const ctx = useContext(TimeContext);
    return ctx.time;
  }

  function useSprite() {
    const sprite = useContext(SpriteContext);
    if (!sprite) {
      return { t: 0, elapsed: 0, duration: 0 };
    }
    return sprite;
  }

  const stageStyles = {
    wrapper: {
      position: "fixed",
      inset: 0,
      background: "#000",
      display: "flex",
      flexDirection: "column",
      fontFamily: "-apple-system, sans-serif",
    },
    stageHolder: {
      flex: 1,
      position: "relative",
      overflow: "hidden",
    },
    canvas: {
      position: "absolute",
      top: "50%",
      left: "50%",
      transformOrigin: "center center",
      background: "#111",
      overflow: "hidden",
    },
    controls: {
      position: "fixed",
      bottom: 0,
      left: 0,
      right: 0,
      background: "rgba(0, 0, 0, 0.8)",
      backdropFilter: "blur(10px)",
      padding: "12px 20px",
      display: "flex",
      alignItems: "center",
      gap: 16,
      color: "#fff",
      fontSize: 12,
      zIndex: 100,
    },
    button: {
      background: "none",
      border: "1px solid rgba(255,255,255,0.3)",
      color: "#fff",
      padding: "6px 14px",
      borderRadius: 4,
      cursor: "pointer",
      fontSize: 12,
    },
    timeDisplay: {
      fontFamily: "ui-monospace, monospace",
      fontVariantNumeric: "tabular-nums",
      minWidth: 90,
    },
    scrubber: {
      flex: 1,
      height: 4,
      background: "rgba(255,255,255,0.2)",
      borderRadius: 2,
      position: "relative",
      cursor: "pointer",
    },
    scrubberFill: {
      position: "absolute",
      top: 0,
      left: 0,
      height: "100%",
      background: "#fff",
      borderRadius: 2,
      pointerEvents: "none",
    },
    scrubberHandle: {
      position: "absolute",
      top: "50%",
      width: 12,
      height: 12,
      background: "#fff",
      borderRadius: "50%",
      transform: "translate(-50%, -50%)",
      pointerEvents: "none",
    },
  };

  function Stage({
    duration = 10,
    width = 1920,
    height = 1080,
    fps = 60,
    loop = true,
    children,
    bgColor = "#fff",
  }) {
    const [time, setTime] = useState(0);
    const [playing, setPlaying] = useState(true);
    const [scale, setScale] = useState(1);
    const rafRef = useRef(null);
    const startTimeRef = useRef(performance.now());
    const canvasRef = useRef(null);

    // Recording mode: render-video.js injects window.__recording = true before goto.
    // When set, force loop=false so the export ends on the final frame instead of
    // wrapping back to t=0 and capturing the start of the next cycle.
    // (Browsers viewing manually still loop because __recording is undefined there.)
    const effectiveLoop = typeof window !== "undefined" && window.__recording ? false : loop;

    useEffect(() => {
      function updateScale() {
        const vw = window.innerWidth;
        const vh = window.innerHeight - 56;
        const s = Math.min(vw / width, vh / height);
        setScale(s);
      }
      updateScale();
      window.addEventListener("resize", updateScale);
      return () => window.removeEventListener("resize", updateScale);
    }, [width, height]);

    useEffect(() => {
      if (!playing) return;
      let cancelled = false;
      let last = null;

      function tick(now) {
        if (cancelled) return;
        if (last === null) {
          // First animation frame. Set last=now so delta starts at 0,
          // AND announce readiness for video export.
          // This pairing is critical: window.__ready must flip to true at
          // the exact moment WebM captures frame 0 of the animation, so
          // render-video.js's trim offset equals the pre-animation gap.
          last = now;
          if (typeof window !== "undefined") window.__ready = true;
        }
        const delta = (now - last) / 1000;
        last = now;
        setTime((prev) => {
          const next = prev + delta;
          if (next >= duration) {
            // effectiveLoop honors window.__recording (forced non-loop during export).
            // Stop just shy of duration so the final-frame state stays rendered
            // (avoids exiting all Sprites that end exactly at `duration`).
            return effectiveLoop ? 0 : duration - 0.001;
          }
          return next;
        });
        rafRef.current = requestAnimationFrame(tick);
      }

      // Wait for fonts before starting the clock — makes frame 0 the
      // real "finished-loading" frame users see, not a fallback-font flash.
      const startAfterFonts = () => {
        if (cancelled) return;
        rafRef.current = requestAnimationFrame(tick);
      };
      if (typeof document !== "undefined" && document.fonts && document.fonts.ready) {
        document.fonts.ready.then(startAfterFonts);
      } else {
        startAfterFonts();
      }

      return () => {
        cancelled = true;
        cancelAnimationFrame(rafRef.current);
      };
    }, [playing, duration, effectiveLoop]);

    const handleScrub = useCallback(
      (e) => {
        const rect = e.currentTarget.getBoundingClientRect();
        const ratio = (e.clientX - rect.left) / rect.width;
        setTime(Math.max(0, Math.min(duration, ratio * duration)));
      },
      [duration],
    );

    const handleSeek = useCallback(
      (e) => {
        handleScrub(e);
        setPlaying(false);
      },
      [handleScrub],
    );

    const progress = time / duration;

    const ctx = {
      time,
      duration,
      playing,
      setPlaying,
      setTime,
    };

    const canvasStyle = {
      ...stageStyles.canvas,
      width,
      height,
      background: bgColor,
      transform: `translate(-50%, -50%) scale(${scale})`,
    };

    return (
      <TimeContext.Provider value={ctx}>
        <div style={stageStyles.wrapper}>
          <div style={stageStyles.stageHolder}>
            <div ref={canvasRef} style={canvasStyle}>
              {children}
            </div>
          </div>

          <div style={stageStyles.controls}>
            <button style={stageStyles.button} onClick={() => setPlaying((p) => !p)}>
              {playing ? "⏸ 暂停" : "▶ 播放"}
            </button>

            <button style={stageStyles.button} onClick={() => setTime(0)}>
              ⏮ 开始
            </button>

            <div style={stageStyles.timeDisplay}>
              {time.toFixed(2)}s / {duration.toFixed(2)}s
            </div>

            <div style={stageStyles.scrubber} onMouseDown={handleSeek}>
              <div style={{ ...stageStyles.scrubberFill, width: `${progress * 100}%` }} />
              <div style={{ ...stageStyles.scrubberHandle, left: `${progress * 100}%` }} />
            </div>
          </div>
        </div>
      </TimeContext.Provider>
    );
  }

  function Sprite({ start = 0, end, children, style }) {
    const { time } = useContext(TimeContext);
    const actualEnd = end == null ? Infinity : end;

    if (time < start || time >= actualEnd) {
      return null;
    }

    const duration = actualEnd - start;
    const elapsed = time - start;
    const t = duration === 0 ? 1 : Math.max(0, Math.min(1, elapsed / duration));

    const spriteValue = { t, elapsed, duration, start, end: actualEnd };

    return (
      <SpriteContext.Provider value={spriteValue}>
        <div style={{ position: "absolute", inset: 0, ...style }}>{children}</div>
      </SpriteContext.Provider>
    );
  }

  if (typeof window !== "undefined") {
    window.Animations = {
      Stage,
      Sprite,
      useTime,
      useSprite,
      Easing,
      interpolate,
    };
  }
})();

/**
 * BrowserWindow — 浏览器窗口边框（Chrome风格）
 *
 * 含：traffic lights + tab bar + URL bar
 *
 * 用法：
 *   <BrowserWindow url="https://example.com" title="Example">
 *     <YourWebPage />
 *   </BrowserWindow>
 */

const browserWindowStyles = {
  window: {
    display: "inline-block",
    background: "#fff",
    borderRadius: 10,
    overflow: "hidden",
    boxShadow: "0 30px 80px rgba(0,0,0,0.25), 0 0 0 0.5px rgba(0,0,0,0.15)",
  },
  chrome: {
    background: "#dee1e6",
    paddingTop: 10,
    paddingLeft: 10,
    paddingRight: 10,
    userSelect: "none",
  },
  tabRow: {
    display: "flex",
    alignItems: "flex-end",
    gap: 6,
    position: "relative",
  },
  trafficLights: {
    display: "flex",
    gap: 8,
    alignItems: "center",
    paddingBottom: 10,
    marginRight: 8,
  },
  light: {
    width: 12,
    height: 12,
    borderRadius: "50%",
    border: "0.5px solid rgba(0,0,0,0.15)",
  },
  close: { background: "#ff5f57" },
  minimize: { background: "#febc2e" },
  maximize: { background: "#28c840" },
  tab: {
    background: "#fff",
    padding: "8px 30px 8px 14px",
    borderTopLeftRadius: 10,
    borderTopRightRadius: 10,
    fontSize: 12,
    color: "#222",
    fontFamily: "-apple-system, sans-serif",
    maxWidth: 220,
    display: "flex",
    alignItems: "center",
    gap: 8,
    position: "relative",
    whiteSpace: "nowrap",
    overflow: "hidden",
    textOverflow: "ellipsis",
  },
  favicon: {
    width: 14,
    height: 14,
    borderRadius: 2,
    background: "#999",
    flexShrink: 0,
  },
  navBar: {
    background: "#fff",
    padding: "8px 14px",
    display: "flex",
    alignItems: "center",
    gap: 10,
    borderBottom: "1px solid #e5e7eb",
  },
  navButtons: {
    display: "flex",
    gap: 4,
    color: "#5f6368",
    fontSize: 16,
  },
  navButton: {
    width: 28,
    height: 28,
    display: "flex",
    alignItems: "center",
    justifyContent: "center",
    borderRadius: "50%",
    cursor: "pointer",
  },
  urlBar: {
    flex: 1,
    background: "#f1f3f4",
    borderRadius: 999,
    padding: "7px 14px",
    fontSize: 13,
    color: "#333",
    display: "flex",
    alignItems: "center",
    gap: 8,
    fontFamily: "-apple-system, sans-serif",
  },
  lockIcon: {
    color: "#5f6368",
    fontSize: 12,
  },
  content: {
    position: "relative",
    overflow: "auto",
    background: "#fff",
  },
};

function BrowserWindow({
  title = "New Tab",
  url = "https://example.com",
  width = 1200,
  height = 800,
  showTrafficLights = true,
  children,
}) {
  return (
    <div style={browserWindowStyles.window}>
      <div style={browserWindowStyles.chrome}>
        <div style={browserWindowStyles.tabRow}>
          {showTrafficLights && (
            <div style={browserWindowStyles.trafficLights}>
              <div style={{ ...browserWindowStyles.light, ...browserWindowStyles.close }} />
              <div style={{ ...browserWindowStyles.light, ...browserWindowStyles.minimize }} />
              <div style={{ ...browserWindowStyles.light, ...browserWindowStyles.maximize }} />
            </div>
          )}
          <div style={browserWindowStyles.tab}>
            <div style={browserWindowStyles.favicon} />
            <span>{title}</span>
          </div>
        </div>
      </div>

      <div style={browserWindowStyles.navBar}>
        <div style={browserWindowStyles.navButtons}>
          <div style={browserWindowStyles.navButton}>←</div>
          <div style={browserWindowStyles.navButton}>→</div>
          <div style={browserWindowStyles.navButton}>↻</div>
        </div>
        <div style={browserWindowStyles.urlBar}>
          <span style={browserWindowStyles.lockIcon}>🔒</span>
          <span>{url}</span>
        </div>
      </div>

      <div style={{ ...browserWindowStyles.content, width, height }}>{children}</div>
    </div>
  );
}

if (typeof window !== "undefined") {
  window.BrowserWindow = BrowserWindow;
}

<!doctype html>
<html lang="zh-CN">
  <head>
    <meta charset="UTF-8" />
    <title>Deck · Multi-file Slide Index</title>
    <!--
  deck_index.html — 多文件 slide deck 的拼接器

  配合「每页一个独立 HTML」架构使用。与单文件 deck_stage.js 对比：
  · 每页独立作用域（CSS/JS 都隔离），一页出 bug 不影响其他页
  · 单页可直接在浏览器打开验证，不依赖 JS goTo()
  · 多 agent 可并行做不同页，merge 时零冲突
  · 适合 ≥15 页的讲座/课件/长 deck

  用法：
    1. 把本文件复制到 deck 根目录，重命名 index.html
    2. 在同目录建 slides/ 子目录，放每一页独立 HTML
    3. 编辑下方 MANIFEST 数组，按顺序列出文件名和人类可读标签
    4. 每张 slide HTML 建议尺寸 1920×1080，自带背景/字体；不要依赖外层 CSS

  共享资源（如果需要）：
    · shared/tokens.css  — 跨页 CSS 变量（色板/字号）
    · shared/chrome.html — 页眉页脚可复用片段
    · 每页 HTML 自己 <link> 进去即可

  键盘：← / → / Space / PgUp / PgDown / Home / End / 1-9 跳页 / P 打印
-->

    <!-- ═══════════════════════════════════════════════════════ -->
    <!-- EDIT THIS — deck 所有页按顺序列出                        -->
    <!-- ═══════════════════════════════════════════════════════ -->
    <script>
      window.DECK_MANIFEST = [
        { file: "slides/01-cover.html", label: "Cover" },
        { file: "slides/02-quote.html", label: "Opening Quote" },
        { file: "slides/03-intro.html", label: "Self-intro" },
        // 继续往下加。file 是相对本文件的路径，label 用于计数器
      ];

      // 固定 canvas 尺寸。每页 HTML 都应该按这个尺寸设计。
      window.DECK_WIDTH = 1920;
      window.DECK_HEIGHT = 1080;
    </script>

    <style>
      * {
        box-sizing: border-box;
        margin: 0;
        padding: 0;
      }
      html,
      body {
        height: 100%;
        background: #0a0a0a;
        overflow: hidden;
        font-family: -apple-system, "PingFang SC", sans-serif;
      }
      #stage {
        position: fixed;
        top: 50%;
        left: 50%;
        transform-origin: top left;
        will-change: transform;
        background: #fff;
        box-shadow: 0 10px 60px rgba(0, 0, 0, 0.4);
        /* size set by JS from DECK_WIDTH/HEIGHT */
      }
      iframe {
        width: 100%;
        height: 100%;
        border: 0;
        display: block;
        background: #fff;
      }
      .counter {
        position: fixed;
        bottom: 20px;
        right: 20px;
        background: rgba(0, 0, 0, 0.65);
        color: #fff;
        padding: 6px 14px;
        border-radius: 999px;
        font-size: 13px;
        letter-spacing: 0.05em;
        font-variant-numeric: tabular-nums;
        z-index: 100;
        user-select: none;
        opacity: 0.7;
        transition: opacity 0.2s;
      }
      .counter:hover {
        opacity: 1;
      }
      .counter .label {
        color: rgba(255, 255, 255, 0.7);
        margin-left: 8px;
      }
      .nav-zone {
        position: fixed;
        top: 0;
        bottom: 0;
        width: 15%;
        cursor: pointer;
        z-index: 50;
      }
      .nav-zone.left {
        left: 0;
      }
      .nav-zone.right {
        right: 0;
      }
      .nav-hint {
        position: absolute;
        top: 50%;
        transform: translateY(-50%);
        width: 44px;
        height: 44px;
        border-radius: 999px;
        background: rgba(255, 255, 255, 0.08);
        color: rgba(255, 255, 255, 0.6);
        display: flex;
        align-items: center;
        justify-content: center;
        font-size: 22px;
        opacity: 0;
        transition: opacity 0.2s;
      }
      .nav-zone.left .nav-hint {
        left: 20px;
      }
      .nav-zone.right .nav-hint {
        right: 20px;
      }
      .nav-zone:hover .nav-hint {
        opacity: 1;
      }

      /* Print: one slide per page, no navigation UI */
      @media print {
        @page {
          size: 1920px 1080px;
          margin: 0;
        }
        html,
        body {
          background: #fff;
          overflow: visible;
          height: auto;
        }
        #stage {
          position: static;
          transform: none !important;
          box-shadow: none;
        }
        .counter,
        .nav-zone {
          display: none !important;
        }
        /* In print mode we render all slides sequentially — see JS */
        .print-stack {
          display: block;
        }
        .print-stack iframe {
          width: 1920px;
          height: 1080px;
          page-break-after: always;
          display: block;
        }
      }
    </style>
  </head>
  <body>
    <div id="stage">
      <iframe id="frame" src="about:blank"></iframe>
    </div>

    <div class="nav-zone left" id="navL"><div class="nav-hint">‹</div></div>
    <div class="nav-zone right" id="navR"><div class="nav-hint">›</div></div>
    <div class="counter" id="counter">1 / 1</div>

    <!-- Print-only stack: populated on beforeprint, stripped on afterprint -->
    <div class="print-stack" id="printStack" style="display: none"></div>

    <script>
      (function () {
        const W = window.DECK_WIDTH || 1920;
        const H = window.DECK_HEIGHT || 1080;
        const deck = window.DECK_MANIFEST || [];
        const stage = document.getElementById("stage");
        const frame = document.getElementById("frame");
        const counter = document.getElementById("counter");
        const printStack = document.getElementById("printStack");
        const storageKey = "deck-index-" + location.pathname;
        let current = 0;

        stage.style.width = W + "px";
        stage.style.height = H + "px";

        function fit() {
          const s = Math.min(window.innerWidth / W, window.innerHeight / H);
          const x = (window.innerWidth - W * s) / 2;
          const y = (window.innerHeight - H * s) / 2;
          stage.style.transform = `translate(${x}px, ${y}px) scale(${s})`;
          stage.style.top = "0";
          stage.style.left = "0";
        }

        function show(idx) {
          if (idx < 0 || idx >= deck.length) return;
          current = idx;
          frame.src = deck[idx].file;
          counter.innerHTML = `${idx + 1} / ${deck.length} <span class="label">${deck[idx].label || ""}</span>`;
          try {
            localStorage.setItem(storageKey, String(idx));
          } catch (_) {}
          if (location.hash !== "#" + (idx + 1)) {
            history.replaceState(null, "", "#" + (idx + 1));
          }
        }

        function next() {
          show(Math.min(current + 1, deck.length - 1));
        }
        function prev() {
          show(Math.max(current - 1, 0));
        }

        // Keyboard
        document.addEventListener("keydown", (e) => {
          if (e.target.tagName === "INPUT" || e.target.tagName === "TEXTAREA") return;
          switch (e.key) {
            case "ArrowRight":
            case " ":
            case "PageDown":
              e.preventDefault();
              next();
              break;
            case "ArrowLeft":
            case "PageUp":
              e.preventDefault();
              prev();
              break;
            case "Home":
              e.preventDefault();
              show(0);
              break;
            case "End":
              e.preventDefault();
              show(deck.length - 1);
              break;
            case "p":
            case "P":
              window.print();
              break;
            default:
              if (e.key >= "1" && e.key <= "9") {
                const i = parseInt(e.key, 10) - 1;
                if (i < deck.length) {
                  e.preventDefault();
                  show(i);
                }
              }
          }
        });

        document.getElementById("navL").addEventListener("click", prev);
        document.getElementById("navR").addEventListener("click", next);
        window.addEventListener("resize", fit);
        window.addEventListener("hashchange", () => {
          const m = location.hash.match(/^#(\d+)$/);
          if (m) show(parseInt(m[1], 10) - 1);
        });

        // Initial: hash > localStorage > 0
        const hashMatch = location.hash.match(/^#(\d+)$/);
        if (hashMatch) current = Math.min(parseInt(hashMatch[1], 10) - 1, deck.length - 1);
        else
          try {
            const v = parseInt(localStorage.getItem(storageKey), 10);
            if (!isNaN(v) && v >= 0 && v < deck.length) current = v;
          } catch (_) {}
        fit();
        show(current);

        // Print: build a stack of all iframes so browser prints every slide
        window.addEventListener("beforeprint", () => {
          printStack.innerHTML = "";
          deck.forEach((item) => {
            const f = document.createElement("iframe");
            f.src = item.file;
            printStack.appendChild(f);
          });
          printStack.style.display = "block";
          document.getElementById("stage").style.display = "none";
        });
        window.addEventListener("afterprint", () => {
          printStack.innerHTML = "";
          printStack.style.display = "none";
          document.getElementById("stage").style.display = "";
        });
      })();
    </script>
  </body>
</html>

/**
 * <deck-stage> — HTML幻灯片外壳web component
 *
 * 提供功能：
 * - 固定尺寸canvas（默认1920×1080）+ auto-scale + letterbox
 * - 键盘导航（←/→/Space/Home/End/Esc）
 * - 左右点击区域导航
 * - slide counter (当前/总数)
 * - localStorage持久化当前slide
 * - Speaker notes postMessage (支持外层渲染)
 * - Hash导航 (#slide-5 跳到第5张)
 * - Print-to-PDF支持 (Cmd+P / Ctrl+P 一页一slide)
 * - 自动给每个slide添加 data-screen-label
 *
 * 用法：
 *   <deck-stage>
 *     <section>Slide 1</section>
 *     <section>Slide 2</section>
 *   </deck-stage>
 *
 * 自定义尺寸：
 *   <deck-stage width="1080" height="1920">...</deck-stage>
 *
 * Speaker notes：在<head>加
 *   <script type="application/json" id="speaker-notes">
 *   ["slide 1 notes", "slide 2 notes"]
 *   </script>
 */

(function () {
  const STORAGE_KEY_PREFIX = "deck-stage-slide-";

  class DeckStage extends HTMLElement {
    constructor() {
      super();
      this.attachShadow({ mode: "open" });
      this._currentSlide = 0;
      this._slides = [];
      this._storageKey = STORAGE_KEY_PREFIX + (location.pathname || "default");
    }

    connectedCallback() {
      this._width = parseInt(this.getAttribute("width")) || 1920;
      this._height = parseInt(this.getAttribute("height")) || 1080;

      // Shadow DOM 先渲染（独立于子节点，不受 parser 时机影响）
      this._render();

      // 防御：若 script 放在 <head> 里（而非 </deck-stage> 之后），
      // parser 此刻可能还没处理完子 <section>，querySelectorAll 会返回空。
      // 延迟到下一个事件循环，确保子节点都已 parse 完毕。
      const init = () => {
        this._collectSlides();
        this._setupEventListeners();
        this._restoreSlide();
        this._updateDisplay();
        this._setupPrintStyles();
      };

      if (this.ownerDocument.readyState === "loading") {
        // 文档还在 parse，等 DOMContentLoaded 一次搞定所有 section
        this.ownerDocument.addEventListener("DOMContentLoaded", init, { once: true });
      } else {
        // 文档已 parse 完（script 在 body 底部或 defer），下一帧收集即可
        requestAnimationFrame(init);
      }
    }

    _render() {
      this.shadowRoot.innerHTML = `
        <style>
          :host {
            display: block;
            position: fixed;
            inset: 0;
            background: #000;
            overflow: hidden;
            font-family: -apple-system, 'SF Pro Text', 'PingFang SC', sans-serif;
          }

          :host([noscale]) .stage {
            transform: none !important;
            top: 0 !important;
            left: 0 !important;
          }

          .stage {
            position: absolute;
            top: 50%;
            left: 50%;
            transform-origin: top left;
            will-change: transform;
            background: #fff;
          }

          .slide-wrapper {
            width: 100%;
            height: 100%;
            position: relative;
          }

          ::slotted(section) {
            display: none;
            width: 100%;
            height: 100%;
            position: absolute;
            top: 0;
            left: 0;
            overflow: hidden;
          }

          ::slotted(section.active) {
            display: block;
          }

          .counter {
            position: fixed;
            bottom: 20px;
            right: 20px;
            background: rgba(0, 0, 0, 0.6);
            color: #fff;
            padding: 6px 14px;
            border-radius: 999px;
            font-size: 13px;
            font-variant-numeric: tabular-nums;
            z-index: 100;
            user-select: none;
            opacity: 0.6;
            transition: opacity 0.2s;
          }

          .counter:hover {
            opacity: 1;
          }

          .nav-zone {
            position: fixed;
            top: 0;
            bottom: 0;
            width: 15%;
            cursor: pointer;
            z-index: 50;
          }

          .nav-zone.left { left: 0; }
          .nav-zone.right { right: 0; }

          .nav-hint {
            position: absolute;
            top: 50%;
            transform: translateY(-50%);
            width: 44px;
            height: 44px;
            border-radius: 999px;
            background: rgba(255, 255, 255, 0.1);
            color: rgba(255, 255, 255, 0.6);
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 24px;
            opacity: 0;
            transition: opacity 0.2s;
          }

          .nav-zone.left .nav-hint { left: 20px; }
          .nav-zone.right .nav-hint { right: 20px; }

          .nav-zone:hover .nav-hint {
            opacity: 1;
          }

          @media print {
            :host {
              position: static;
              background: #fff;
            }
            .counter, .nav-zone {
              display: none !important;
            }
            .stage {
              position: static;
              transform: none !important;
              page-break-after: always;
            }
            ::slotted(section) {
              display: block !important;
              position: relative !important;
              page-break-after: always;
              width: 100%;
              height: 100%;
            }
          }
        </style>

        <div class="stage" id="stage" style="width: ${this._width}px; height: ${this._height}px;">
          <div class="slide-wrapper">
            <slot></slot>
          </div>
        </div>

        <div class="nav-zone left" id="navLeft">
          <div class="nav-hint">‹</div>
        </div>
        <div class="nav-zone right" id="navRight">
          <div class="nav-hint">›</div>
        </div>

        <div class="counter" id="counter">1 / 1</div>
      `;
    }

    _collectSlides() {
      this._slides = Array.from(this.querySelectorAll(":scope > section"));

      this._slides.forEach((slide, idx) => {
        if (!slide.hasAttribute("data-screen-label")) {
          const num = String(idx + 1).padStart(2, "0");
          slide.setAttribute("data-screen-label", num);
        }
        if (!slide.hasAttribute("data-om-validate")) {
          slide.setAttribute("data-om-validate", "");
        }
      });
    }

    _setupEventListeners() {
      window.addEventListener("resize", () => this._updateScale());

      document.addEventListener("keydown", (e) => {
        if (e.target.matches("input, textarea, [contenteditable]")) return;

        switch (e.key) {
          case "ArrowRight":
          case " ":
          case "PageDown":
            e.preventDefault();
            this.next();
            break;
          case "ArrowLeft":
          case "PageUp":
            e.preventDefault();
            this.prev();
            break;
          case "Home":
            e.preventDefault();
            this.goTo(0);
            break;
          case "End":
            e.preventDefault();
            this.goTo(this._slides.length - 1);
            break;
        }
      });

      this.shadowRoot.getElementById("navLeft").addEventListener("click", () => this.prev());
      this.shadowRoot.getElementById("navRight").addEventListener("click", () => this.next());

      window.addEventListener("hashchange", () => this._handleHash());
      if (location.hash) {
        setTimeout(() => this._handleHash(), 0);
      }

      const observer = new MutationObserver(() => {
        if (this.hasAttribute("noscale")) {
          this._updateScale();
        }
      });
      observer.observe(this, { attributes: true, attributeFilter: ["noscale"] });
    }

    _handleHash() {
      const match = location.hash.match(/^#slide-(\d+)$/);
      if (match) {
        const idx = parseInt(match[1]) - 1;
        if (idx >= 0 && idx < this._slides.length) {
          this.goTo(idx);
        }
      }
    }

    _restoreSlide() {
      try {
        const stored = localStorage.getItem(this._storageKey);
        if (stored !== null) {
          const idx = parseInt(stored);
          if (idx >= 0 && idx < this._slides.length) {
            this._currentSlide = idx;
          }
        }
      } catch (e) {}
    }

    _saveSlide() {
      try {
        localStorage.setItem(this._storageKey, String(this._currentSlide));
      } catch (e) {}
    }

    _updateScale() {
      if (this.hasAttribute("noscale")) {
        const stage = this.shadowRoot.getElementById("stage");
        stage.style.transform = "none";
        stage.style.top = "0";
        stage.style.left = "0";
        return;
      }

      const stage = this.shadowRoot.getElementById("stage");
      if (!stage) return;

      const viewportW = window.innerWidth;
      const viewportH = window.innerHeight;
      const scale = Math.min(viewportW / this._width, viewportH / this._height);
      const scaledW = this._width * scale;
      const scaledH = this._height * scale;
      const offsetX = (viewportW - scaledW) / 2;
      const offsetY = (viewportH - scaledH) / 2;

      stage.style.transform = `translate(${offsetX}px, ${offsetY}px) scale(${scale})`;
      stage.style.top = "0";
      stage.style.left = "0";
    }

    _updateDisplay() {
      this._slides.forEach((slide, idx) => {
        slide.classList.toggle("active", idx === this._currentSlide);
      });

      const counter = this.shadowRoot.getElementById("counter");
      if (counter) {
        counter.textContent = `${this._currentSlide + 1} / ${this._slides.length}`;
      }

      this._updateScale();

      try {
        window.postMessage(
          {
            slideIndexChanged: this._currentSlide,
            totalSlides: this._slides.length,
          },
          "*",
        );
      } catch (e) {}

      try {
        if (window.parent && window.parent !== window) {
          window.parent.postMessage(
            {
              slideIndexChanged: this._currentSlide,
              totalSlides: this._slides.length,
            },
            "*",
          );
        }
      } catch (e) {}
    }

    _setupPrintStyles() {
      const printStyle = document.createElement("style");
      printStyle.textContent = `
        @media print {
          @page {
            size: ${this._width}px ${this._height}px;
            margin: 0;
          }
          body {
            margin: 0;
            padding: 0;
          }
          deck-stage {
            position: static !important;
          }
          deck-stage > section {
            display: block !important;
            position: relative !important;
            width: ${this._width}px !important;
            height: ${this._height}px !important;
            page-break-after: always;
            overflow: hidden;
          }
          deck-stage > section:last-child {
            page-break-after: auto;
          }
        }
      `;
      document.head.appendChild(printStyle);
    }

    next() {
      if (this._currentSlide < this._slides.length - 1) {
        this._currentSlide++;
        this._saveSlide();
        this._updateDisplay();
      }
    }

    prev() {
      if (this._currentSlide > 0) {
        this._currentSlide--;
        this._saveSlide();
        this._updateDisplay();
      }
    }

    goTo(idx) {
      if (idx >= 0 && idx < this._slides.length) {
        this._currentSlide = idx;
        this._saveSlide();
        this._updateDisplay();
      }
    }

    get currentSlide() {
      return this._currentSlide;
    }

    get totalSlides() {
      return this._slides.length;
    }
  }

  customElements.define("deck-stage", DeckStage);

  window.DeckStage = DeckStage;
})();

/**
 * DesignCanvas — 变体并排网格布局
 *
 * 用于展示2+个静态设计variations让用户对比选择。
 * 每个variation有label，可hover放大。
 *
 * 用法：
 *   <DesignCanvas
 *     title="Hero区设计探索"
 *     subtitle="3个方向对比"
 *     columns={3}
 *   >
 *     <Variation label="Minimal" description="极简克制版">
 *       <div>...你的设计1...</div>
 *     </Variation>
 *     <Variation label="Editorial" description="杂志编辑风">
 *       <div>...你的设计2...</div>
 *     </Variation>
 *     <Variation label="Brutalist" description="粗粝原始">
 *       <div>...你的设计3...</div>
 *     </Variation>
 *   </DesignCanvas>
 *
 * 配合React+Babel使用。放在合适的script里，然后window.DesignCanvas/window.Variation可用。
 */

const canvasStyles = {
  container: {
    minHeight: "100vh",
    background: "#F5F5F0",
    padding: "40px 60px",
    fontFamily: '-apple-system, "SF Pro Text", "PingFang SC", sans-serif',
  },
  header: {
    marginBottom: 48,
    maxWidth: 900,
  },
  title: {
    fontSize: 36,
    fontWeight: 600,
    marginBottom: 12,
    color: "#1A1A1A",
    letterSpacing: "-0.02em",
  },
  subtitle: {
    fontSize: 16,
    color: "#666",
    lineHeight: 1.5,
  },
  grid: {
    display: "grid",
    gap: 32,
  },
  cell: {
    display: "flex",
    flexDirection: "column",
    gap: 12,
  },
  cellHeader: {
    display: "flex",
    alignItems: "baseline",
    gap: 12,
    paddingBottom: 8,
    borderBottom: "1px solid #E0E0DA",
  },
  label: {
    fontSize: 14,
    fontWeight: 600,
    color: "#1A1A1A",
    letterSpacing: "-0.01em",
  },
  description: {
    fontSize: 13,
    color: "#888",
  },
  frame: {
    background: "#fff",
    borderRadius: 4,
    border: "1px solid #E0E0DA",
    overflow: "hidden",
    position: "relative",
    transition: "transform 0.2s ease, box-shadow 0.2s ease",
    cursor: "pointer",
  },
  frameInner: {
    position: "relative",
    width: "100%",
  },
  badge: {
    position: "absolute",
    top: 12,
    left: 12,
    background: "rgba(0, 0, 0, 0.7)",
    color: "#fff",
    padding: "3px 8px",
    borderRadius: 4,
    fontSize: 11,
    fontWeight: 500,
    letterSpacing: "0.5px",
    textTransform: "uppercase",
    zIndex: 10,
    pointerEvents: "none",
  },
};

function DesignCanvas({ title, subtitle, columns = 3, children }) {
  const [expanded, setExpanded] = React.useState(null);

  const gridStyle = {
    ...canvasStyles.grid,
    gridTemplateColumns: `repeat(${columns}, 1fr)`,
  };

  return (
    <div style={canvasStyles.container}>
      {(title || subtitle) && (
        <div style={canvasStyles.header}>
          {title && <h1 style={canvasStyles.title}>{title}</h1>}
          {subtitle && <p style={canvasStyles.subtitle}>{subtitle}</p>}
        </div>
      )}

      <div style={gridStyle}>
        {React.Children.map(children, (child, idx) =>
          React.isValidElement(child)
            ? React.cloneElement(child, {
                _index: idx,
                _expanded: expanded === idx,
                _onToggle: () => setExpanded(expanded === idx ? null : idx),
              })
            : child,
        )}
      </div>

      {expanded !== null && (
        <div
          onClick={() => setExpanded(null)}
          style={{
            position: "fixed",
            inset: 0,
            background: "rgba(0, 0, 0, 0.75)",
            zIndex: 1000,
            display: "flex",
            alignItems: "center",
            justifyContent: "center",
            padding: 40,
            cursor: "zoom-out",
          }}
        >
          <div
            onClick={(e) => e.stopPropagation()}
            style={{
              background: "#fff",
              borderRadius: 8,
              overflow: "hidden",
              maxWidth: "90vw",
              maxHeight: "90vh",
              position: "relative",
            }}
          >
            {React.Children.toArray(children)[expanded]}
          </div>
        </div>
      )}
    </div>
  );
}

function Variation({
  label,
  description,
  number,
  children,
  _index,
  _expanded,
  _onToggle,
  aspectRatio = "4 / 3",
}) {
  const displayNumber = number || String(_index + 1).padStart(2, "0");

  return (
    <div style={canvasStyles.cell}>
      <div style={canvasStyles.cellHeader}>
        <span
          style={{
            ...canvasStyles.label,
            color: "#999",
            fontFamily: "ui-monospace, monospace",
            fontSize: 12,
          }}
        >
          {displayNumber}
        </span>
        <span style={canvasStyles.label}>{label}</span>
        {description && <span style={canvasStyles.description}>— {description}</span>}
      </div>

      <div
        onClick={_onToggle}
        style={{
          ...canvasStyles.frame,
          aspectRatio,
        }}
        onMouseEnter={(e) => {
          e.currentTarget.style.boxShadow = "0 8px 24px rgba(0,0,0,0.08)";
        }}
        onMouseLeave={(e) => {
          e.currentTarget.style.boxShadow = "none";
        }}
      >
        <div style={canvasStyles.frameInner}>{children}</div>
      </div>
    </div>
  );
}

if (typeof window !== "undefined") {
  Object.assign(window, { DesignCanvas, Variation });
}