<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>字符编码实验室</title>
<style>
:root {
  --bg-primary: #0f1419;
  --bg-secondary: #1a2027;
  --bg-tertiary: #24303c;
  --text-primary: #e6edf3;
  --text-secondary: #8b949e;
  --accent: #58a6ff;
  --success: #3fb950;
  --error: #f85149;
  --warning: #d29922;
  --border: #30363d;
  --code-bg: #161b22;
}
* { box-sizing: border-box; margin: 0; padding: 0; }
body {
  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Microsoft YaHei', sans-serif;
  background: var(--bg-primary);
  color: var(--text-primary);
  line-height: 1.6;
  padding: 20px;
  max-width: 1400px;
  margin: 0 auto;
}
h1 {
  text-align: center;
  color: var(--accent);
  margin-bottom: 30px;
  font-size: 28px;
  border-bottom: 2px solid var(--accent);
  padding-bottom: 15px;
}
h2 {
  color: var(--text-primary);
  margin-bottom: 15px;
  font-size: 20px;
  padding-left: 12px;
  border-left: 4px solid var(--accent);
}
section {
  background: var(--bg-secondary);
  border-radius: 12px;
  padding: 20px;
  margin-bottom: 25px;
  border: 1px solid var(--border);
}
.input-group {
  display: flex;
  gap: 12px;
  align-items: center;
  margin-bottom: 15px;
  flex-wrap: wrap;
}
.input-group label {
  color: var(--text-secondary);
  min-width: 80px;
}
input[type="text"] {
  flex: 1;
  min-width: 200px;
  padding: 10px 14px;
  background: var(--bg-tertiary);
  border: 1px solid var(--border);
  border-radius: 6px;
  color: var(--text-primary);
  font-size: 16px;
}
input[type="text"]:focus {
  outline: none;
  border-color: var(--accent);
  box-shadow: 0 0 0 3px rgba(88, 166, 255, 0.15);
}
textarea {
  width: 100%;
  padding: 12px;
  background: var(--code-bg);
  border: 1px solid var(--border);
  border-radius: 6px;
  color: var(--text-primary);
  font-family: 'Fira Code', 'Consolas', monospace;
  font-size: 14px;
  resize: vertical;
  min-height: 60px;
}
table {
  width: 100%;
  border-collapse: collapse;
  margin-top: 12px;
  font-size: 14px;
}
th, td {
  padding: 10px 12px;
  text-align: left;
  border-bottom: 1px solid var(--border);
}
th {
  background: var(--bg-tertiary);
  color: var(--accent);
  font-weight: 600;
  position: sticky;
  top: 0;
}
tr:hover { background: var(--bg-tertiary); }
.byte-hex {
  font-family: 'Fira Code', 'Consolas', monospace;
  color: var(--accent);
  letter-spacing: 1px;
}
.byte-group {
  display: inline-block;
  margin-right: 8px;
  padding: 2px 6px;
  background: var(--code-bg);
  border-radius: 4px;
  border: 1px solid var(--border);
}
.copy-btn {
  background: var(--bg-tertiary);
  border: 1px solid var(--border);
  color: var(--text-secondary);
  padding: 4px 10px;
  border-radius: 4px;
  cursor: pointer;
  font-size: 12px;
  margin-left: 8px;
  transition: all 0.2s;
}
.copy-btn:hover { background: var(--accent); color: white; }
.copy-btn.copied { background: var(--success); color: white; }
.code-block {
  background: var(--code-bg);
  padding: 12px;
  border-radius: 6px;
  font-family: 'Fira Code', 'Consolas', monospace;
  font-size: 13px;
  overflow-x: auto;
  white-space: pre-wrap;
  word-break: break-all;
  line-height: 1.8;
}
.char-cell {
  font-size: 18px;
  text-align: center;
}
.badge {
  display: inline-block;
  padding: 2px 8px;
  border-radius: 12px;
  font-size: 12px;
  font-weight: 600;
}
.badge-utf8 { background: rgba(59, 130, 246, 0.2); color: #60a5fa; }
.badge-utf16 { background: rgba(16, 185, 129, 0.2); color: #34d399; }
.badge-gbk { background: rgba(245, 158, 11, 0.2); color: #fbbf24; }
.badge-error { background: rgba(248, 81, 73, 0.2); color: #f85149; }
.badge-success { background: rgba(63, 185, 80, 0.2); color: #3fb950; }
.grid-2 { display: grid; grid-template-columns: 1fr 1fr; gap: 15px; }
@media (max-width: 768px) { .grid-2 { grid-template-columns: 1fr; } }
select {
  padding: 8px 12px;
  background: var(--bg-tertiary);
  border: 1px solid var(--border);
  border-radius: 6px;
  color: var(--text-primary);
  font-size: 14px;
}
.moji-result {
  padding: 15px;
  background: var(--code-bg);
  border-radius: 6px;
  margin-top: 10px;
  border: 1px solid var(--border);
}
.moji-result .original { color: var(--text-secondary); font-size: 12px; margin-bottom: 8px; }
.moji-result .garbled { color: var(--error); font-size: 18px; font-weight: bold; }
.moji-result .normal { color: var(--success); font-size: 16px; }
.moji-reason { color: var(--text-secondary); font-size: 13px; margin-top: 8px; padding-top: 8px; border-top: 1px solid var(--border); }
.test-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(320px, 1fr));
  gap: 12px;
}
.test-item {
  background: var(--bg-tertiary);
  padding: 12px;
  border-radius: 8px;
  border: 1px solid var(--border);
}
.test-name { color: var(--text-secondary); font-size: 12px; margin-bottom: 6px; }
.test-detail { font-family: 'Fira Code', monospace; font-size: 13px; }
.test-detail .expected { color: var(--warning); }
.test-detail .actual { color: var(--accent); }
.summary {
  text-align: center;
  font-size: 20px;
  padding: 20px;
  margin-top: 15px;
  border-radius: 8px;
  font-weight: bold;
}
.summary.pass { background: rgba(63, 185, 80, 0.1); color: var(--success); border: 1px solid var(--success); }
.summary.fail { background: rgba(248, 81, 73, 0.1); color: var(--error); border: 1px solid var(--error); }
.encoding-tabs {
  display: flex;
  gap: 8px;
  margin-bottom: 15px;
  flex-wrap: wrap;
}
.encoding-tab {
  padding: 8px 16px;
  background: var(--bg-tertiary);
  border: 1px solid var(--border);
  border-radius: 6px;
  cursor: pointer;
  color: var(--text-secondary);
  transition: all 0.2s;
}
.encoding-tab:hover { color: var(--text-primary); }
.encoding-tab.active { background: var(--accent); color: white; border-color: var(--accent); }
.legend {
  display: flex;
  gap: 15px;
  flex-wrap: wrap;
  margin-bottom: 15px;
  font-size: 13px;
}
.legend-item { display: flex; align-items: center; gap: 6px; }
.legend-color { width: 14px; height: 14px; border-radius: 3px; }
</style>
</head>
<body>
<h1>🔬 字符编码实验室</h1>

<section id="input-section">
  <h2>📝 输入文本</h2>
  <div class="input-group">
    <label>文本内容:</label>
    <input type="text" id="textInput" value="汉字A😀" placeholder="输入要分析的文本...">
    <button class="copy-btn" onclick="copyInput()">复制</button>
  </div>
  <p style="color:var(--text-secondary);font-size:13px;">支持 Unicode 字符、emoji、特殊符号等,实时分析每种编码的字节序列。</p>
</section>

<section id="detail-section">
  <h2>📊 逐字符分析</h2>
  <div class="legend">
    <div class="legend-item"><span class="legend-color" style="background:#60a5fa"></span> UTF-8</div>
    <div class="legend-item"><span class="legend-color" style="background:#34d399"></span> UTF-16</div>
    <div class="legend-item"><span class="legend-color" style="background:#fbbf24"></span> GBK</div>
  </div>
  <div style="overflow-x:auto;">
    <table id="charTable">
      <thead>
        <tr>
          <th>字符</th>
          <th>Unicode 码位</th>
          <th>名称</th>
          <th>UTF-8 字节</th>
          <th>UTF-16 码元</th>
          <th>GBK 字节</th>
        </tr>
      </thead>
      <tbody></tbody>
    </table>
  </div>
</section>

<section id="encoding-section">
  <h2>💾 完整字节序列对比</h2>
  <div class="encoding-tabs" id="encodingTabs">
    <div class="encoding-tab active" data-enc="utf8">UTF-8</div>
    <div class="encoding-tab" data-enc="utf16le">UTF-16LE</div>
    <div class="encoding-tab" data-enc="utf16be">UTF-16BE</div>
    <div class="encoding-tab" data-enc="gbk">GBK</div>
  </div>
  <div id="encodingContent" class="code-block"></div>
</section>

<section id="garbled-section">
  <h2>🔮 乱码复现</h2>
  <div class="grid-2">
    <div>
      <h3 style="font-size:16px;color:var(--warning);margin-bottom:10px;">UTF-8 字节 → GBK 解码</h3>
      <p style="color:var(--text-secondary);font-size:13px;margin-bottom:10px;">用 GBK 解码 UTF-8 字节,产生「锟斤拷」等经典乱码</p>
      <div id="garbledUtf8ToGbk" class="moji-result">
        <div class="original">原始字节:<span id="utf8BytesForGbk"></span></div>
        <div class="garbled" id="utf8GbkResult"></div>
        <div class="moji-reason" id="utf8GbkReason"></div>
      </div>
    </div>
    <div>
      <h3 style="font-size:16px;color:var(--warning);margin-bottom:10px;">GBK 字节 → UTF-8 解码</h3>
      <p style="color:var(--text-secondary);font-size:13px;margin-bottom:10px;">用 UTF-8 解码 GBK 字节,产生「烫烫烫」等乱码</p>
      <div id="garbledGbkToUtf8" class="moji-result">
        <div class="original">原始字节:<span id="gbkBytesForUtf8"></span></div>
        <div class="garbled" id="gbkUtf8Result"></div>
        <div class="moji-reason" id="gbkUtf8Reason"></div>
      </div>
    </div>
  </div>
</section>

<section id="decoder-section">
  <h2>🧮 字节解码器</h2>
  <div class="input-group">
    <label>十六进制:</label>
    <input type="text" id="hexInput" placeholder="输入十六进制字节,如 E4 B8 AD" style="flex:2;">
    <select id="decodeEncoding">
      <option value="utf8">UTF-8</option>
      <option value="utf16le">UTF-16LE</option>
      <option value="utf16be">UTF-16BE</option>
      <option value="gbk">GBK</option>
    </select>
    <button class="copy-btn" onclick="decodeBytes()">解码</button>
  </div>
  <div id="decodeResult" class="moji-result" style="display:none;">
    <div class="original" id="decodeOriginal"></div>
    <div class="normal" id="decodeOutput"></div>
  </div>
</section>

<section id="selftest-section">
  <h2>🧪 自检断言</h2>
  <p style="color:var(--text-secondary);font-size:13px;margin-bottom:15px;">验证编码与解码实现的正确性,14 条断言覆盖常见字符</p>
  <div class="test-grid" id="testGrid"></div>
  <div id="testSummary" class="summary"></div>
</section>

<script>
// GBK 码表构建:枚举所有可能的双字节组合
let gbkMap = null; // char -> bytes
let gbkReverseMap = null; // bytes -> char

function buildGbkMap() {
  if (gbkMap) return;
  gbkMap = new Map();
  gbkReverseMap = new Map();
  
  // GBK 单字节部分 (0x00-0x7F 与 ASCII 相同)
  for (let i = 0; i <= 0x7F; i++) {
    gbkMap.set(String.fromCharCode(i), [i]);
  }
  
  // GBK 双字节部分:0x81-0xFE 作为首字节,0x40-0xFE 作为次字节
  const decoder = new TextDecoder('gbk');
  for (let b1 = 0x81; b1 <= 0xFE; b1++) {
    for (let b2 = 0x40; b2 <= 0xFE; b2++) {
      // 跳过 0x7F
      if (b2 === 0x7F) continue;
      const bytes = new Uint8Array([b1, b2]);
      try {
        const char = decoder.decode(bytes);
        if (char.length === 1 && !gbkMap.has(char)) {
          gbkMap.set(char, [b1, b2]);
          gbkReverseMap.set((b1 << 8) | b2, char);
        }
      } catch(e) {}
    }
  }
}

function getGbkBytes(char) {
  buildGbkMap();
  return gbkMap.get(char) || null;
}

// 编码函数
function getUtf8Bytes(str) {
  const encoder = new TextEncoder();
  return Array.from(encoder.encode(str));
}

function getUtf16LEBytes(str) {
  const result = [];
  for (let i = 0; i < str.length; i++) {
    const code = str.charCodeAt(i);
    result.push(code & 0xFF, (code >> 8) & 0xFF);
  }
  return result;
}

function getUtf16BEBytes(str) {
  const result = [];
  for (let i = 0; i < str.length; i++) {
    const code = str.charCodeAt(i);
    result.push((code >> 8) & 0xFF, code & 0xFF);
  }
  return result;
}

function getGbkBytesArr(str) {
  buildGbkMap();
  const result = [];
  for (const char of str) {
    const bytes = gbkMap.get(char);
    if (bytes) {
      result.push(...bytes);
    } else {
      result.push(0x3F); // 无法编码时用 ?
    }
  }
  return result;
}

// 解码函数
function decodeUtf8(bytes) {
  try {
    const decoder = new TextDecoder('utf8');
    return { text: decoder.decode(new Uint8Array(bytes)), error: null };
  } catch(e) {
    return { text: null, error: e.message };
  }
}

function decodeGbk(bytes) {
  try {
    const decoder = new TextDecoder('gbk');
    return { text: decoder.decode(new Uint8Array(bytes)), error: null };
  } catch(e) {
    return { text: null, error: e.message };
  }
}

function decodeUtf16LE(bytes) {
  try {
    const decoder = new TextDecoder('utf-16le');
    return { text: decoder.decode(new Uint8Array(bytes)), error: null };
  } catch(e) {
    return { text: null, error: e.message };
  }
}

function decodeUtf16BE(bytes) {
  try {
    const decoder = new TextDecoder('utf-16be');
    return { text: decoder.decode(new Uint8Array(bytes)), error: null };
  } catch(e) {
    return { text: null, error: e.message };
  }
}

// 格式化字节为十六进制
function bytesToHex(bytes) {
  return bytes.map(b => b.toString(16).toUpperCase().padStart(2, '0')).join(' ');
}

function bytesToGroups(bytes, encoding) {
  if (encoding === 'utf8') {
    return bytes.map(b => {
      let cls = 'byte-group ';
      if ((b & 0x80) === 0) cls += 'badge-utf8';
      else if ((b & 0xE0) === 0xC0) cls += 'badge-utf8';
      else if ((b & 0xF0) === 0xE0) cls += 'badge-utf8';
      else if ((b & 0xF8) === 0xF0) cls += 'badge-utf8';
      else cls += 'badge-utf8';
      return `<span class="${cls}">${b.toString(16).toUpperCase().padStart(2,'0')}</span>`;
    }).join(' ');
  }
  return bytes.map(b => b.toString(16).toUpperCase().padStart(2, '0')).join(' ');
}

// 获取字符名称
function getCharName(char) {
  const code = char.codePointAt(0);
  if (code >= 0x4E00 && code <= 0x9FFF) return '汉字';
  if (code >= 0x3040 && code <= 0x309F) return '平假名';
  if (code >= 0x30A0 && code <= 0x30FF) return '片假名';
  if (code >= 0xAC00 && code <= 0xD7AF) return '韩文';
  if (code >= 0x0041 && code <= 0x005A) return '大写字母';
  if (code >= 0x0061 && code <= 0x007A) return '小写字母';
  if (code >= 0x0030 && code <= 0x0039) return '数字';
  if (code >= 0x1F600 && code <= 0x1F64F) return '表情符号';
  if (code >= 0x1F300 && code <= 0x1F9FF) return '符号/表情';
  if (code === 0x20) return '空格';
  if (code === 0x0A) return '换行';
  if (code === 0x0D) return '回车';
  if (code < 0x80) return 'ASCII字符';
  return 'Unicode字符';
}

// 分析文本并更新表格
function analyzeText() {
  const text = document.getElementById('textInput').value;
  const tbody = document.querySelector('#charTable tbody');
  tbody.innerHTML = '';
  
  const chars = Array.from(text); // 正确处理代理对
  
  chars.forEach(char => {
    const codePoint = char.codePointAt(0);
    const hexCode = codePoint.toString(16).toUpperCase().padStart(4, '0');
    const utf8Bytes = getUtf8Bytes(char);
    const utf16Bytes = getUtf16LEBytes(char);
    const gbkBytes = getGbkBytes(char);
    
    const tr = document.createElement('tr');
    tr.innerHTML = `
      <td class="char-cell">${char === ' ' ? '&nbsp;' : char}</td>
      <td><code>U+${hexCode}</code></td>
      <td>${getCharName(char)}</td>
      <td><span class="byte-hex">${bytesToHex(utf8Bytes)}</span> <span class="badge badge-utf8">${utf8Bytes.length}字节</span></td>
      <td><span class="byte-hex">${bytesToHex(utf16Bytes)}</span> <span class="badge badge-utf16">${utf16Bytes.length/2}码元</span></td>
      <td><span class="byte-hex">${gbkBytes ? bytesToHex(gbkBytes) : 'N/A'}</span> <span class="badge badge-gbk">${gbkBytes ? gbkBytes.length + '字节' : '不支持'}</span></td>
    `;
    tbody.appendChild(tr);
  });
  
  updateEncodingView();
  updateGarbledDemo();
}

let currentEncoding = 'utf8';

function updateEncodingView() {
  const text = document.getElementById('textInput').value;
  let bytes = [];
  let encodingName = '';
  
  switch(currentEncoding) {
    case 'utf8':
      bytes = getUtf8Bytes(text);
      encodingName = 'UTF-8';
      break;
    case 'utf16le':
      bytes = getUtf16LEBytes(text);
      encodingName = 'UTF-16LE';
      break;
    case 'utf16be':
      bytes = getUtf16BEBytes(text);
      encodingName = 'UTF-16BE';
      break;
    case 'gbk':
      bytes = getGbkBytesArr(text);
      encodingName = 'GBK';
      break;
  }
  
  document.getElementById('encodingContent').innerHTML = 
    `<span style="color:var(--text-secondary)">${encodingName} 字节序列:</span>\n` +
    bytes.map(b => b.toString(16).toUpperCase().padStart(2, '0')).join(' ');
}

// 乱码复现
function updateGarbledDemo() {
  const text = document.getElementById('textInput').value;
  
  // UTF-8 字节 -> GBK 解码
  const utf8Bytes = getUtf8Bytes(text);
  document.getElementById('utf8BytesForGbk').textContent = bytesToHex(utf8Bytes);
  const utf8GbkResult = decodeGbk(utf8Bytes);
  document.getElementById('utf8GbkResult').textContent = utf8GbkResult.text;
  document.getElementById('utf8GbkReason').innerHTML = 
    `<strong>原因:</strong>UTF-8 多字节字符被 GBK 当作单/双字节解析,产生错误映射。<br>` +
    `<strong>典型现象:</strong>「锟斤拷」来自 UTF-8 替换字符 0xEF 0xBF 0xBD 被 GBK 解码为「锟斤拷」。<br>` +
    `<strong>字节分析:</strong>UTF-8 用 1-4 字节编码,GBK 用 1-2 字节,解析边界不匹配导致乱码。`;
  
  // GBK 字节 -> UTF-8 解码
  const gbkBytes = getGbkBytesArr(text);
  document.getElementById('gbkBytesForUtf8').textContent = bytesToHex(gbkBytes);
  const gbkUtf8Result = decodeUtf8(gbkBytes);
  if (gbkUtf8Result.error) {
    document.getElementById('gbkUtf8Result').textContent = '解码失败:' + gbkUtf8Result.error;
    document.getElementById('gbkUtf8Result').className = 'garbled';
  } else {
    document.getElementById('gbkUtf8Result').textContent = gbkUtf8Result.text;
    document.getElementById('gbkUtf8Result').className = 'garbled';
  }
  document.getElementById('gbkUtf8Reason').innerHTML = 
    `<strong>原因:</strong>GBK 双字节被 UTF-8 当作独立字节或无效序列解析,产生无效字符。<br>` +
    `<strong>典型现象:</strong>「烫烫烫」来自调试器填充未初始化内存的 0xCC 字节:GBK 把 CC CC 解成「烫」、CD CD 解成「屯」。<br>` +
    `<strong>字节分析:</strong>GBK 双字节首字节可能落在 UTF-8 的连续字节范围,被当作独立字符。`;
}

// 字节解码器
function decodeBytes() {
  const hexStr = document.getElementById('hexInput').value.trim();
  const encoding = document.getElementById('decodeEncoding').value;
  const resultDiv = document.getElementById('decodeResult');
  
  // 解析十六进制
  let bytes = [];
  try {
    const compact = hexStr.replace(/[\s,]+/g, '');
    if (!compact) throw new Error('请输入十六进制字节,例如 E4 B8 AD');
    if (!/^[0-9A-Fa-f]+$/.test(compact)) throw new Error('含非十六进制字符:' + compact.replace(/[0-9A-Fa-f]/g, ''));
    if (compact.length % 2 !== 0) throw new Error('十六进制字符个数为奇数,请补全');
    bytes = compact.match(/../g).map(p => parseInt(p, 16));
  } catch(e) {
    resultDiv.style.display = 'block';
    document.getElementById('decodeOriginal').textContent = '输入:' + hexStr;
    document.getElementById('decodeOutput').textContent = '❌ ' + e.message;
    document.getElementById('decodeOutput').className = 'garbled';
    return;
  }
  
  let result = { text: null, error: null };
  switch(encoding) {
    case 'utf8': result = decodeUtf8(bytes); break;
    case 'utf16le': result = decodeUtf16LE(bytes); break;
    case 'utf16be': result = decodeUtf16BE(bytes); break;
    case 'gbk': result = decodeGbk(bytes); break;
  }
  
  resultDiv.style.display = 'block';
  document.getElementById('decodeOriginal').textContent = 
    `输入:${bytesToHex(bytes)}  |  编码:${encoding.toUpperCase()}`;
  
  if (result.error) {
    document.getElementById('decodeOutput').textContent = '❌ 解码失败:' + result.error;
    document.getElementById('decodeOutput').className = 'garbled';
  } else {
    document.getElementById('decodeOutput').textContent = result.text;
    document.getElementById('decodeOutput').className = 'normal';
  }
}

// 复制功能
function copyInput() {
  const text = document.getElementById('textInput').value;
  navigator.clipboard.writeText(text).then(() => {
    const btn = event.target;
    btn.textContent = '已复制!';
    btn.classList.add('copied');
    setTimeout(() => { btn.textContent = '复制'; btn.classList.remove('copied'); }, 2000);
  });
}

// 编码Tab切换
document.querySelectorAll('.encoding-tab').forEach(tab => {
  tab.addEventListener('click', function() {
    document.querySelectorAll('.encoding-tab').forEach(t => t.classList.remove('active'));
    this.classList.add('active');
    currentEncoding = this.dataset.enc;
    updateEncodingView();
  });
});

// 输入事件
document.getElementById('textInput').addEventListener('input', analyzeText);
document.getElementById('hexInput').addEventListener('input', function() {
  if (this.value.trim()) decodeBytes();
});

// 自检断言
function runSelfTest() {
  const tests = [
    { name: '「中」UTF-8', char: '中', enc: 'utf8', expected: 'E4 B8 AD' },
    { name: '「中」UTF-16LE', char: '中', enc: 'utf16le', expected: '2D 4E' },
    { name: '「中」GBK', char: '中', enc: 'gbk', expected: 'D6 D0' },
    { name: '「汉」UTF-8', char: '汉', enc: 'utf8', expected: 'E6 B1 89' },
    { name: '「汉」UTF-16LE', char: '汉', enc: 'utf16le', expected: '49 6C' },
    { name: '「汉」GBK', char: '汉', enc: 'gbk', expected: 'BA BA' },
    { name: '「A」UTF-8', char: 'A', enc: 'utf8', expected: '41' },
    { name: '「A」UTF-16LE', char: 'A', enc: 'utf16le', expected: '41 00' },
    { name: '「😀」UTF-8', char: '😀', enc: 'utf8', expected: 'F0 9F 98 80' },
    { name: '「😀」UTF-16LE', char: '😀', enc: 'utf16le', expected: '3D D8 00 DE' },
    { name: '「😀」GBK', char: '😀', enc: 'gbk', expected: '3F' },
    { name: '「𐍈」UTF-8', char: '𐍈', enc: 'utf8', expected: 'F0 90 8D 88' },
    { name: '「中」UTF-16BE 解码', kind: 'decode', hex: '4E 2D', enc: 'utf16be', char: '中' },
    { name: '「汉」GBK 解码', kind: 'decode', hex: 'BA BA', enc: 'gbk', char: '汉' },
  ];
  
  let passed = 0;
  const grid = document.getElementById('testGrid');
  grid.innerHTML = '';
  
  tests.forEach(test => {
    let actual = '';
    let expected = test.expected;
    if (test.kind === 'decode') {
      const b = test.hex.split(' ').map(h => parseInt(h, 16));
      const r = test.enc === 'utf16be' ? decodeUtf16BE(b) : test.enc === 'gbk' ? decodeGbk(b) : decodeUtf8(b);
      actual = r.error ? ('ERR: ' + r.error) : r.text;
      expected = test.char;
    } else if (test.enc === 'utf8') actual = bytesToHex(getUtf8Bytes(test.char));
    else if (test.enc === 'utf16le') actual = bytesToHex(getUtf16LEBytes(test.char));
    else if (test.enc === 'gbk') actual = bytesToHex(getGbkBytesArr(test.char));
    
    const isPass = actual === expected;
    if (isPass) passed++;
    
    const item = document.createElement('div');
    item.className = 'test-item';
    item.innerHTML = `
      <div class="test-name">${test.name}</div>
      <div class="test-detail">
        <span class="expected">期望: ${expected}</span><br>
        <span class="actual">实际: ${actual}</span>
        <span style="margin-left:8px;" class="badge ${isPass ? 'badge-success' : 'badge-error'}">${isPass ? '✓' : '✗'}</span>
      </div>
    `;
    grid.appendChild(item);
  });
  
  const summary = document.getElementById('testSummary');
  summary.className = `summary ${passed === tests.length ? 'pass' : 'fail'}`;
  summary.textContent = `自检结果:${passed}/${tests.length} 条通过`;
}

// 初始化
buildGbkMap();
analyzeText();
runSelfTest();
</script>
</body>
</html>