typescript-virtual-container 1.5.1 → 1.5.3

package/examples/app.ts

@@ -0,0 +1,299 @@
+/** biome-ignore-all lint/suspicious/noControlCharactersInRegex: need to parse ANSI */
+import { getCommandNames } from '../src/commands/registry.js';
+import { makeDefaultEnv, runCommand, userHome } from '../src/commands/runtime.js';
+import { VirtualShell } from '../src/index.js';
+import { resolvePath } from '../src/modules/shellRuntime.js';
+import { type LoginBannerState, buildLoginBanner } from '../src/SSHMimic/loginBanner.js';
+import { buildPrompt } from '../src/SSHMimic/prompt.js';
+import type { CommandResult } from '../src/types/commands.js';
+
+const HOSTNAME = 'my-vm';
+const MAX_HISTORY = 500;
+
+const terminal = document.getElementById('terminal') as HTMLElement;
+const out = document.getElementById('output') as HTMLElement;
+const cmd = document.getElementById('cmd') as HTMLInputElement;
+
+function scrollToBottom(): void {
+  terminal.scrollTop = terminal.scrollHeight;
+}
+
+cmd.focus();
+document.addEventListener('click', () => {
+  if (!window.getSelection()?.toString()) cmd.focus();
+});
+
+// ANSI to HTML
+const FG_COLORS: Record<number, string> = {
+  30: '#000', 31: '#c00', 32: '#0c0', 33: '#cc0',
+  34: '#00c', 35: '#c0c', 36: '#0cc', 37: '#ccc',
+  90: '#555', 91: '#f55', 92: '#5f5', 93: '#ff5',
+  94: '#55f', 95: '#f5f', 96: '#5ff', 97: '#fff',
+};
+const BG_COLORS: Record<number, string> = {
+  40: '#000', 41: '#c00', 42: '#0c0', 43: '#cc0',
+  44: '#00c', 45: '#c0c', 46: '#0cc', 47: '#ccc',
+};
+
+function ansiToHtml(s: string): string {
+  let html = '';
+  let bold = false, fg = '', bg = '';
+  for (const part of s.split(/(\x1b\[[0-9;]*m)/)) {
+    const m = part.match(/^\x1b\[([0-9;]*)m$/);
+    if (m) {
+      for (const code of m[1].split(';').map(Number)) {
+        if (code === 0) { bold = false; fg = ''; bg = ''; }
+        else if (code === 1) bold = true;
+        else if (FG_COLORS[code]) fg = FG_COLORS[code];
+        else if (BG_COLORS[code]) bg = BG_COLORS[code];
+      }
+    } else if (part) {
+      const style = [
+        fg ? `color:${fg}` : '',
+        bg ? `background:${bg}` : '',
+        bold ? 'font-weight:bold' : '',
+      ].filter(Boolean).join(';');
+      const escaped = part.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+      html += style ? `<span style="${style}">${escaped}</span>` : escaped;
+    }
+  }
+  return html;
+}
+
+// All output goes into a single <span> appended to #output.
+// #output is pre-wrap so \n = newline, no extra divs needed.
+function print(s: string): void {
+  const span = document.createElement('span');
+  span.innerHTML = ansiToHtml(s);
+  if (inputLineEl) {
+    out.insertBefore(span, inputLineEl);
+  } else {
+    out.appendChild(span);
+  }
+  scrollToBottom();
+}
+
+// Live input line — sits at bottom of #output as an inline element
+let inputLineEl: HTMLSpanElement | null = null;
+
+function printPrompt(): void {
+  if (inputLineEl) { inputLineEl.remove(); inputLineEl = null; }
+  cmd.value = '';
+
+  inputLineEl = document.createElement('span');
+  inputLineEl.className = 'input-line';
+
+  const promptSpan = document.createElement('span');
+  const cwdLabel = cwd === userHome(authUser) ? '~' : (cwd.split('/').at(-1) || '/');
+  promptSpan.innerHTML = ansiToHtml(buildPrompt(authUser, HOSTNAME, cwdLabel));
+
+  const textSpan = document.createElement('span');
+  textSpan.className = 'typed';
+
+  const cursor = document.createElement('span');
+  cursor.className = 'cursor';
+  cursor.textContent = '\u00a0';
+
+  inputLineEl.appendChild(promptSpan);
+  inputLineEl.appendChild(textSpan);
+  inputLineEl.appendChild(cursor);
+  out.appendChild(inputLineEl);
+  scrollToBottom();
+}
+
+cmd.addEventListener('input', () => {
+  if (!inputLineEl) return;
+  (inputLineEl.querySelector('.typed') as HTMLSpanElement).textContent = cmd.value;
+  scrollToBottom();
+});
+
+// Wait for IndexedDB fs shim memCache
+// biome-ignore lint/suspicious/noExplicitAny: globalThis shim
+await (globalThis as any).__fsReady__;
+
+const shell = new VirtualShell(HOSTNAME, undefined, {
+  mode: 'fs',
+  snapshotPath: '/vfs-data',
+  flushIntervalMs: 10_000,
+});
+
+const vfs = shell.vfs;
+
+await vfs.restoreMirror();
+
+const isFirstRun = !vfs.exists('/bin');
+if (isFirstRun) {
+  await shell.ensureInitialized();
+  if (!vfs.exists('/root')) vfs.mkdir('/root', 0o700);
+  vfs.writeFile('/root/README.txt', `Welcome to ${HOSTNAME}\n`);
+  await vfs.flushMirror();
+}
+
+window.addEventListener('beforeunload', () => { vfs.flushMirror(); });
+
+// Session state
+let authUser = 'root';
+let cwd = userHome(authUser);
+const shellEnv = makeDefaultEnv(authUser, HOSTNAME);
+shellEnv.vars.PWD = cwd;
+
+function applyResult(result: CommandResult): void {
+  if (result.switchUser) {
+    authUser = result.switchUser;
+    cwd = result.nextCwd ?? userHome(authUser);
+    shellEnv.vars.USER = authUser;
+    shellEnv.vars.LOGNAME = authUser;
+    shellEnv.vars.HOME = userHome(authUser);
+    shellEnv.vars.PWD = cwd;
+  } else if (result.nextCwd) {
+    cwd = result.nextCwd;
+    shellEnv.vars.PWD = cwd;
+  }
+}
+
+// History
+function historyPath(): string { return `${userHome(authUser)}/.bash_history`; }
+
+function loadHistory(): string[] {
+  try {
+    if (!vfs.exists(historyPath())) return [];
+    return (vfs.readFile(historyPath()) as string)
+      .split('\n').map((l: string) => l.trim()).filter((l: string) => l.length > 0);
+  } catch { return []; }
+}
+
+function saveHistory(): void {
+  vfs.writeFile(historyPath(), history.length > 0 ? `${history.join('\n')}\n` : '');
+}
+
+let history: string[] = loadHistory();
+let historyIdx = -1;
+
+// Login banner + lastlog
+function readLastLogin(): LoginBannerState | null {
+  try {
+    if (!vfs.exists('/root/.lastlog')) return null;
+    return JSON.parse(vfs.readFile('/root/.lastlog'));
+  } catch { return null; }
+}
+
+function writeLastLogin(): void {
+  vfs.writeFile('/root/.lastlog', JSON.stringify({ at: new Date().toISOString(), from: 'browser' }));
+}
+
+print(buildLoginBanner(HOSTNAME, shell.properties, readLastLogin()));
+writeLastLogin();
+await vfs.flushMirror();
+printPrompt();
+
+
+// Tab completion
+function listPathCompletions(prefix: string): string[] {
+  const slashIndex = prefix.lastIndexOf('/');
+  const dirPart  = slashIndex >= 0 ? prefix.slice(0, slashIndex + 1) : '';
+  const namePart = slashIndex >= 0 ? prefix.slice(slashIndex + 1)    : prefix;
+  const basePath = resolvePath(cwd, dirPart || '.');
+  try {
+    return vfs.list(basePath)
+      .filter((e: string) => !e.startsWith('.') && e.startsWith(namePart))
+      .map((e: string) => {
+        const fullPath = `${basePath}/${e}`.replace(/\/+/g, '/');
+        const st = vfs.stat(fullPath);
+        return `${dirPart}${e}${st.type === 'directory' ? '/' : ''}`;
+      })
+      .sort();
+  } catch { return []; }
+}
+
+const commandNames = Array.from(new Set(getCommandNames())).sort();
+
+function getCompletions(line: string): [string[], string] {
+  const token = line.split(/\s+/).at(-1) ?? '';
+  const isFirstToken = line.trimStart() === token;
+  const cmdHits  = isFirstToken ? commandNames.filter(n => n.startsWith(token)) : [];
+  const pathHits = listPathCompletions(token);
+  const hits = Array.from(new Set([...cmdHits, ...pathHits])).sort();
+  return [hits, token];
+}
+
+// Input handler
+cmd.addEventListener('keydown', async (e: KeyboardEvent) => {
+  if (e.key === 'Tab') {
+    e.preventDefault();
+    const line = cmd.value;
+    const [hits, token] = getCompletions(line);
+    if (hits.length === 0) return;
+    if (hits.length === 1) {
+      // Unique match — complete inline
+      cmd.value = line.slice(0, line.length - token.length) + hits[0];
+      if (inputLineEl) (inputLineEl.querySelector('.typed') as HTMLSpanElement).textContent = cmd.value;
+    } else {
+      // Multiple matches — print them below current line, re-prompt
+      const prevLine = inputLineEl;
+      inputLineEl = null;
+      prevLine?.querySelector('.cursor')?.remove();
+      out.appendChild(document.createTextNode('\n'));
+      print(`${hits.join('  ')}
+`);
+      printPrompt();
+      cmd.value = line;
+      if (inputLineEl) ((inputLineEl as HTMLSpanElement).querySelector('.typed') as HTMLSpanElement).textContent = cmd.value;
+    }
+    return;
+  }
+
+  if (e.key === 'ArrowUp') {
+    e.preventDefault();
+    if (historyIdx < history.length - 1) {
+      historyIdx++;
+      cmd.value = history[history.length - 1 - historyIdx];
+      if (inputLineEl) (inputLineEl.querySelector('.typed') as HTMLSpanElement).textContent = cmd.value;
+    }
+    return;
+  }
+
+  if (e.key === 'ArrowDown') {
+    e.preventDefault();
+    if (historyIdx > 0) { historyIdx--; cmd.value = history[history.length - 1 - historyIdx]; }
+    else { historyIdx = -1; cmd.value = ''; }
+    if (inputLineEl) (inputLineEl.querySelector('.typed') as HTMLSpanElement).textContent = cmd.value;
+    return;
+  }
+
+  if (e.key !== 'Enter') return;
+
+  const value = cmd.value.trim();
+  historyIdx = -1;
+
+  // Freeze input line: remove cursor span, null the ref (keeps prompt+typed in DOM)
+  if (inputLineEl) {
+    inputLineEl.querySelector('.cursor')?.remove();
+    inputLineEl = null;
+  }
+
+  // Newline after the frozen line
+  out.appendChild(document.createTextNode('\n'));
+
+  if (value) {
+    history.push(value);
+    if (history.length > MAX_HISTORY) history = history.slice(history.length - MAX_HISTORY);
+    saveHistory();
+  }
+
+  try {
+    const result = await runCommand(value, authUser, HOSTNAME, 'shell', cwd, shell, undefined, shellEnv);
+
+    if (result.clearScreen) out.innerHTML = '';
+    if (result.stdout) print(`${result.stdout.trim()}\n`);
+    if (result.stderr) print(`${result.stderr.trim()}\n`);
+
+    applyResult(result);
+    await vfs.flushMirror();
+
+    if (result.closeSession) { print('\nSession closed.\n'); return; }
+  } catch (err) {
+    print(`${String(err)}\n`);
+  }
+
+  printPrompt();
+});

package/examples/build.js

@@ -0,0 +1,27 @@
+import esbuild from 'esbuild';
+
+const ctx = await esbuild.context({
+    entryPoints: ['app.ts'],
+    bundle: true,
+    format: 'esm',
+    outfile: `app.js`,
+    platform: 'browser',
+    alias: {
+        'node:events': '../polyfills/node_events/index.js',
+        'node:path': '../polyfills/node_path/index.js',
+        'node:os': '../polyfills/node_os/index.js',
+        'node:fs': '../polyfills/node_fs/index.js',
+        'node:fs/promises': '../polyfills/node_fs/promises.js',
+        'node:crypto': '../polyfills/node_crypto/index.js',
+        'node:child_process': '../polyfills/node_child_process/index.js',
+        'node:zlib': '../polyfills/node_zlib/index.js',
+        'node:vm': '../polyfills/node_vm/index.js',
+        'ssh2': '../polyfills/ssh2/index.js',
+    },
+    minify: true,
+    treeShaking: true,
+    inject: ['../polyfills/process.js', '../polyfills/buffer.js'],
+});
+
+await ctx.watch();
+console.log('watching...');

package/examples/demo.html

@@ -0,0 +1,33 @@
+    <!DOCTYPE html>
+    <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Virtual Env JS</title>
+            <script type="module">
+                import { VirtualShell, VirtualFileSystem } from '../builds/fortune-nyx-v1.5.3-web.min.js';
+
+                const now1 = new Date();
+                const ready = await globalThis.__fsReady__;
+                window.ready = ready; // Expose for debugging
+                const now2 = new Date();
+                console.log(`IndexedDB VFS ready in ${now2 - now1}ms`);
+                const shell = new VirtualShell('my-vm', undefined, {
+                    mode: 'fs',
+                    snapshotPath: '/vfs-data',
+                    flushIntervalMs: 10_000,
+                });
+
+                window.addEventListener('beforeunload', () => {
+                    shell.vfs.flushMirror();
+                });
+
+                window.shell = shell; // Expose shell for debugging
+                const result = await shell.executeCommand("ls -l", "root", "/root");
+                await shell.vfs.flushMirror()
+                console.log(shell.vfs.getMode());
+            </script>
+        </head>
+        <body>
+        </body>
+    </html>

package/examples/index.html

@@ -5,23 +5,78 @@
     <meta name="viewport" content="width=device-width,initial-scale=1" />
     <title>Virtual Shell — Web Demo</title>
     <style>
-      html,body{height:100%;margin:0}
-      body{display:flex;flex-direction:column;font-family:monospace;background:#0b0f14;color:#e6eef6}
-      #terminal{flex:1;display:flex;flex-direction:column;padding:12px;box-sizing:border-box}
-      #output{flex:1;overflow:auto;white-space:pre-wrap}
-      #inputRow{display:flex;border-top:1px solid rgba(255,255,255,0.04);padding-top:8px}
-      #prompt{padding-right:8px}
-      #cmd{flex:1;background:transparent;border:0;color:inherit;outline:none;font-family:inherit}
+      *, *::before, *::after { box-sizing: border-box; }
+
+      html, body {
+        height: 100%;
+        margin: 0;
+      }
+
+      body {
+        display: flex;
+        flex-direction: column;
+        font-family: 'Cascadia Code', 'Fira Code', 'JetBrains Mono', monospace;
+        font-size: 14px;
+        line-height: 1.5;
+        background: #0b0f14;
+        color: #e6eef6;
+      }
+
+      #terminal {
+        flex: 1;
+        overflow-y: auto;
+        padding: 12px 16px;
+        cursor: text;
+        user-select: text;
+        scrollbar-width: none;       /* Firefox */
+      }
+
+      #terminal::-webkit-scrollbar {
+        display: none;               /* Chrome/Safari */
+      }
+
+      #output {
+        white-space: pre-wrap;
+        word-break: break-all;
+        user-select: text;
+      }
+
+      #output span,
+      #output .input-line {
+        user-select: text;
+      }
+
+      /* Hidden input — keystroke sink only */
+      #cmd {
+        position: fixed;
+        left: -9999px;
+        opacity: 0;
+        width: 1px;
+        height: 1px;
+        pointer-events: none;
+      }
+
+      .cursor {
+        display: inline-block;
+        min-width: 0.6em;
+        background: #e6eef6;
+        color: #0b0f14;
+        animation: blink 1s step-start infinite;
+        pointer-events: none;
+        user-select: none;
+      }
+
+      @keyframes blink {
+        0%, 100% { opacity: 1; }
+        50%       { opacity: 0; }
+      }
     </style>
   </head>
   <body>
     <div id="terminal">
-      <div id="output">Welcome to Virtual Shell (web build)\n</div>
-      <div id="inputRow">
-        <div id="prompt">$</div>
-        <input id="cmd" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false" />
-      </div>
+      <div id="output"></div>
     </div>
+    <input id="cmd" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false" />
     <script type="module" src="./app.js"></script>
   </body>
-</html>
+</html>

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "self-standalone-build": "node scripts/build-all.mjs",
     "standalone-build": "bunx esbuild src/standalone.ts --bundle --platform=node --target=node18 --outfile=builds/standalone.cjs --tree-shaking=true --minify  --banner:js='#!/usr/bin/env node'",
     "build-all": "node scripts/build-all.mjs",
-    "publish-doc": "bunx typedoc && bunx gh-pages -d docs",
+    "publish-doc": "bunx typedoc && bun build-all && bunx gh-pages -d docs && git add docs && git commit -m 'docs: update documentation' && git push",
     "generate-manuals": "node scripts/generate-manuals-bundle.mjs"
   },
   "devDependencies": {
@@ -48,6 +48,7 @@
     "@types/bun": "^1.3.14",
     "@types/node": "^25.7.0",
     "@types/ssh2": "^1.15.5",
+    "esbuild": "^0.28.0",
     "gh-pages": "^6.3.0",
     "rimraf": "^6.1.3",
     "typescript": "^6.0.3"

package/polyfills/buffer.js

@@ -0,0 +1,117 @@
+class BrowserBuffer extends Uint8Array {
+    static from(data, encoding) {
+        if (typeof data === 'string') {
+            const enc = encoding || 'utf8';
+            if (enc === 'hex') {
+                const arr = new BrowserBuffer(data.length / 2);
+                for (let i = 0; i < arr.length; i++)
+                    arr[i] = parseInt(data.slice(i * 2, i * 2 + 2), 16);
+                return arr;
+            }
+            if (enc === 'base64') {
+                const bin = atob(data);
+                const arr = new BrowserBuffer(bin.length);
+                for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i);
+                return arr;
+            }
+            return new BrowserBuffer(new TextEncoder().encode(data));
+        }
+        if (data instanceof ArrayBuffer) return new BrowserBuffer(data);
+        return new BrowserBuffer(data);
+    }
+
+    static alloc(size, fill = 0) {
+        return new BrowserBuffer(size).fill(fill);
+    }
+
+    static allocUnsafe(size) {
+        return new BrowserBuffer(size);
+    }
+
+    static isBuffer(obj) {
+        return obj instanceof BrowserBuffer || obj instanceof Uint8Array;
+    }
+
+    static concat(bufs, totalLength) {
+        const len = totalLength ?? bufs.reduce((s, b) => s + b.length, 0);
+        const out = new BrowserBuffer(len);
+        let offset = 0;
+        for (const b of bufs) { out.set(b, offset); offset += b.length; }
+        return out;
+    }
+
+    static byteLength(str, enc = 'utf8') {
+        if (enc === 'hex') return str.length / 2;
+        if (enc === 'base64') return Math.floor(str.length * 3 / 4);
+        return new TextEncoder().encode(str).length;
+    }
+
+    // ── write methods ──────────────────────────────────────────────────────────
+    writeUInt8(val, offset = 0) { this[offset] = val & 0xff; return offset + 1; }
+    writeInt8(val, offset = 0) { this[offset] = val & 0xff; return offset + 1; }
+
+    writeUInt16BE(val, offset = 0) { this[offset] = (val >>> 8) & 0xff; this[offset + 1] = val & 0xff; return offset + 2; }
+    writeUInt16LE(val, offset = 0) { this[offset] = val & 0xff; this[offset + 1] = (val >>> 8) & 0xff; return offset + 2; }
+    writeInt16BE(val, offset = 0) { return this.writeUInt16BE(val, offset); }
+    writeInt16LE(val, offset = 0) { return this.writeUInt16LE(val, offset); }
+
+    writeUInt32BE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setUint32(0, val, false); return offset + 4; }
+    writeUInt32LE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setUint32(0, val, true); return offset + 4; }
+    writeInt32BE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setInt32(0, val, false); return offset + 4; }
+    writeInt32LE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setInt32(0, val, true); return offset + 4; }
+
+    writeBigUInt64BE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setBigUint64(0, BigInt(val), false); return offset + 8; }
+    writeBigUInt64LE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setBigUint64(0, BigInt(val), true); return offset + 8; }
+
+    writeFloatBE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setFloat32(0, val, false); return offset + 4; }
+    writeFloatLE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setFloat32(0, val, true); return offset + 4; }
+    writeDoubleBE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setFloat64(0, val, false); return offset + 8; }
+    writeDoubleLE(val, offset = 0) { new DataView(this.buffer, this.byteOffset + offset).setFloat64(0, val, true); return offset + 8; }
+
+    // ── read methods ───────────────────────────────────────────────────────────
+    readUInt8(offset = 0) { return this[offset]; }
+    readInt8(offset = 0) { const v = this[offset]; return v >= 128 ? v - 256 : v; }
+
+    readUInt16BE(offset = 0) { return (this[offset] << 8) | this[offset + 1]; }
+    readUInt16LE(offset = 0) { return this[offset] | (this[offset + 1] << 8); }
+    readInt16BE(offset = 0) { const v = this.readUInt16BE(offset); return v >= 0x8000 ? v - 0x10000 : v; }
+    readInt16LE(offset = 0) { const v = this.readUInt16LE(offset); return v >= 0x8000 ? v - 0x10000 : v; }
+
+    readUInt32BE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getUint32(0, false); }
+    readUInt32LE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getUint32(0, true); }
+    readInt32BE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getInt32(0, false); }
+    readInt32LE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getInt32(0, true); }
+
+    readBigUInt64BE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getBigUint64(0, false); }
+    readBigUInt64LE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getBigUint64(0, true); }
+
+    readFloatBE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getFloat32(0, false); }
+    readFloatLE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getFloat32(0, true); }
+    readDoubleBE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getFloat64(0, false); }
+    readDoubleLE(offset = 0) { return new DataView(this.buffer, this.byteOffset + offset).getFloat64(0, true); }
+
+    // ── misc ───────────────────────────────────────────────────────────────────
+    toString(enc = 'utf8', start = 0, end = this.length) {
+        const slice = this.subarray(start, end);
+        if (enc === 'hex') return Array.from(slice).map(b => b.toString(16).padStart(2, '0')).join('');
+        if (enc === 'base64') return btoa(String.fromCharCode(...slice));
+        return new TextDecoder(enc === 'utf8' ? 'utf-8' : enc).decode(slice);
+    }
+
+    copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.length) {
+        target.set(this.subarray(sourceStart, sourceEnd), targetStart);
+    }
+    equals(other) {
+        if (this.length !== other.length) return false;
+        for (let i = 0; i < this.length; i++)
+            if (this[i] !== other[i]) return false;
+        return true;
+    }
+
+    slice(start, end) { return new BrowserBuffer(super.slice(start, end)); }
+    subarray(start, end) { return new BrowserBuffer(super.subarray(start, end)); }
+
+    get length() { return this.byteLength; }
+}
+
+globalThis.Buffer = BrowserBuffer;