repoburg 1.3.255 → 1.3.256

package/daemon/dist/tabtape/config.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TABTAPE_MOUNT = exports.TABTAPE_VERSION = void 0;
+exports.parseSize = parseSize;
+exports.formatSize = formatSize;
+exports.defaultDataDir = defaultDataDir;
+exports.loadConfig = loadConfig;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const redact_1 = require("./redact");
+/** Version of the tabtape component (extension, replay UI, server API). */
+exports.TABTAPE_VERSION = '0.5.0';
+/** URL prefix of everything tabtape serves on the daemon's port. */
+exports.TABTAPE_MOUNT = '/tabtape';
+const UNITS = [
+    ['GIB', 1 << 30],
+    ['MIB', 1 << 20],
+    ['KIB', 1 << 10],
+    ['GB', 1 << 30],
+    ['MB', 1 << 20],
+    ['KB', 1 << 10],
+    ['G', 1 << 30],
+    ['M', 1 << 20],
+    ['K', 1 << 10],
+    ['B', 1],
+];
+/**
+ * Parses sizes like "500MB", "16M", "1GiB" or "4096". Units are binary:
+ * 1MB = 1024*1024 bytes.
+ */
+function parseSize(s) {
+    let t = s.trim().toUpperCase();
+    let mult = 1;
+    for (const [suffix, m] of UNITS) {
+        if (t.endsWith(suffix)) {
+            t = t.slice(0, -suffix.length).trim();
+            mult = m;
+            break;
+        }
+    }
+    const n = t === '' ? NaN : Number(t);
+    if (!Number.isFinite(n))
+        throw new Error(`invalid size "${s}"`);
+    if (n <= 0)
+        throw new Error('size must be positive');
+    return Math.trunc(n * mult);
+}
+function formatSize(n) {
+    if (n >= 1 << 30)
+        return `${(n / (1 << 30)).toFixed(1)}GB`;
+    if (n >= 1 << 20)
+        return `${(n / (1 << 20)).toFixed(1)}MB`;
+    if (n >= 1 << 10)
+        return `${(n / (1 << 10)).toFixed(1)}KB`;
+    return `${n}B`;
+}
+/** Default data directory: ~/.repoburg/tabtape (next to the daemon's other state). */
+function defaultDataDir(home = os_1.default.homedir()) {
+    return path_1.default.join(home, '.repoburg', 'tabtape');
+}
+/**
+ * Reads the configuration from the environment:
+ *   REPOBURG_TABTAPE_DATA             data directory (default ~/.repoburg/tabtape)
+ *   REPOBURG_TABTAPE_MAX_SIZE         ring buffer cap (default 500MB)
+ *   REPOBURG_TABTAPE_SEGMENT_SIZE     segment size (default 16MB)
+ *   REPOBURG_TABTAPE_COMPRESS         gzip (default) or off
+ *   REPOBURG_TABTAPE_BUFFER_MAX_SIZE  buffer mode space (default 100MB)
+ *   REPOBURG_TABTAPE_REDACT_HEADERS   headers hidden in MCP results and exports
+ *   REPOBURG_TABTAPE_MCP_SHOW_SECRETS 1 shows those headers to MCP clients
+ *   REPOBURG_TABTAPE_MCP_TOKEN        bearer token required by /tabtape/mcp
+ */
+function loadConfig(env = process.env, home = os_1.default.homedir()) {
+    const get = (key, fallback) => {
+        const v = env[key];
+        return v !== undefined && v !== '' ? v : fallback;
+    };
+    const size = (key, fallback) => {
+        try {
+            return parseSize(get(key, fallback));
+        }
+        catch (err) {
+            throw new Error(`${key}: ${err.message}`);
+        }
+    };
+    const maxBytes = size('REPOBURG_TABTAPE_MAX_SIZE', '500MB');
+    let segmentBytes = size('REPOBURG_TABTAPE_SEGMENT_SIZE', '16MB');
+    const bufferBytes = size('REPOBURG_TABTAPE_BUFFER_MAX_SIZE', '100MB');
+    if (segmentBytes > maxBytes / 4) {
+        segmentBytes = Math.max(Math.floor(maxBytes / 4), 1); // keep eviction granular for small caps
+    }
+    const compress = get('REPOBURG_TABTAPE_COMPRESS', 'gzip');
+    if (compress !== 'off' && compress !== 'gzip') {
+        throw new Error(`REPOBURG_TABTAPE_COMPRESS: "${compress}" is neither "off" nor "gzip"`);
+    }
+    return {
+        dataDir: get('REPOBURG_TABTAPE_DATA', defaultDataDir(home)),
+        maxBytes,
+        segmentBytes,
+        compress,
+        bufferBytes,
+        redactHeaders: get('REPOBURG_TABTAPE_REDACT_HEADERS', redact_1.DEFAULT_REDACT_HEADERS),
+        showSecrets: env.REPOBURG_TABTAPE_MCP_SHOW_SECRETS === '1',
+        mcpToken: env.REPOBURG_TABTAPE_MCP_TOKEN ?? '',
+    };
+}

package/daemon/dist/tabtape/e2e-server.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Test harness: serves tabtape alone, mounted exactly as the daemon mounts
+ * it, on an address of its own — for tabtape/e2e and UI development without
+ * the daemon (whose port, pm2 state and data belong to the real install).
+ *
+ *   node daemon/dist/tabtape/e2e-server.js --addr 127.0.0.1:7787 --data <dir>
+ *     [--max-size 500MB] [--segment-size 16MB] [--compress gzip|off]
+ *     [--buffer-max-size 100MB] [--redact-headers a,b] [--mcp-show-secrets]
+ *
+ * Production never runs this: the daemon serves tabtape on its own port.
+ */
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const index_1 = require("./index");
+const FLAGS = {
+    data: 'REPOBURG_TABTAPE_DATA',
+    'max-size': 'REPOBURG_TABTAPE_MAX_SIZE',
+    'segment-size': 'REPOBURG_TABTAPE_SEGMENT_SIZE',
+    compress: 'REPOBURG_TABTAPE_COMPRESS',
+    'buffer-max-size': 'REPOBURG_TABTAPE_BUFFER_MAX_SIZE',
+    'redact-headers': 'REPOBURG_TABTAPE_REDACT_HEADERS',
+};
+function parseArgs(argv) {
+    let addr = '127.0.0.1:7787';
+    const env = { ...process.env };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const m = /^--?([a-z-]+)(?:=(.*))?$/.exec(arg);
+        if (!m)
+            throw new Error(`unexpected argument ${arg}`);
+        const name = m[1];
+        if (name === 'mcp-show-secrets') {
+            env.REPOBURG_TABTAPE_MCP_SHOW_SECRETS = '1';
+            continue;
+        }
+        const value = m[2] ?? argv[++i];
+        if (value === undefined)
+            throw new Error(`--${name} needs a value`);
+        if (name === 'addr')
+            addr = value;
+        else if (FLAGS[name])
+            env[FLAGS[name]] = value;
+        else
+            throw new Error(`unknown flag --${name}`);
+    }
+    return { addr, env };
+}
+async function main() {
+    const { addr, env } = parseArgs(process.argv.slice(2));
+    const i = addr.lastIndexOf(':');
+    const host = i > 0 ? addr.slice(0, i).replace(/^\[|\]$/g, '') : '127.0.0.1';
+    const port = Number(i >= 0 ? addr.slice(i + 1) : addr);
+    const config = (0, config_1.loadConfig)(env);
+    const baseHost = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host.includes(':') ? `[${host}]` : host;
+    const tabtape = (0, index_1.createTabtape)({
+        baseURL: `http://${baseHost}:${port}/tabtape`,
+        uiDist: (0, index_1.resolveTabtapeUiDist)(path_1.default.join(__dirname, '..')),
+        config,
+    });
+    const app = (0, express_1.default)();
+    app.use(tabtape.mount, tabtape.router);
+    app.use((_req, res) => {
+        res.status(404).type('text/plain').send(`tabtape is served under ${tabtape.mount}/\n`);
+    });
+    const server = http_1.default.createServer(app);
+    server.on('upgrade', (req, socket, head) => {
+        if (tabtape.handlesUpgrade(req))
+            tabtape.handleUpgrade(req, socket, head);
+        else
+            socket.destroy();
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, host, resolve);
+    });
+    console.log(`tabtape test server listening on http://${baseHost}:${port}/tabtape/ (data: ${config.dataDir})`);
+    const shutdown = async () => {
+        server.close();
+        await tabtape.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+}
+main().catch((err) => {
+    console.error('tabtape test server:', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/daemon/dist/tabtape/errors.js

@@ -0,0 +1,77 @@
+"use strict";
+/** Error types shared by the tabtape store, buffers and queries. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoViewerError = exports.EmptyRangeError = exports.BufferEmptyError = exports.BufferNotFoundError = exports.GoneError = exports.RecordError = exports.InvalidIDError = exports.NotFoundError = void 0;
+exports.isNotExist = isNotExist;
+exports.errorMessage = errorMessage;
+/** A session that does not exist (or was deleted by the ring buffer). */
+class NotFoundError extends Error {
+    constructor(message = 'session not found') {
+        super(message);
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+/** An id that is unsafe as a directory name. */
+class InvalidIDError extends Error {
+    constructor() {
+        super('invalid session id');
+        this.name = 'InvalidIDError';
+    }
+}
+exports.InvalidIDError = InvalidIDError;
+/** A record line that cannot be stored. */
+class RecordError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RecordError';
+    }
+}
+exports.RecordError = RecordError;
+/** A line whose segment was deleted by the ring buffer after a view was built. */
+class GoneError extends Error {
+    constructor() {
+        super('record deleted by the ring buffer');
+        this.name = 'GoneError';
+    }
+}
+exports.GoneError = GoneError;
+/** An unknown buffer (buffer mode). */
+class BufferNotFoundError extends Error {
+    constructor() {
+        super('buffer not found');
+        this.name = 'BufferNotFoundError';
+    }
+}
+exports.BufferNotFoundError = BufferNotFoundError;
+/** A buffer that holds nothing to save yet. */
+class BufferEmptyError extends Error {
+    constructor() {
+        super('the buffer is empty');
+        this.name = 'BufferEmptyError';
+    }
+}
+exports.BufferEmptyError = BufferEmptyError;
+/** A from/to range whose end is not after its start. */
+class EmptyRangeError extends Error {
+    constructor() {
+        super('empty range: to must be after from');
+        this.name = 'EmptyRangeError';
+    }
+}
+exports.EmptyRangeError = EmptyRangeError;
+/** The offline viewer that HTML exports embed was not built. */
+class NoViewerError extends Error {
+    constructor() {
+        super('the export viewer is not built: run npm run build in tabtape/');
+        this.name = 'NoViewerError';
+    }
+}
+exports.NoViewerError = NoViewerError;
+/** Node's "no such file or directory". */
+function isNotExist(err) {
+    return err?.code === 'ENOENT';
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/daemon/dist/tabtape/export/export.js

@@ -0,0 +1,331 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeExport = writeExport;
+/**
+ * Writes a recording as one self-contained HTML file: the offline viewer
+ * (built from tabtape/ui, see vite.export.config.ts) with the session's lines
+ * embedded as gzip + base64. The file opens from disk in any current browser;
+ * images and fonts still load from the recorded site.
+ *
+ * The file is streamed: lines are read in file order, compressed, encoded and
+ * handed to the sink in chunks of tens of kilobytes, waiting whenever the
+ * sink returns a promise. A session of any size exports in bounded memory.
+ */
+const zlib_1 = __importDefault(require("zlib"));
+const errors_1 = require("../errors");
+const reader_1 = require("../query/reader");
+const types_1 = require("../query/types");
+/** Uncompressed bytes handed to gzip at once. */
+const BATCH_BYTES = 64 * 1024;
+/** Compressed bytes collected before they are encoded and written. */
+const FLUSH_BYTES = 48 * 1024;
+/** Beyond any timestamp: an open end of the range. */
+const FAR = 2 ** 62;
+/**
+ * Writes the self-contained HTML file for v to the sink; returns the number
+ * of bytes written. Throws NoViewerError when assets.js is empty. Errors of
+ * the sink or of reading the session are thrown as they are.
+ */
+async function writeExport(sink, v, assets, opts) {
+    const js = bytesOf(assets.js);
+    if (js.length === 0)
+        throw new errors_1.NoViewerError();
+    const now = opts.now ?? Date.now;
+    const out = new Counter(sink);
+    const s = v.session;
+    const redacted = opts.secrets ? [] : opts.redact.list();
+    const [from, to] = selectLines(v, opts);
+    const optFrom = opts.from ?? 0;
+    const optTo = opts.to ?? 0;
+    const meta = {
+        id: s.id,
+        ...(s.title ? { title: s.title } : {}),
+        ...(s.url ? { url: s.url } : {}),
+        startedAt: s.startedAt,
+        ...(s.userAgent ? { userAgent: s.userAgent } : {}),
+        ...(s.truncated ? { truncated: true } : {}),
+        exportedAt: now(),
+        version: opts.version,
+        ...(redacted.length > 0 ? { redactedHeaders: redacted } : {}),
+        ...(opts.stripBodies ? { bodiesRemoved: true } : {}),
+        ...(opts.stripConsoleArgs ? { consoleArgsRemoved: true } : {}),
+        ...(optFrom > 0 || optTo > 0 ? { range: { from: Math.max(optFrom, 0), to: v.offset(to) } } : {}),
+    };
+    const title = s.title || s.id;
+    await out.put('<!doctype html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n' +
+        '<meta name="viewport" content="width=device-width, initial-scale=1">\n' +
+        `<meta name="generator" content="tabtape ${escapeHTML(opts.version)}">\n` +
+        `<title>${escapeHTML(title)} · tabtape recording</title>\n<style>`);
+    await out.put(escapeClose(bytesOf(assets.css), STYLE_CLOSE));
+    await out.put('</style>\n</head>\n<body>\n' +
+        '<div id="root"><div class="loading"><div class="spinner"></div>Opening the recording…</div></div>\n' +
+        `<script id="tabtape-meta" type="application/json">${scriptJSON(meta)}</script>\n` +
+        '<script id="tabtape-data" type="application/octet-stream">');
+    const data = new EmbeddedData((b) => out.put(b));
+    try {
+        await v.scan((l, raw) => (included(l, from, to) ? data.write(transform(l, raw, opts)) : undefined));
+        await data.end();
+    }
+    catch (err) {
+        data.destroy();
+        throw err;
+    }
+    await out.put('</script>\n<script>');
+    await out.put(escapeClose(js, SCRIPT_CLOSE));
+    await out.put('</script>\n</body>\n</html>\n');
+    return out.n;
+}
+/** Counts what the sink accepted and waits when it asks to. */
+class Counter {
+    constructor(sink) {
+        this.sink = sink;
+        this.n = 0;
+    }
+    async put(chunk) {
+        const b = typeof chunk === 'string' ? Buffer.from(chunk, 'utf8') : chunk;
+        if (b.length === 0)
+            return;
+        const pending = this.sink(b);
+        this.n += b.length;
+        if (pending)
+            await pending;
+    }
+}
+/**
+ * The embedded recording: lines → gzip → base64 → put. Lines are batched for
+ * zlib, and compressed output is encoded in multiples of 3 bytes, so the
+ * pieces concatenate to the base64 of one gzip stream. Each batch is
+ * compressed and its output written before more lines are taken.
+ */
+class EmbeddedData {
+    constructor(put) {
+        this.put = put;
+        this.gz = zlib_1.default.createGzip();
+        this.batch = Buffer.allocUnsafe(BATCH_BYTES);
+        this.batchLen = 0;
+        this.compressed = [];
+        this.compressedLen = 0;
+        /** Compressed bytes not encoded yet: fewer than 3. */
+        this.carry = Buffer.alloc(0);
+        this.gz.on('data', (chunk) => {
+            this.compressed.push(chunk);
+            this.compressedLen += chunk.length;
+        });
+        // Failures reach the write callback or end(); this keeps an 'error'
+        // event from being unhandled.
+        this.gz.on('error', () => { });
+    }
+    /** Adds a line; returns a promise when the caller must wait for the batch to be written. */
+    write(line) {
+        // Lines are copied, so no buffer of scan is kept beyond its call.
+        if (this.batchLen + line.length + 1 > this.batch.length)
+            return this.writeSlow(line);
+        line.copy(this.batch, this.batchLen);
+        this.batchLen += line.length;
+        this.batch[this.batchLen++] = 0x0a;
+    }
+    async writeSlow(line) {
+        await this.flushBatch();
+        if (line.length + 1 > this.batch.length) {
+            await this.compress(Buffer.concat([line, NEWLINE]));
+            return;
+        }
+        line.copy(this.batch, 0);
+        this.batchLen = line.length;
+        this.batch[this.batchLen++] = 0x0a;
+    }
+    async flushBatch() {
+        if (this.batchLen === 0)
+            return;
+        const chunk = this.batch.subarray(0, this.batchLen);
+        this.batch = Buffer.allocUnsafe(BATCH_BYTES); // zlib keeps chunk until it is processed
+        this.batchLen = 0;
+        await this.compress(chunk);
+    }
+    async compress(chunk) {
+        await new Promise((resolve, reject) => {
+            this.gz.write(chunk, (err) => (err ? reject(err) : resolve()));
+        });
+        if (this.compressedLen >= FLUSH_BYTES)
+            await this.encode(false);
+    }
+    /** Encodes and writes the compressed output; all of it, padded, when final. */
+    async encode(final) {
+        const data = Buffer.concat([this.carry, ...this.compressed]);
+        this.compressed = [];
+        this.compressedLen = 0;
+        const n = final ? data.length : data.length - (data.length % 3);
+        this.carry = Buffer.from(data.subarray(n));
+        if (n > 0)
+            await this.put(Buffer.from(data.toString('base64', 0, n), 'latin1'));
+    }
+    /** Writes the rest and the gzip trailer. */
+    async end() {
+        await this.flushBatch();
+        await new Promise((resolve, reject) => {
+            this.gz.once('end', resolve);
+            this.gz.once('error', reject);
+            this.gz.end();
+        });
+        await this.encode(true);
+    }
+    destroy() {
+        this.gz.destroy();
+    }
+}
+const NEWLINE = Buffer.from('\n');
+/**
+ * Whether a line belongs in the file. A WebSocket connection's record
+ * carries its open time; it is included while the connection was open during
+ * the range, so the range's messages keep their connection.
+ */
+function included(l, from, to) {
+    if (l.ts >= from && l.ts <= to)
+        return true;
+    const n = l.net;
+    if (n && (0, types_1.isWebSocket)(n) && l.ts < from)
+        return n.pending || n.closedAt === 0 || Math.trunc(n.closedAt) >= from;
+    return false;
+}
+/** The timestamps of the first and last line to include. */
+function selectLines(v, o) {
+    let from = -FAR;
+    let to = FAR;
+    const optFrom = o.from ?? 0;
+    const optTo = o.to ?? 0;
+    if (optTo > 0)
+        to = v.start + optTo;
+    if (optFrom <= 0)
+        return [from, to];
+    // Start at the last Meta + full snapshot pair at or before the range,
+    // else at the first one.
+    const target = v.start + optFrom;
+    const rr = v.lines.filter((l) => l.type === 'rrweb');
+    let found = false;
+    for (let i = 0; i + 1 < rr.length; i++) {
+        if (rr[i].rr === reader_1.RR_META && rr[i + 1].rr === reader_1.RR_FULL_SNAPSHOT) {
+            if (rr[i].ts > target && found)
+                break;
+            from = rr[i].ts;
+            found = true;
+        }
+    }
+    if (!found)
+        from = target;
+    return [from, to];
+}
+/** Applies the options to one line. Lines that need no change are returned as they are. */
+function transform(l, raw, o) {
+    if (l.type === 'network' && (!o.secrets || o.stripBodies)) {
+        return editData(raw, (d) => {
+            if (!o.secrets) {
+                for (const key of ['reqHeaders', 'resHeaders'])
+                    redactHeaders(d, key, o.redact);
+            }
+            if (o.stripBodies) {
+                for (const side of ['req', 'res']) {
+                    if (has(d, side + 'Body')) {
+                        delete d[side + 'Body'];
+                        delete d[side + 'BodyTruncated'];
+                        d[side + 'BodyNote'] = 'removed from this export';
+                    }
+                }
+            }
+        });
+    }
+    if (l.type === 'ws' && o.stripBodies) {
+        // WebSocket messages are bodies too.
+        return editData(raw, (d) => {
+            if (has(d, 'data')) {
+                delete d.data;
+                delete d.truncated;
+                d.dataRemoved = true;
+            }
+        });
+    }
+    if (l.type === 'console' && o.stripConsoleArgs) {
+        return editData(raw, (d) => {
+            delete d.args;
+        });
+    }
+    return raw;
+}
+const has = (d, key) => Object.prototype.hasOwnProperty.call(d, key);
+/** Replaces sensitive header values, when the field is a map of strings; anything else is left alone. */
+function redactHeaders(d, key, rd) {
+    const h = d[key];
+    if (!(0, types_1.isObj)(h))
+        return; // missing, null or not the expected shape
+    const m = {};
+    for (const [k, v] of Object.entries(h)) {
+        if (typeof v === 'string')
+            m[k] = v;
+        else if (v === null)
+            m[k] = ''; // Go decodes null into a string as ""
+        else
+            return;
+    }
+    d[key] = rd.apply(m);
+}
+/**
+ * Decodes a line's "data" object, lets fn change it and re-encodes the line
+ * with the envelope's fields in their order: sid, ts, type, data. Lines that
+ * are not such an object are kept as they are.
+ */
+function editData(raw, fn) {
+    let env;
+    try {
+        env = JSON.parse(raw.toString('utf8'));
+    }
+    catch {
+        return raw;
+    }
+    if (!(0, types_1.isObj)(env))
+        return raw;
+    const { sid, ts, type, data } = env;
+    if (!(0, types_1.isObj)(data))
+        return raw; // missing, null or not an object
+    if ((sid !== undefined && sid !== null && typeof sid !== 'string') || (type !== undefined && type !== null && typeof type !== 'string')) {
+        return raw;
+    }
+    fn(data);
+    const line = {
+        ...(typeof sid === 'string' && sid !== '' ? { sid } : {}),
+        ts: ts === undefined ? null : ts,
+        type: typeof type === 'string' ? type : '',
+        data,
+    };
+    return Buffer.from(JSON.stringify(line), 'utf8');
+}
+function bytesOf(b) {
+    return typeof b === 'string' ? Buffer.from(b, 'utf8') : b;
+}
+/**
+ * "</script" and "</style" in any case, which would end the element early.
+ * Like Go's (?i), "ſ" (U+017F, UTF-8 C5 BF) matches "s" too. The assets are
+ * matched as latin1 so their bytes pass through unchanged.
+ */
+const SCRIPT_CLOSE = /<\/((?:[sS]|\xc5\xbf)[cC][rR][iI][pP][tT])/g;
+const STYLE_CLOSE = /<\/((?:[sS]|\xc5\xbf)[tT][yY][lL][eE])/g;
+function escapeClose(b, re) {
+    const s = b.toString('latin1');
+    const escaped = s.replace(re, '<\\/$1');
+    return escaped === s ? b : Buffer.from(escaped, 'latin1');
+}
+const HTML_ESCAPES = { '&': '&amp;', "'": '&#39;', '<': '&lt;', '>': '&gt;', '"': '&#34;' };
+/** Go's html.EscapeString. */
+function escapeHTML(s) {
+    return s.replace(/[&'<>"]/g, (c) => HTML_ESCAPES[c]);
+}
+/** What Go's json.Marshal escapes and JSON.stringify does not: <, >, &, U+2028 and U+2029. */
+const SCRIPT_UNSAFE = new RegExp(`[<>&${String.fromCharCode(0x2028, 0x2029)}]`, 'g');
+/**
+ * JSON that cannot end its script element, escaped like Go's json.Marshal.
+ * The escaped characters only occur inside strings.
+ */
+function scriptJSON(v) {
+    return JSON.stringify(v).replace(SCRIPT_UNSAFE, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}