@weibaohui/dsh-git-server 0.1.0

package/server/dist/gitx/http.js

@@ -0,0 +1,232 @@
+import * as fsMod from 'node:fs';
+import * as zlib from 'node:zlib';
+import * as path from 'node:path';
+import { conf } from '../conf.js';
+import * as db from '../db/db.js';
+import * as git from './git.js';
+import { authenticateUserByBasic } from '../context.js';
+import * as crypto from 'node:crypto';
+function require_md5hex(s) {
+    return crypto.createHash('md5').update(s).digest('hex');
+}
+const NO_CACHE_HEADERS = {
+    Expires: 'Fri, 01 Jan 1980 00:00:00 GMT',
+    Pragma: 'no-cache',
+    'Cache-Control': 'no-cache, max-age=0, must-revalidate',
+};
+/** Try to handle a git smart-HTTP request; returns false when not a git path. */
+export function handleGitHTTP(req, res, pathname) {
+    const m = /^\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/(.*))?$/.exec(pathname);
+    if (!m)
+        return false;
+    const [, username, rawRepo, rest] = m;
+    if (!rest)
+        return false;
+    // repoName may carry .git / .wiki suffixes
+    let repoName = rawRepo;
+    let isWiki = false;
+    if (repoName.endsWith('.wiki')) {
+        isWiki = true;
+        repoName = repoName.slice(0, -5);
+    }
+    else if (repoName.endsWith('.git')) {
+        repoName = repoName.slice(0, -4);
+        if (repoName.endsWith('.wiki')) {
+            isWiki = true;
+            repoName = repoName.slice(0, -5);
+        }
+    }
+    const action = rest.split('?')[0];
+    // Git LFS: /info/lfs/...
+    const lfsMatch = /^info\/lfs(\/.*)?$/.exec(action);
+    if (lfsMatch) {
+        (async () => {
+            try {
+                const owner = db.getUserByUsername(username);
+                const repo = owner ? db.getRepoByOwnerAndName(owner, repoName) : null;
+                const fsMod = await import('node:fs');
+                if (!owner || !repo || !fsMod.existsSync(isWiki ? repo.WikiPath() : repo.RepoPath())) {
+                    res.statusCode = 404;
+                    res.end('repository does not exist');
+                    return;
+                }
+                const { handleLFS } = await import('../lfsx.js');
+                await handleLFS(req, res, owner, repo, lfsMatch[1] ?? '/');
+            }
+            catch (e) {
+                console.error('[lfs]', e);
+                if (!res.headersSent)
+                    res.statusCode = 500;
+                res.end();
+            }
+        })();
+        return true;
+    }
+    const GIT_ACTIONS = new Set([
+        'info/refs', 'HEAD', 'git-upload-pack', 'git-receive-pack',
+        'objects/info/alternates', 'objects/info/http-alternates', 'objects/info/packs',
+    ]);
+    const isObjectReq = /^objects\/info\/.*/.test(action) ||
+        /^objects\/[0-9a-f]{2}\/[0-9a-f]{38}$/.test(action) ||
+        /^objects\/pack\/pack-[0-9a-f]{40}\.(pack|idx)$/.test(action);
+    if (!GIT_ACTIONS.has(action) && !isObjectReq)
+        return false;
+    const lowerPath = pathname.toLowerCase();
+    (async () => {
+        try {
+            const owner = db.getUserByUsername(username);
+            const repo = owner ? db.getRepoByOwnerAndName(owner, repoName) : null;
+            if (!repo) {
+                res.statusCode = 404;
+                res.end('repository does not exist');
+                return;
+            }
+            const repoDir = isWiki ? repo.WikiPath() : repo.RepoPath();
+            if (!fsMod.existsSync(repoDir)) {
+                res.statusCode = 404;
+                res.end('repository does not exist');
+                return;
+            }
+            // service detection
+            const service = new URL(req.url ?? '/', 'http://internal').searchParams.get('service') ?? '';
+            const isReceive = action === 'git-receive-pack' || service === 'git-receive-pack';
+            const isPull = action === 'info/refs' ? service !== 'git-receive-pack' : action !== 'git-receive-pack';
+            if (conf.disableHTTPGit) {
+                res.statusCode = 403;
+                res.end('The repository\'s HTTP git is disabled');
+                return;
+            }
+            // public repo pull requires no auth (unless REQUIRE_SIGNIN_VIEW)
+            if (!(isPull && !repo.is_private && !conf.requireSigninView)) {
+                const authHeader = String(req.headers.authorization ?? '');
+                const authed = await authenticateUserByBasic(authHeader);
+                if (!authed) {
+                    res.statusCode = 401;
+                    res.setHeader('WWW-Authenticate', 'Basic realm="."');
+                    res.end('Requires authentication');
+                    return;
+                }
+                const mode = db.accessMode(authed.user.id, repo);
+                const need = isPull ? db.AccessMode.READ : db.AccessMode.WRITE;
+                if (mode < need) {
+                    res.statusCode = 403;
+                    res.end('User does not have access to repository');
+                    return;
+                }
+                if (isReceive && repo.is_mirror) {
+                    res.statusCode = 403;
+                    res.end('Mirror repository is read-only');
+                    return;
+                }
+                // stash authed user for post-processing
+                req.__authedUser = authed.user;
+            }
+            for (const [k, v] of Object.entries(NO_CACHE_HEADERS))
+                res.setHeader(k, v);
+            if (action === 'info/refs') {
+                if (service !== 'git-upload-pack' && service !== 'git-receive-pack') {
+                    // dumb protocol: run update-server-info and serve the static file
+                    await git.git(repoDir, 'update-server-info');
+                    const file = path.join(repoDir, 'info', 'refs');
+                    if (fsMod.existsSync(file)) {
+                        res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+                        res.end(fsMod.readFileSync(file));
+                    }
+                    else {
+                        res.statusCode = 404;
+                        res.end();
+                    }
+                    return;
+                }
+                const out = await git.statelessRPC(repoDir, service === 'git-receive-pack' ? 'receive-pack' : 'upload-pack', true, Buffer.alloc(0));
+                res.setHeader('Content-Type', `application/x-${service}-advertisement`);
+                const head = git.pktLine(`# service=${service}\n`) + '0000';
+                res.end(Buffer.concat([Buffer.from(head), out]));
+                return;
+            }
+            if (action === 'git-upload-pack' || action === 'git-receive-pack') {
+                const svc = action === 'git-upload-pack' ? 'upload-pack' : 'receive-pack';
+                const reqContentType = `application/x-git-${svc}-request`;
+                if (String(req.headers['content-type'] ?? '') !== reqContentType) {
+                    res.statusCode = 401;
+                    res.end();
+                    return;
+                }
+                let body = await readBody(req);
+                if (String(req.headers['content-encoding'] ?? '') === 'gzip') {
+                    body = zlib.gunzipSync(body);
+                }
+                res.setHeader('Content-Type', `application/x-${svc}-result`);
+                if (svc === 'receive-pack') {
+                    // post-processing runs via delegate hooks (env flows into them)
+                    const out = await git.statelessRPC(repoDir, svc, false, body, {
+                        GOGS_AUTH_USER_ID: String(req.__authedUser?.id ?? 0),
+                        GOGS_AUTH_USER_NAME: String(req.__authedUser?.name ?? ''),
+                        GOGS_AUTH_USER_EMAIL: String(req.__authedUser?.email ?? ''),
+                        GOGS_REPO_OWNER_NAME: String(owner.name),
+                        GOGS_REPO_OWNER_SALT_MD5: require_md5hex(`${owner.name}${owner.salt ?? ''}`),
+                        GOGS_REPO_ID: String(repo.id),
+                        GOGS_REPO_NAME: String(repo.name),
+                        GOGS_REPO_CUSTOM_HOOKS_PATH: path.join(repoDir, 'custom_hooks'),
+                    });
+                    res.end(out);
+                }
+                else {
+                    const out = await git.statelessRPC(repoDir, svc, false, body);
+                    res.end(out);
+                }
+                return;
+            }
+            // static object serving (dumb protocol)
+            const safe = path.normalize(action).replace(/^(\.\.[/\\])+/, '');
+            const file = path.join(repoDir, safe);
+            if (fsMod.existsSync(file) && fsMod.statSync(file).isFile()) {
+                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+                res.setHeader('Cache-Control', 'public, max-age=31536000');
+                res.end(fsMod.readFileSync(file));
+                return;
+            }
+            res.statusCode = 404;
+            res.end();
+        }
+        catch (e) {
+            console.error('[git http]', e);
+            if (!res.headersSent)
+                res.statusCode = 500;
+            res.end();
+        }
+    })();
+    return true;
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (d) => chunks.push(d));
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+function parseRefUpdates(body) {
+    // pkt-line stream: 4-hex len lines "old new ref\0capabilities" until 0000
+    const updates = [];
+    let pos = 0;
+    while (pos + 4 <= body.length) {
+        const lenStr = body.toString('utf8', pos, pos + 4);
+        if (!/^[0-9a-f]{4}$/.test(lenStr))
+            break;
+        const len = parseInt(lenStr, 16);
+        if (len === 0)
+            break;
+        let line = body.toString('utf8', pos + 4, pos + len);
+        pos += len;
+        const nul = line.indexOf('\0');
+        if (nul >= 0)
+            line = line.slice(0, nul);
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 3 && /^[0-9a-f]{40}$/.test(parts[0]) && /^[0-9a-f]{40}$/.test(parts[1])) {
+            updates.push({ old: parts[0], new: parts[1], ref: parts[2] });
+        }
+    }
+    return updates;
+}
+//# sourceMappingURL=http.js.map

package/server/dist/gitx/paths.js

@@ -0,0 +1,28 @@
+// Repository disk layout, byte-compatible with gogs:
+//   {ROOT}/{owner lowercase}/{repo lowercase}.git
+//   {ROOT}/{owner lowercase}/{repo lowercase}.wiki.git
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { conf } from '../conf.js';
+/** pathx.Clean: prevent path traversal, collapse separators */
+export function cleanPath(name) {
+    let n = name.replace(/\\/g, '/');
+    n = path.posix.normalize(n);
+    n = n.replace(/^(\.\.(\/|$))+/, '');
+    if (n.startsWith('/'))
+        n = n.slice(1);
+    return n;
+}
+export function userPath(username) {
+    return path.join(conf.repositoryRoot, cleanPath(username.toLowerCase()));
+}
+export function repoPath(username, repoName) {
+    return path.join(userPath(username), cleanPath(repoName.toLowerCase()) + '.git');
+}
+export function wikiPath(username, repoName) {
+    return path.join(userPath(username), cleanPath(repoName.toLowerCase()) + '.wiki.git');
+}
+export function isRepositoryExist(username, repoName) {
+    return fs.existsSync(repoPath(username, repoName));
+}
+//# sourceMappingURL=paths.js.map

package/server/dist/gitx/service.js

@@ -0,0 +1,251 @@
+// Repository lifecycle service: create (bare init), fork, wiki init, and the
+// push-update pipeline that gogs runs via delegate hooks + tasks/trigger.
+import * as fs from 'node:fs';
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+import { conf } from '../conf.js';
+import * as db from '../db/db.js';
+import * as git from './git.js';
+import { userPath } from './paths.js';
+const EMPTY_SHA = '0000000000000000000000000000000000000000';
+/** ComposeHookEnvs equivalent for local (file-remote) pushes. */
+export function composeHookEnv(doer, repo, ownerOverride) {
+    const ownerName = ownerOverride ?? repo.OwnerName();
+    const salt = repo.owner?.salt ?? '';
+    return {
+        SSH_ORIGINAL_COMMAND: '1',
+        GOGS_AUTH_USER_ID: String(doer?.id ?? 0),
+        GOGS_AUTH_USER_NAME: String(doer?.name ?? ''),
+        GOGS_AUTH_USER_EMAIL: String(doer?.email ?? ''),
+        GOGS_REPO_OWNER_NAME: ownerName,
+        GOGS_REPO_OWNER_SALT_MD5: crypto.createHash('md5').update(`${ownerName}${salt}`).digest('hex'),
+        GOGS_REPO_ID: String(repo.id),
+        GOGS_REPO_NAME: String(repo.name),
+        GOGS_REPO_CUSTOM_HOOKS_PATH: path.join(repo.RepoPath(), 'custom_hooks'),
+    };
+}
+/** createDelegateHooks equivalent: since push handling runs in-process after
+ * receive-pack, delegate hooks are only written for SSH/custom compat. */
+export function createDelegateHooks(repoPath) {
+    const hooksDir = path.join(repoPath, 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    const dist = path.join(conf.workDir, 'dist', 'index.js');
+    const srcCli = path.join(conf.workDir, 'node_modules', '.bin', 'tsx');
+    const srcEntry = path.join(conf.workDir, 'src', 'index.ts');
+    const script = (name, args) => {
+        let runner;
+        if (fs.existsSync(dist)) {
+            runner = `${process.execPath} "${dist}"`;
+        }
+        else {
+            // NOTE: absolute node + tsx CLI entry (ssh sessions have a minimal PATH);
+            // config passes via env — `tsx` consumes --config as its own flag
+            const tsxCli = path.join(conf.workDir, 'node_modules', 'tsx', 'dist', 'cli.mjs');
+            runner = `GOGS_CUSTOM_CONF='${conf.customConf}' "${process.execPath}" "${tsxCli}" "${srcEntry}"`;
+        }
+        return `#!/usr/bin/env bash\n${runner} hook ${name} ${args}\n`;
+    };
+    fs.writeFileSync(path.join(hooksDir, 'pre-receive'), script('pre-receive', ''), { mode: 0o755 });
+    fs.writeFileSync(path.join(hooksDir, 'update'), script('update', '$1 $2 $3'), { mode: 0o755 });
+    fs.writeFileSync(path.join(hooksDir, 'post-receive'), script('post-receive', ''), { mode: 0o755 });
+}
+export async function initRepository(repo, opts = {}) {
+    const repoDir = repo.RepoPath();
+    fs.mkdirSync(userPath(repo.OwnerName()), { recursive: true });
+    await git.initBare(repoDir, conf.defaultBranch);
+    createDelegateHooks(repoDir);
+    if (opts.autoInit) {
+        // clone to temp dir, seed files, push
+        const tmpDir = path.join(conf.appDataPath, 'tmp', 'init-' + Date.now() + '-' + Math.random().toString(36).slice(2));
+        fs.mkdirSync(tmpDir, { recursive: true });
+        try {
+            await git.git(process.cwd(), 'clone', repoDir, tmpDir);
+            let hasContent = false;
+            const files = [];
+            if (opts.readme) {
+                files.push(['README.md', renderReadmeTemplate(opts.readme, repo)]);
+                hasContent = true;
+            }
+            if (opts.gitignores) {
+                const gi = readVendorTemplate('gitignore', opts.gitignores);
+                if (gi) {
+                    files.push(['.gitignore', gi]);
+                    hasContent = true;
+                }
+            }
+            if (opts.license) {
+                const lic = readVendorTemplate('license', opts.license);
+                if (lic) {
+                    files.push(['LICENSE', lic]);
+                    hasContent = true;
+                }
+            }
+            for (const [name, content] of files) {
+                fs.writeFileSync(path.join(tmpDir, name), content);
+            }
+            if (hasContent) {
+                const author = opts.doer ? `${opts.doer.name} <${opts.doer.email}>` : 'Gogs <gogs@fake.local>';
+                await git.git(tmpDir, 'add', '--all');
+                await git.git(tmpDir, 'commit', `--author=${author}`, '-m', 'Initial commit');
+                // local remotes inherit the push process env — hooks receive the context
+                const hookEnv = composeHookEnv(opts.doer, repo);
+                await git.runGit(tmpDir, ['push', 'origin', `master:${conf.defaultBranch}`], 120000, hookEnv);
+                if (conf.defaultBranch !== 'master') {
+                    await git.git(repoDir, 'symbolic-ref', 'HEAD', `refs/heads/${conf.defaultBranch}`);
+                }
+                await git.updateServerInfo(repoDir);
+            }
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    }
+    await git.updateServerInfo(repoDir);
+}
+function renderReadmeTemplate(name, repo) {
+    const tpl = readVendorTemplate('readme', name);
+    if (!tpl)
+        return `# ${repo.name}\n\n${repo.description ?? ''}\n`;
+    return tpl
+        .replace(/\{\{Filename\}\}/g, 'README.md')
+        .replace(/\{\{Description\}\}/g, repo.description ?? '')
+        .replace(/\{\{Name\}\}/g, repo.name);
+}
+export function readVendorTemplate(kind, name) {
+    const file = path.join(conf.workDir, 'vendored-conf', kind, name);
+    if (!fs.existsSync(file))
+        return null;
+    return fs.readFileSync(file, 'utf8');
+}
+export function listVendorTemplates(kind) {
+    const dir = path.join(conf.workDir, 'vendored-conf', kind);
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir).filter((f) => !f.startsWith('.'));
+}
+/** git clone --bare fork. */
+export async function forkRepository(base, fork) {
+    fs.mkdirSync(userPath(fork.OwnerName()), { recursive: true });
+    await git.git(process.cwd(), 'clone', '--bare', base.RepoPath(), fork.RepoPath());
+    await git.updateServerInfo(fork.RepoPath());
+    createDelegateHooks(fork.RepoPath());
+}
+/** gogs PushUpdate equivalent, invoked in-process after receive-pack. */
+export async function processPushUpdate(opts) {
+    const repoDir = opts.repo.RepoPath();
+    const { commitRepoAction, pushTagAction, ActionType } = await import('../db/actions.js');
+    await git.updateServerInfo(repoDir);
+    const { size } = await git.countObjects(repoDir);
+    // upstream RepositoriesStore.Touch: any push clears the bare flag
+    db.updateRepoColumns(opts.repo.id, { size, is_bare: 0 });
+    if (opts.refName.startsWith('refs/tags/')) {
+        const tagName = opts.refName.slice('refs/tags/'.length);
+        if (opts.newSha === EMPTY_SHA) {
+            const { deleteBranchAction } = await import('../db/actions.js');
+            // tag deletion action (op 18)
+            await deleteBranchAction(opts.doer, opts.repo, tagName);
+            return;
+        }
+        await pushTagAction(opts.doer, opts.repo, tagName);
+        return;
+    }
+    const branch = opts.refName.replace('refs/heads/', '');
+    if (opts.newSha === EMPTY_SHA) {
+        const { deleteBranchAction } = await import('../db/actions.js');
+        deleteBranchAction(opts.doer, opts.repo, branch);
+        db.db().prepare('UPDATE repository SET is_bare = CASE WHEN ? = default_branch THEN 1 ELSE is_bare END WHERE id = ?').run(opts.repo.default_branch, opts.repo.id);
+        return;
+    }
+    let commits = [];
+    if (opts.oldSha === EMPTY_SHA) {
+        // new branch: take up to 10 commits (new + 9 ancestors).
+        // upstream fires only the commit-push action here — no separate "create" event.
+        const head = await git.catFileCommit(repoDir, opts.newSha);
+        const ancestors = await commitsList(repoDir, opts.newSha, 9);
+        commits = [head, ...ancestors];
+    }
+    else {
+        commits = await git.commitsAfter(repoDir, opts.oldSha, opts.newSha);
+    }
+    await commitRepoAction(opts.doer, opts.repo, opts.refName, {
+        TotalCommits: commits.length,
+        Len: commits.length,
+        Commits: commits.map((c) => ({
+            Sha1: c.id,
+            Message: c.message,
+            AuthorEmail: c.author.email,
+        })),
+        Compares: commits.length > 0 ? [{ numCommits: commits.length }] : [],
+    });
+    // issue reference from commit messages (#123)
+    try {
+        await processCommitIssueRefs(opts.repo, commits, opts.doer);
+    }
+    catch (e) {
+        console.error('[push update] issue refs:', e);
+    }
+}
+async function commitsList(repoDir, rev, maxCount) {
+    const out = await git.gitOK(repoDir, 'log', `--max-count=${maxCount}`, '--pretty=format:%H', '--end-of-options', rev, '--');
+    if (!out)
+        return [];
+    const shas = out.toString().trim().split('\n').filter(Boolean);
+    const commits = [];
+    for (const sha of shas) {
+        try {
+            commits.push(await git.catFileCommit(repoDir, sha));
+        }
+        catch {
+            // ignore
+        }
+    }
+    return commits;
+}
+/** Commit messages referencing #123 close/mention issues like gogs update.go. */
+async function processCommitIssueRefs(repo, commits, doer) {
+    for (const commit of commits) {
+        const matches = [...commit.message.matchAll(/#(\d+)/g)];
+        for (const m of matches) {
+            const index = Number(m[1]);
+            const issue = db.getIssueByIndex(repo.id, index);
+            if (!issue || issue.is_closed)
+                continue;
+            // upstream matches the keyword anywhere in the message (no word-start anchor)
+            const closes = /(close[sd]?|fix(?:e[sd]?)?|resolve[sd]?)[:\s]+#\d+/i.test(commit.message);
+            if (closes) {
+                db.updateIssueColumns(issue.id, { is_closed: 1 });
+                db.db().prepare('INSERT INTO comment (type, poster_id, issue_id, content, created_unix, updated_unix, commit_sha) VALUES (2,?,?,?,?,?,?)')
+                    .run(doer.id, issue.id, '', Math.floor(Date.now() / 1000), Math.floor(Date.now() / 1000), commit.id);
+                db.refreshIssueCounts(repo.id);
+            }
+        }
+    }
+}
+/** wiki repository helpers */
+export async function initWiki(repoDir) {
+    if (fs.existsSync(repoDir))
+        return;
+    fs.mkdirSync(path.dirname(repoDir), { recursive: true });
+    await git.initBare(repoDir, 'master');
+    createDelegateHooks(repoDir);
+}
+export function wikiBranch(repoDir) {
+    // main if exists, else master
+    const main = fs.existsSync(path.join(repoDir, 'refs', 'heads', 'main')) ||
+        fs.existsSync(path.join(repoDir, 'packed-refs')) &&
+            fs.readFileSync(path.join(repoDir, 'packed-refs'), 'utf8').includes('refs/heads/main');
+    return main ? 'main' : 'master';
+}
+export function toWikiPageName(name) {
+    let n = name;
+    try {
+        n = decodeURIComponent(name);
+    }
+    catch {
+        // keep raw
+    }
+    n = n.replace(/\\/g, '/').replace(/\/+/g, ' ').replace(/^\/|\/$/g, '');
+    n = n.replaceAll('/', ' ').trim();
+    return n || 'Home';
+}
+//# sourceMappingURL=service.js.map

package/server/dist/gosprintf.js

@@ -0,0 +1,167 @@
+// goSprintf：Go fmt.Sprintf 子集，仅供 i18n 翻译插值使用。
+// 从 gotemplate/engine.ts 抽出的自包含实现（模板引擎本体已随网页 UI 一并裁撤）。
+// SafeHTML 兼容：不 import engine 的 SafeHTML 类，改为结构判断（{ html: string }），
+// 避免反向依赖整个模板引擎。
+export function isTrue(v) {
+    if (v == null || v === false)
+        return false;
+    if (typeof v === 'number')
+        return v !== 0 && !Number.isNaN(v) ? true : false;
+    if (typeof v === 'string' || v instanceof String)
+        return String(v).length > 0;
+    if (Array.isArray(v))
+        return v.length > 0;
+    if (v instanceof Map)
+        return v.size > 0;
+    if (typeof v === 'object')
+        return Object.keys(v).length > 0 || Object.getPrototypeOf(v) !== Object.prototype;
+    return true;
+}
+function printPlain(v) {
+    // 用户拍板：嵌套 nil（容器整体打印时）也渲染空串，偏离 Go fmt 的 '<nil>'
+    if (v == null)
+        return '';
+    // SafeHTML 结构判断：{ html: string } 直接取可信 HTML，不转义
+    if (typeof v === 'object' && typeof v.html === 'string')
+        return v.html;
+    if (typeof v === 'string' || v instanceof String)
+        return String(v);
+    if (typeof v === 'number')
+        return fmtNumber(v);
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    if (Array.isArray(v))
+        return '[' + v.map((x) => printPlain(x)).join(' ') + ']';
+    if (v instanceof Map) {
+        const keys = Array.from(v.keys()).map(String).sort();
+        return 'map[' + keys.map((k) => `${k}:${printPlain(v.get(k))}`).join(' ') + ']';
+    }
+    if (typeof v === 'object') {
+        // Go struct: {v1 v2}
+        return '{' + Object.values(v).map((x) => printPlain(x)).join(' ') + '}';
+    }
+    return String(v);
+}
+function fmtNumber(n) {
+    if (Number.isInteger(n))
+        return String(n);
+    return String(n);
+}
+export function goSprintf(format, args) {
+    let argIdx = 0;
+    let out = '';
+    let i = 0;
+    while (i < format.length) {
+        const c = format[i];
+        if (c !== '%') {
+            out += c;
+            i++;
+            continue;
+        }
+        // positional form: %[N]<verb> — sets the argument index for this verb only
+        const posMatch = /^%\[(\d+)\]/.exec(format.slice(i));
+        let positional = false;
+        if (posMatch) {
+            argIdx = Number(posMatch[1]) - 1;
+            i += posMatch[0].length;
+            positional = true;
+        }
+        // parse verb: %[-+ #0]*[0-9]*(\.[0-9]+)?[bdeEfFgGoOqxXscvU%]
+        let j = positional ? i : i + 1;
+        let flags = '';
+        while (j < format.length && /[-+ #0]/.test(format[j])) {
+            flags += format[j];
+            j++;
+        }
+        let width = '';
+        while (j < format.length && /[0-9]/.test(format[j])) {
+            width += format[j];
+            j++;
+        }
+        let prec = '';
+        if (format[j] === '.') {
+            j++;
+            while (j < format.length && /[0-9]/.test(format[j])) {
+                prec += format[j];
+                j++;
+            }
+            if (prec === '')
+                prec = '0';
+        }
+        const verb = format[j];
+        if (verb === undefined) {
+            out += '%';
+            break;
+        }
+        if (verb === '%') {
+            out += '%';
+            i = j + 1;
+            continue;
+        }
+        const arg = args[argIdx];
+        argIdx = argIdx + 1;
+        out += formatVerb(verb, flags, width, prec, arg);
+        i = j + 1;
+    }
+    return out;
+}
+function formatVerb(verb, flags, width, prec, arg) {
+    let s;
+    switch (verb) {
+        case 's':
+            s = arg == null ? '%!s(<nil>)' : printPlain(arg);
+            if (prec !== '')
+                s = s.slice(0, Number(prec));
+            break;
+        case 'd': {
+            const n = Math.trunc(Number(arg));
+            if (Number.isNaN(n))
+                s = `%!d(${printPlain(arg)})`;
+            else
+                s = String(n);
+            break;
+        }
+        case 'x':
+            s = typeof arg === 'string' ? Buffer.from(arg, 'utf8').toString('hex') : (Number(arg) >>> 0).toString(16);
+            break;
+        case 'X':
+            s = typeof arg === 'string' ? Buffer.from(arg, 'utf8').toString('hex').toUpperCase() : (Number(arg) >>> 0).toString(16).toUpperCase();
+            break;
+        case 'f':
+        case 'F': {
+            const n = Number(arg);
+            s = n.toFixed(prec === '' ? 6 : Number(prec));
+            break;
+        }
+        case 'g':
+            s = String(Number(arg));
+            break;
+        case 'q':
+            s = JSON.stringify(printPlain(arg)) ?? '""';
+            break;
+        case 'v':
+            s = printPlain(arg);
+            break;
+        case 't':
+            s = String(isTrue(arg));
+            break;
+        default:
+            s = `%!${verb}(${printPlain(arg)})`;
+    }
+    // width padding
+    if (width) {
+        const w = Number(width);
+        if (s.length < w) {
+            if (flags.includes('-'))
+                s = s.padEnd(w);
+            else if (flags.includes('0') && (verb === 'd' || verb === 'f')) {
+                const neg = s.startsWith('-');
+                s = neg ? '-' + s.slice(1).padStart(w - (neg ? 1 : 0), '0') : s.padStart(w, '0');
+            }
+            else
+                s = s.padStart(w);
+        }
+    }
+    return s;
+}
+//# sourceMappingURL=gosprintf.js.map