@file-viewer/renderer-text 2.0.11

package/dist/gitBundle.js

@@ -0,0 +1,580 @@
+import { createFileViewerZoomChangeEmitter as createZoomChangeEmitter, registerFileViewerZoomProvider, unregisterFileViewerZoomProvider } from '@file-viewer/core';
+import { Inflate } from 'pako';
+const textDecoder = new TextDecoder('utf-8');
+const asciiDecoder = new TextDecoder('latin1');
+const bundleStyle = `
+.git-bundle-viewer{display:grid;height:100%;min-height:420px;grid-template-rows:auto minmax(0,1fr);--bundle-bg:#f6f8fa;--bundle-surface:#fff;--bundle-border:rgba(31,35,40,.12);--bundle-text:#24292f;--bundle-muted:#57606a;--bundle-accent:#0f766e;--bundle-code:#0d1117;--bundle-code-text:#e6edf3;--bundle-font-size:13px;background:var(--bundle-bg);color:var(--bundle-text);box-sizing:border-box}
+.git-bundle-toolbar{position:sticky;top:0;z-index:2;display:flex;min-height:46px;align-items:center;justify-content:space-between;gap:12px;padding:8px 16px;border-bottom:1px solid var(--bundle-border);background:rgba(255,255,255,.92);backdrop-filter:blur(12px);box-sizing:border-box}
+.git-bundle-toolbar span,.git-bundle-toolbar strong{color:var(--bundle-muted);font-size:12px;font-weight:800;letter-spacing:0}
+.git-bundle-layout{display:grid;min-height:0;grid-template-columns:minmax(260px,340px) minmax(260px,360px) minmax(0,1fr);gap:12px;padding:12px;box-sizing:border-box}
+.git-bundle-panel{min-height:0;overflow:auto;border:1px solid var(--bundle-border);border-radius:8px;background:var(--bundle-surface)}
+.git-bundle-panel h3{position:sticky;top:0;z-index:1;margin:0;padding:11px 12px;border-bottom:1px solid var(--bundle-border);background:var(--bundle-surface);font-size:13px}
+.git-bundle-list{margin:0;padding:8px;list-style:none}
+.git-bundle-list button{display:block;width:100%;margin:0 0 6px;padding:9px 10px;border:1px solid transparent;border-radius:6px;background:transparent;color:var(--bundle-text);font:inherit;font-size:var(--bundle-font-size);text-align:left;cursor:pointer}
+.git-bundle-list button:hover,.git-bundle-list button.active{border-color:rgba(15,118,110,.28);background:rgba(15,118,110,.08)}
+.git-bundle-list small{display:block;margin-top:4px;color:var(--bundle-muted);font-size:.86em;line-height:1.35}
+.git-bundle-meta{display:grid;gap:1px;background:var(--bundle-border)}
+.git-bundle-meta div{padding:10px 12px;background:var(--bundle-surface)}
+.git-bundle-meta span{display:block;color:var(--bundle-muted);font-size:11px;font-weight:800}
+.git-bundle-meta strong{display:block;margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.git-bundle-tree{padding:10px 12px;font-size:var(--bundle-font-size)}
+.git-bundle-tree button{display:block;width:100%;padding:6px 8px;border:0;border-radius:6px;background:transparent;color:var(--bundle-text);font:inherit;text-align:left;cursor:pointer}
+.git-bundle-tree button:hover,.git-bundle-tree button.active{background:rgba(15,118,110,.08);color:var(--bundle-accent)}
+.git-bundle-file{display:grid;min-height:0;grid-template-rows:auto minmax(0,1fr)}
+.git-bundle-file-header{padding:11px 12px;border-bottom:1px solid var(--bundle-border);font-size:12px;font-weight:800;color:var(--bundle-muted)}
+.git-bundle-code{margin:0;overflow:auto;padding:16px 18px;background:var(--bundle-code);color:var(--bundle-code-text);font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,'Liberation Mono',monospace;font-size:var(--bundle-font-size);line-height:1.65;white-space:pre}
+.git-bundle-notice{margin:8px;padding:10px 12px;border:1px solid rgba(245,158,11,.35);border-radius:8px;background:rgba(245,158,11,.12);color:#92400e;font-size:12px;line-height:1.55}
+.file-viewer[data-viewer-theme='dark'] .git-bundle-viewer{--bundle-bg:#0d1117;--bundle-surface:#161b22;--bundle-border:rgba(139,148,158,.24);--bundle-text:#e6edf3;--bundle-muted:#8b949e;--bundle-code:#010409;--bundle-code-text:#e6edf3}
+.file-viewer[data-viewer-theme='dark'] .git-bundle-toolbar{background:rgba(13,17,23,.92)}
+@media (prefers-color-scheme:dark){.file-viewer[data-viewer-theme='system'] .git-bundle-viewer{--bundle-bg:#0d1117;--bundle-surface:#161b22;--bundle-border:rgba(139,148,158,.24);--bundle-text:#e6edf3;--bundle-muted:#8b949e;--bundle-code:#010409;--bundle-code-text:#e6edf3}.file-viewer[data-viewer-theme='system'] .git-bundle-toolbar{background:rgba(13,17,23,.92)}}
+@media (max-width:980px){.git-bundle-layout{grid-template-columns:1fr}.git-bundle-panel{min-height:240px}}
+`;
+const createElement = (documentRef, tagName, className, text) => {
+    const element = documentRef.createElement(tagName);
+    if (className) {
+        element.className = className;
+    }
+    if (typeof text === 'string') {
+        element.textContent = text;
+    }
+    return element;
+};
+const createStyle = (documentRef) => {
+    const style = documentRef.createElement('style');
+    style.textContent = bundleStyle;
+    return style;
+};
+const toHex = (bytes) => {
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+};
+const readUInt32 = (bytes, offset) => {
+    return ((bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]) >>> 0;
+};
+const concatBytes = (items) => {
+    const total = items.reduce((sum, item) => sum + item.byteLength, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const item of items) {
+        merged.set(item, offset);
+        offset += item.byteLength;
+    }
+    return merged;
+};
+const parseHeader = (bytes) => {
+    const lines = [];
+    let offset = 0;
+    while (offset < bytes.length) {
+        const next = bytes.indexOf(10, offset);
+        if (next < 0) {
+            throw new Error('Git bundle header is incomplete.');
+        }
+        const rawLine = bytes.subarray(offset, next);
+        const line = asciiDecoder.decode(rawLine).replace(/\r$/, '');
+        offset = next + 1;
+        if (line === '') {
+            break;
+        }
+        lines.push(line);
+    }
+    const signature = lines.shift() || '';
+    if (!signature.startsWith('# v') || !signature.includes('git bundle')) {
+        throw new Error('当前文件不是标准 Git bundle。');
+    }
+    const capabilities = [];
+    const refs = [];
+    const prerequisites = [];
+    let objectFormat = 'sha1';
+    for (const line of lines) {
+        if (line.startsWith('@')) {
+            capabilities.push(line.slice(1));
+            const objectFormatMatch = line.match(/^@object-format=(sha1|sha256)$/);
+            if (objectFormatMatch) {
+                objectFormat = objectFormatMatch[1];
+            }
+            continue;
+        }
+        if (line.startsWith('-')) {
+            const [oid = '', ...subject] = line.slice(1).split(/\s+/);
+            prerequisites.push({ oid, subject: subject.join(' ') });
+            continue;
+        }
+        const [oid = '', ...name] = line.split(/\s+/);
+        if (oid) {
+            refs.push({ oid, name: name.join(' ') || oid });
+        }
+    }
+    return {
+        signature,
+        capabilities,
+        refs,
+        prerequisites,
+        packOffset: offset,
+        objectFormat
+    };
+};
+const readPackObjectHeader = (bytes, start) => {
+    let offset = start;
+    let byte = bytes[offset++];
+    const typeCode = (byte >> 4) & 0x07;
+    let size = byte & 0x0f;
+    let shift = 4;
+    while (byte & 0x80) {
+        byte = bytes[offset++];
+        size |= (byte & 0x7f) << shift;
+        shift += 7;
+    }
+    return { typeCode, size, offset };
+};
+const readOfsDeltaBase = (bytes, start) => {
+    let offset = start;
+    let value = bytes[offset++] & 0x7f;
+    while (bytes[offset - 1] & 0x80) {
+        value += 1;
+        value = (value << 7) + (bytes[offset++] & 0x7f);
+    }
+    return { value, offset };
+};
+const inflateObject = (bytes, start) => {
+    const inflator = new Inflate();
+    let offset = start;
+    while (!inflator.ended && offset < bytes.length) {
+        inflator.push(bytes.subarray(offset, offset + 1), false);
+        offset += 1;
+        if (inflator.err) {
+            throw new Error(inflator.msg || 'Git pack object inflate failed.');
+        }
+    }
+    if (!inflator.ended || !(inflator.result instanceof Uint8Array)) {
+        throw new Error('Git pack object is incomplete.');
+    }
+    return {
+        content: inflator.result,
+        nextOffset: offset
+    };
+};
+const kindName = (typeCode) => {
+    if (typeCode === 1)
+        return 'commit';
+    if (typeCode === 2)
+        return 'tree';
+    if (typeCode === 3)
+        return 'blob';
+    if (typeCode === 4)
+        return 'tag';
+    if (typeCode === 6)
+        return 'ofs-delta';
+    if (typeCode === 7)
+        return 'ref-delta';
+    return 'unknown';
+};
+const hashObjectId = async (format, kind, content) => {
+    if (format === 'unknown') {
+        return undefined;
+    }
+    const header = new TextEncoder().encode(`${kind} ${content.byteLength}\0`);
+    const digest = await globalThis.crypto.subtle.digest(format === 'sha256' ? 'SHA-256' : 'SHA-1', concatBytes([header, content]));
+    return toHex(new Uint8Array(digest));
+};
+const readDeltaSize = (bytes, start) => {
+    let offset = start;
+    let size = 0;
+    let shift = 0;
+    let byte = 0;
+    do {
+        byte = bytes[offset++];
+        size |= (byte & 0x7f) << shift;
+        shift += 7;
+    } while (byte & 0x80);
+    return { size, offset };
+};
+const applyPackDelta = (base, delta) => {
+    const baseSize = readDeltaSize(delta, 0);
+    const targetSize = readDeltaSize(delta, baseSize.offset);
+    let offset = targetSize.offset;
+    const chunks = [];
+    if (baseSize.size !== base.byteLength) {
+        throw new Error('Git delta base size does not match the resolved object.');
+    }
+    while (offset < delta.byteLength) {
+        const opcode = delta[offset++];
+        if (opcode & 0x80) {
+            let copyOffset = 0;
+            let copySize = 0;
+            if (opcode & 0x01)
+                copyOffset = delta[offset++];
+            if (opcode & 0x02)
+                copyOffset |= delta[offset++] << 8;
+            if (opcode & 0x04)
+                copyOffset |= delta[offset++] << 16;
+            if (opcode & 0x08)
+                copyOffset |= delta[offset++] << 24;
+            if (opcode & 0x10)
+                copySize = delta[offset++];
+            if (opcode & 0x20)
+                copySize |= delta[offset++] << 8;
+            if (opcode & 0x40)
+                copySize |= delta[offset++] << 16;
+            if (copySize === 0)
+                copySize = 0x10000;
+            chunks.push(base.subarray(copyOffset, copyOffset + copySize));
+        }
+        else if (opcode) {
+            chunks.push(delta.subarray(offset, offset + opcode));
+            offset += opcode;
+        }
+        else {
+            throw new Error('Git delta contains a reserved opcode.');
+        }
+    }
+    const result = concatBytes(chunks);
+    if (result.byteLength !== targetSize.size) {
+        throw new Error('Git delta target size does not match decoded content.');
+    }
+    return result;
+};
+const resolvePackDeltas = async (objects, format) => {
+    const byOffset = new Map();
+    const byOid = new Map();
+    objects.forEach(object => {
+        byOffset.set(object.offset, object);
+        if (object.oid) {
+            byOid.set(object.oid, object);
+        }
+    });
+    for (let pass = 0; pass < objects.length; pass += 1) {
+        let resolvedThisPass = 0;
+        for (const object of objects) {
+            if (!object.deltaKind || object.oid || !object.content) {
+                continue;
+            }
+            const base = typeof object.baseOffset === 'number'
+                ? byOffset.get(object.baseOffset)
+                : object.baseOid
+                    ? byOid.get(object.baseOid)
+                    : undefined;
+            if (!(base === null || base === void 0 ? void 0 : base.content) || base.deltaKind || base.kind === 'ofs-delta' || base.kind === 'ref-delta') {
+                continue;
+            }
+            object.content = applyPackDelta(base.content, object.content);
+            object.kind = base.kind;
+            object.oid = await hashObjectId(format, object.kind, object.content);
+            if (object.oid) {
+                byOid.set(object.oid, object);
+            }
+            resolvedThisPass += 1;
+        }
+        if (!resolvedThisPass) {
+            break;
+        }
+    }
+};
+const parsePack = async (bytes, header) => {
+    const offset = header.packOffset;
+    if (asciiDecoder.decode(bytes.subarray(offset, offset + 4)) !== 'PACK') {
+        throw new Error('Git bundle header 后未找到 PACK 数据。');
+    }
+    const version = readUInt32(bytes, offset + 4);
+    const count = readUInt32(bytes, offset + 8);
+    const objects = [];
+    let cursor = offset + 12;
+    const maxObjects = Math.min(count, 2500);
+    for (let index = 0; index < maxObjects && cursor < bytes.length; index += 1) {
+        const objectOffset = cursor;
+        const parsedHeader = readPackObjectHeader(bytes, cursor);
+        cursor = parsedHeader.offset;
+        const kind = kindName(parsedHeader.typeCode);
+        let baseOffset;
+        let baseOid;
+        if (kind === 'ofs-delta') {
+            const parsedBase = readOfsDeltaBase(bytes, cursor);
+            baseOffset = objectOffset - parsedBase.value;
+            cursor = parsedBase.offset;
+        }
+        else if (kind === 'ref-delta') {
+            const oidLength = header.objectFormat === 'sha256' ? 32 : 20;
+            baseOid = toHex(bytes.subarray(cursor, cursor + oidLength));
+            cursor += oidLength;
+        }
+        const inflated = inflateObject(bytes, cursor);
+        cursor = inflated.nextOffset;
+        const item = {
+            kind,
+            size: parsedHeader.size,
+            offset: objectOffset,
+            content: inflated.content,
+            baseOffset,
+            baseOid,
+            deltaKind: kind === 'ofs-delta' || kind === 'ref-delta' ? kind : undefined
+        };
+        if (kind !== 'ofs-delta' && kind !== 'ref-delta' && kind !== 'unknown') {
+            item.oid = await hashObjectId(header.objectFormat, kind, inflated.content);
+        }
+        objects.push(item);
+    }
+    await resolvePackDeltas(objects, header.objectFormat);
+    return {
+        version,
+        declaredCount: count,
+        objects,
+        parsedCount: objects.length
+    };
+};
+const parseCommit = (object, refsByOid) => {
+    if (object.kind !== 'commit' || !object.oid || !object.content) {
+        return null;
+    }
+    const text = textDecoder.decode(object.content);
+    const [headers = '', ...messageParts] = text.split(/\n\n/);
+    const parents = [];
+    let tree;
+    let author;
+    let committer;
+    for (const line of headers.split(/\n/)) {
+        if (line.startsWith('tree ')) {
+            tree = line.slice(5);
+        }
+        else if (line.startsWith('parent ')) {
+            parents.push(line.slice(7));
+        }
+        else if (line.startsWith('author ')) {
+            author = line.slice(7);
+        }
+        else if (line.startsWith('committer ')) {
+            committer = line.slice(10);
+        }
+    }
+    return {
+        oid: object.oid,
+        tree,
+        parents,
+        author,
+        committer,
+        message: messageParts.join('\n\n').trim() || '(no message)',
+        refs: refsByOid.get(object.oid) || []
+    };
+};
+const parseTree = (content) => {
+    const entries = [];
+    let offset = 0;
+    while (offset < content.byteLength) {
+        const modeEnd = content.indexOf(32, offset);
+        if (modeEnd < 0)
+            break;
+        const nameEnd = content.indexOf(0, modeEnd + 1);
+        if (nameEnd < 0 || nameEnd + 21 > content.byteLength)
+            break;
+        entries.push({
+            mode: asciiDecoder.decode(content.subarray(offset, modeEnd)),
+            name: textDecoder.decode(content.subarray(modeEnd + 1, nameEnd)),
+            oid: toHex(content.subarray(nameEnd + 1, nameEnd + 21))
+        });
+        offset = nameEnd + 21;
+    }
+    return entries;
+};
+const isMostlyText = (bytes) => {
+    const sample = bytes.subarray(0, Math.min(bytes.byteLength, 4096));
+    if (!sample.length) {
+        return true;
+    }
+    let printable = 0;
+    for (const byte of sample) {
+        if (byte === 9 || byte === 10 || byte === 13 || (byte >= 32 && byte < 127) || byte >= 128) {
+            printable += 1;
+        }
+    }
+    return printable / sample.length > 0.86;
+};
+const previewBlob = (content) => {
+    if (!isMostlyText(content)) {
+        return `[binary blob: ${content.byteLength} bytes]`;
+    }
+    return textDecoder.decode(content.subarray(0, Math.min(content.byteLength, 12000)));
+};
+const collectTree = (objectMap, treeOid, basePath = '', depth = 0) => {
+    if (!treeOid || depth > 24) {
+        return { treeEntries: [], files: [] };
+    }
+    const treeObject = objectMap.get(treeOid);
+    if ((treeObject === null || treeObject === void 0 ? void 0 : treeObject.kind) !== 'tree' || !treeObject.content) {
+        return { treeEntries: [], files: [] };
+    }
+    const treeEntries = [];
+    const files = [];
+    for (const entry of parseTree(treeObject.content)) {
+        const path = basePath ? `${basePath}/${entry.name}` : entry.name;
+        treeEntries.push({ path, entry });
+        const object = objectMap.get(entry.oid);
+        if ((object === null || object === void 0 ? void 0 : object.kind) === 'tree') {
+            const child = collectTree(objectMap, entry.oid, path, depth + 1);
+            treeEntries.push(...child.treeEntries);
+            files.push(...child.files);
+        }
+        else if ((object === null || object === void 0 ? void 0 : object.kind) === 'blob' && object.content) {
+            files.push({
+                path,
+                oid: entry.oid,
+                size: object.content.byteLength,
+                preview: previewBlob(object.content)
+            });
+        }
+    }
+    return { treeEntries, files };
+};
+const parseBundleModel = async (buffer) => {
+    const bytes = new Uint8Array(buffer);
+    const header = parseHeader(bytes);
+    const pack = await parsePack(bytes, header);
+    const objectMap = new Map(pack.objects.flatMap(object => object.oid ? [[object.oid, object]] : []));
+    const refsByOid = new Map();
+    header.refs.forEach(ref => {
+        refsByOid.set(ref.oid, [...(refsByOid.get(ref.oid) || []), ref.name]);
+    });
+    const commits = pack.objects
+        .map(object => parseCommit(object, refsByOid))
+        .filter((commit) => Boolean(commit));
+    const selectedCommit = header.refs.map(ref => refsByOid.has(ref.oid) ? commits.find(commit => commit.oid === ref.oid) : null)
+        .find(Boolean) || commits[0];
+    const tree = collectTree(objectMap, selectedCommit === null || selectedCommit === void 0 ? void 0 : selectedCommit.tree);
+    return {
+        header,
+        objects: pack.objects,
+        commits,
+        files: tree.files,
+        treeEntries: tree.treeEntries,
+        deltaCount: pack.objects.filter(object => object.deltaKind).length
+    };
+};
+const shortOid = (oid) => oid ? oid.slice(0, 12) : '-';
+const commitTitle = (commit) => commit.message.split(/\r?\n/)[0] || '(no message)';
+const clampZoom = (value) => {
+    return Math.min(2.2, Math.max(0.65, Number(value.toFixed(2))));
+};
+const renderMeta = (documentRef, panel, model) => {
+    const meta = createElement(documentRef, 'div', 'git-bundle-meta');
+    const counts = new Map();
+    model.objects.forEach(object => {
+        counts.set(object.kind, (counts.get(object.kind) || 0) + 1);
+    });
+    const items = [
+        ['Bundle', model.header.signature],
+        ['Refs', String(model.header.refs.length)],
+        ['Commits', String(model.commits.length)],
+        ['Objects', String(model.objects.length)],
+        ['Deltas', String(model.deltaCount)],
+        ['Object format', model.header.objectFormat],
+        ['Object types', Array.from(counts).map(([kind, count]) => `${kind}:${count}`).join(' · ') || '-']
+    ];
+    items.forEach(([label, value]) => {
+        const row = createElement(documentRef, 'div');
+        row.append(createElement(documentRef, 'span', undefined, label), createElement(documentRef, 'strong', undefined, value));
+        meta.appendChild(row);
+    });
+    panel.appendChild(meta);
+    if (model.deltaCount > 0) {
+        panel.appendChild(createElement(documentRef, 'div', 'git-bundle-notice', '当前 bundle 包含 delta 压缩对象。预览器已在浏览器端解析常规 OFS_DELTA / REF_DELTA；若仍有缺失文件，通常是包体过大、对象过多或依赖外部 prerequisite。'));
+    }
+};
+export default async function renderGitBundle(buffer, target, type = 'bundle') {
+    const documentRef = target.ownerDocument || document;
+    const model = await parseBundleModel(buffer);
+    let zoom = 1;
+    const zoomEmitter = createZoomChangeEmitter();
+    const root = createElement(documentRef, 'div', 'git-bundle-viewer');
+    root.dataset.viewerZoomProvider = 'git-bundle';
+    const toolbar = createElement(documentRef, 'div', 'git-bundle-toolbar');
+    toolbar.append(createElement(documentRef, 'span', undefined, type.toUpperCase()), createElement(documentRef, 'strong', undefined, `${model.commits.length} commits · ${model.files.length} files`));
+    const layout = createElement(documentRef, 'div', 'git-bundle-layout');
+    const historyPanel = createElement(documentRef, 'section', 'git-bundle-panel');
+    historyPanel.appendChild(createElement(documentRef, 'h3', undefined, '历史记录'));
+    renderMeta(documentRef, historyPanel, model);
+    const historyList = createElement(documentRef, 'ul', 'git-bundle-list');
+    historyPanel.appendChild(historyList);
+    const treePanel = createElement(documentRef, 'section', 'git-bundle-panel');
+    treePanel.appendChild(createElement(documentRef, 'h3', undefined, '文件树'));
+    const tree = createElement(documentRef, 'div', 'git-bundle-tree');
+    treePanel.appendChild(tree);
+    const filePanel = createElement(documentRef, 'section', 'git-bundle-panel git-bundle-file');
+    const fileHeader = createElement(documentRef, 'div', 'git-bundle-file-header', '选择文件查看内容');
+    const fileCode = createElement(documentRef, 'pre', 'git-bundle-code', '');
+    filePanel.append(fileHeader, fileCode);
+    layout.append(historyPanel, treePanel, filePanel);
+    root.append(toolbar, layout);
+    target.replaceChildren(createStyle(documentRef), root);
+    const renderFiles = (files) => {
+        tree.replaceChildren();
+        if (!files.length) {
+            tree.appendChild(createElement(documentRef, 'div', 'git-bundle-notice', '当前 bundle 的 tree/blob 可能被 delta 压缩，暂未解析到可展开文件。'));
+            fileHeader.textContent = '未解析到文件';
+            fileCode.textContent = '';
+            return;
+        }
+        files.forEach((file, index) => {
+            const button = createElement(documentRef, 'button');
+            button.type = 'button';
+            button.textContent = `${file.path} · ${file.size} B`;
+            button.addEventListener('click', () => {
+                tree.querySelectorAll('button').forEach(item => item.classList.remove('active'));
+                button.classList.add('active');
+                fileHeader.textContent = `${file.path} · ${shortOid(file.oid)}`;
+                fileCode.textContent = file.preview;
+            });
+            tree.appendChild(button);
+            if (index === 0) {
+                button.click();
+            }
+        });
+    };
+    model.commits.forEach((commit, index) => {
+        const button = createElement(documentRef, 'button');
+        button.type = 'button';
+        button.innerHTML = '';
+        button.append(documentRef.createTextNode(commit.refs[0] || commitTitle(commit)), createElement(documentRef, 'small', undefined, `${shortOid(commit.oid)} · ${commitTitle(commit)}`));
+        button.addEventListener('click', () => {
+            historyList.querySelectorAll('button').forEach(item => item.classList.remove('active'));
+            button.classList.add('active');
+            const objectMap = new Map(model.objects.flatMap(object => object.oid ? [[object.oid, object]] : []));
+            const commitTree = collectTree(objectMap, commit.tree);
+            renderFiles(commitTree.files);
+        });
+        historyList.appendChild(button);
+        if (index === 0) {
+            button.click();
+        }
+    });
+    if (!model.commits.length) {
+        historyList.appendChild(createElement(documentRef, 'li', 'git-bundle-notice', '当前 bundle 未解析到 commit 对象，仅展示 refs 和 pack 摘要。'));
+        renderFiles(model.files);
+    }
+    const getZoomState = () => ({
+        scale: zoom,
+        label: `${Math.round(zoom * 100)}%`,
+        canZoomIn: zoom < 2.2,
+        canZoomOut: zoom > 0.65,
+        canReset: zoom !== 1,
+        minScale: 0.65,
+        maxScale: 2.2
+    });
+    const setZoom = (scale) => {
+        zoom = clampZoom(scale);
+        root.style.setProperty('--bundle-font-size', `${13 * zoom}px`);
+        zoomEmitter.emit();
+        return getZoomState();
+    };
+    setZoom(1);
+    registerFileViewerZoomProvider(root, {
+        zoomIn: () => setZoom(zoom + 0.1),
+        zoomOut: () => setZoom(zoom - 0.1),
+        resetZoom: () => setZoom(1),
+        setZoom,
+        getState: getZoomState,
+        subscribe: zoomEmitter.subscribe
+    });
+    return {
+        $el: root,
+        unmount() {
+            unregisterFileViewerZoomProvider(root);
+            target.replaceChildren();
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { type FileRenderHandler, type FileViewerRenderedInstance, type FileViewerRendererPlugin, type RendererDefinition } from '@file-viewer/core';
+export declare const textRendererDefinitions: RendererDefinition[];
+export declare const renderFileViewerCode: FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>;
+export declare const renderFileViewerMarkdown: FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>;
+export declare const textRenderer: FileViewerRendererPlugin<FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>>;
+export default textRenderer;

package/dist/index.js

@@ -0,0 +1,25 @@
+import { DEFAULT_RENDERER_DEFINITIONS, } from '@file-viewer/core';
+const textRendererIds = ['code', 'markdown'];
+const textDefinitions = DEFAULT_RENDERER_DEFINITIONS.filter(definition => textRendererIds.includes(definition.id));
+if (textDefinitions.length !== textRendererIds.length) {
+    throw new Error('@file-viewer/renderer-text could not locate the shared code/markdown format definitions.');
+}
+export const textRendererDefinitions = textDefinitions;
+export const renderFileViewerCode = (buffer, target, type) => import('./code.js').then(({ default: renderCode }) => renderCode(buffer, target, type));
+export const renderFileViewerMarkdown = (buffer, target) => import('./markdown.js').then(({ default: renderMarkdown }) => renderMarkdown(buffer, target));
+export const textRenderer = {
+    id: 'file-viewer-renderer-text',
+    label: 'Flyfish File Viewer text renderer',
+    definitions: textRendererDefinitions,
+    handlers: [
+        {
+            rendererId: 'code',
+            handler: renderFileViewerCode,
+        },
+        {
+            rendererId: 'markdown',
+            handler: renderFileViewerMarkdown,
+        },
+    ],
+};
+export default textRenderer;

package/dist/markdown.d.ts

@@ -0,0 +1,2 @@
+import { type FileViewerRenderedInstance } from '@file-viewer/core';
+export default function renderMarkdown(buffer: ArrayBuffer, target: HTMLDivElement): Promise<FileViewerRenderedInstance>;