typescript-virtual-container 1.5.3 → 1.5.4

package/polyfills/node_crypto/index.js

@@ -1,167 +0,0 @@
-// ─── SHA-256 (pure JS) ───────────────────────────────────────────────────────
-const K = new Uint32Array([
-  0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
-  0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
-  0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
-  0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
-  0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
-  0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
-  0x19a4c116,0x1e376c085,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
-  0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
-]);
-
-function sha256(data) {
-  const msg = data instanceof Uint8Array ? data : new TextEncoder().encode(data);
-  const bits = msg.length * 8;
-  const padLen = Math.ceil((msg.length + 9) / 64) * 64;
-  const padded = new Uint8Array(padLen);
-  padded.set(msg);
-  padded[msg.length] = 0x80;
-  const dv0 = new DataView(padded.buffer);
-  dv0.setUint32(padLen - 4, bits >>> 0, false);
-
-  let h0=0x6a09e667, h1=0xbb67ae85, h2=0x3c6ef372, h3=0xa54ff53a,
-      h4=0x510e527f, h5=0x9b05688c, h6=0x1f83d9ab, h7=0x5be0cd19;
-
-  const w = new Uint32Array(64);
-  const dv = new DataView(padded.buffer);
-  for (let i = 0; i < padLen; i += 64) {
-    for (let j = 0; j < 16; j++) w[j] = dv.getUint32(i + j * 4, false);
-    for (let j = 16; j < 64; j++) {
-      const s0 = (w[j-15]>>>7|w[j-15]<<25)^(w[j-15]>>>18|w[j-15]<<14)^(w[j-15]>>>3);
-      const s1 = (w[j-2]>>>17|w[j-2]<<15)^(w[j-2]>>>19|w[j-2]<<13)^(w[j-2]>>>10);
-      w[j] = (w[j-16] + s0 + w[j-7] + s1) | 0;
-    }
-    let a=h0,b=h1,c=h2,d=h3,e=h4,f=h5,g=h6,hh=h7;
-    for (let j = 0; j < 64; j++) {
-      const S1  = (e>>>6|e<<26)^(e>>>11|e<<21)^(e>>>25|e<<7);
-      const ch  = (e&f)^(~e&g);
-      const t1  = (hh + S1 + ch + K[j] + w[j]) | 0;
-      const S0  = (a>>>2|a<<30)^(a>>>13|a<<19)^(a>>>22|a<<10);
-      const maj = (a&b)^(a&c)^(b&c);
-      const t2  = (S0 + maj) | 0;
-      hh=g; g=f; f=e; e=(d+t1)|0; d=c; c=b; b=a; a=(t1+t2)|0;
-    }
-    h0=(h0+a)|0; h1=(h1+b)|0; h2=(h2+c)|0; h3=(h3+d)|0;
-    h4=(h4+e)|0; h5=(h5+f)|0; h6=(h6+g)|0; h7=(h7+hh)|0;
-  }
-
-  const out = new Uint8Array(32);
-  const odv = new DataView(out.buffer);
-  [h0,h1,h2,h3,h4,h5,h6,h7].forEach((v,i) => odv.setUint32(i*4, v, false));
-  return out;
-}
-
-// ─── HMAC-SHA256 ─────────────────────────────────────────────────────────────
-function hmacSha256(key, data) {
-  const BLOCK = 64;
-  let k = key instanceof Uint8Array ? key : new TextEncoder().encode(key);
-  if (k.length > BLOCK) k = sha256(k);
-  const kpad = new Uint8Array(BLOCK);
-  kpad.set(k);
-  const ipad = kpad.map(b => b ^ 0x36);
-  const opad = kpad.map(b => b ^ 0x5c);
-  const inner = new Uint8Array(BLOCK + data.length);
-  inner.set(ipad); inner.set(data, BLOCK);
-  const outer = new Uint8Array(BLOCK + 32);
-  outer.set(opad); outer.set(sha256(inner), BLOCK);
-  return sha256(outer);
-}
-
-// ─── PBKDF2-HMAC-SHA256 (sync) ───────────────────────────────────────────────
-function pbkdf2Sync(password, salt, iterations, keylen) {
-  const pw   = password instanceof Uint8Array ? password : new TextEncoder().encode(password);
-  const sl   = salt instanceof Uint8Array ? salt : new TextEncoder().encode(salt);
-  const hlen = 32;
-  const blocks = Math.ceil(keylen / hlen);
-  const dk = new Uint8Array(keylen);
-
-  for (let i = 1; i <= blocks; i++) {
-    const ibuf = new Uint8Array(4);
-    new DataView(ibuf.buffer).setUint32(0, i, false);
-    const saltI = new Uint8Array(sl.length + 4);
-    saltI.set(sl);
-    saltI.set(ibuf, sl.length);
-
-    let U = hmacSha256(pw, saltI);
-    const T = new Uint8Array(U);
-    for (let j = 1; j < iterations; j++) {
-      U = hmacSha256(pw, U);
-      for (let k = 0; k < hlen; k++) T[k] ^= U[k];
-    }
-    const offset = (i - 1) * hlen;
-    dk.set(T.slice(0, keylen - offset), offset);
-  }
-  return dk;
-}
-
-// ─── Exports ─────────────────────────────────────────────────────────────────
-export function randomBytes(n) {
-  const a = new Uint8Array(n);
-  crypto.getRandomValues(a);
-  return a;
-}
-
-export function randomUUID() {
-  return crypto.randomUUID
-    ? crypto.randomUUID()
-    : ([1e7]+-1e3+-4e3+-8e3+-1e11).replace(/[018]/g, c =>
-        (c ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
-}
-
-export function createHash(alg) {
-  const chunks = [];
-  return {
-    update(d) {
-      chunks.push(d instanceof Uint8Array ? d : new TextEncoder().encode(String(d)));
-      return this;
-    },
-    digest(enc = 'hex') {
-      const total = chunks.reduce((s, c) => s + c.length, 0);
-      const buf = new Uint8Array(total);
-      let off = 0;
-      for (const c of chunks) { buf.set(c, off); off += c.length; }
-      const hash = sha256(buf);
-      if (enc === 'hex') return Array.from(hash).map(b => b.toString(16).padStart(2,'0')).join('');
-      if (enc === 'base64') return btoa(String.fromCharCode(...hash));
-      return hash;
-    },
-  };
-}
-
-export function scryptSync(password, salt, keylen, options = {}) {
-  const N = options.N ?? 16384;
-  const iterations = Math.max(1000, Math.round(Math.log2(N) * 1000));
-  const pw = typeof password === 'string' ? new TextEncoder().encode(password) : password;
-  const sl = typeof salt === 'string' ? new TextEncoder().encode(salt) : salt;
-  return pbkdf2Sync(pw, sl, iterations, keylen);
-}
-
-export function timingSafeEqual(a, b) {
-  if (a.length !== b.length) return false;
-  let diff = 0;
-  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
-  return diff === 0;
-}
-
-export function generateKeyPairSync() {
-  throw new Error('generateKeyPairSync is not implemented in this environment');
-}
-
-export function createHmac() {
-  throw new Error('createHmac is not implemented in this environment');
-}
-
-export function createCipheriv() {
-  throw new Error('createCipheriv is not implemented in this environment');
-}
-
-export function createDecipheriv() {
-  throw new Error('createDecipheriv is not implemented in this environment');
-}
-
-export function createSign() {
-  throw new Error('createSign is not implemented in this environment');
-}
-
-export default { randomBytes, randomUUID, createHash, scryptSync, timingSafeEqual, generateKeyPairSync, createHmac, createCipheriv, createDecipheriv, createSign };

package/polyfills/node_events/index.js

@@ -1,9 +0,0 @@
-export class EventEmitter {
-  constructor(){ this._events = Object.create(null); }
-  on(ev, fn){ (this._events[ev] ||= []).push(fn); return this; }
-  addListener(ev, fn){ return this.on(ev, fn); }
-  emit(ev, ...args){ const fns = this._events[ev] || []; for (const f of fns) try{ f(...args);}catch(e){} return fns.length>0; }
-  removeListener(ev, fn){ if(!this._events[ev]) return; this._events[ev]=this._events[ev].filter(x=>x!==fn); }
-}
-
-export default EventEmitter;

package/polyfills/node_fs/index.js

@@ -1,202 +0,0 @@
-// ── In-memory cache backed by IndexedDB (async writes, sync reads from cache) ──
-
-const DB_NAME = 'vfs-fs-shim';
-const STORE   = 'files';
-let db = null;
-
-function openDB() {
-  if (db) return Promise.resolve(db);
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(DB_NAME, 1);
-    req.onupgradeneeded = e => e.target.result.createObjectStore(STORE);
-    req.onsuccess  = e => { db = e.target.result; resolve(db); };
-    req.onerror    = e => reject(e.target.error);
-  });
-}
-
-// Sync cache (path → Uint8Array | null)
-const memCache = new Map();
-
-// Preload all keys into memCache at startup
-openDB().then(db => {
-  const tx = db.transaction(STORE, 'readonly');
-  const req = tx.objectStore(STORE).openCursor();
-  req.onsuccess = e => {
-    const cursor = e.target.result;
-    if (!cursor) return;
-    memCache.set(cursor.key, cursor.value);
-    cursor.continue();
-  };
-});
-
-function idbSet(path, value) {
-  openDB().then(db => {
-    const tx = db.transaction(STORE, 'readwrite');
-    if (value === null) tx.objectStore(STORE).delete(path);
-    else tx.objectStore(STORE).put(value, path);
-  });
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-function toBytes(data, encoding = 'utf8') {
-  if (data instanceof Uint8Array) return data;
-  if (typeof data === 'string') {
-    if (encoding === 'hex') {
-      const arr = new Uint8Array(data.length / 2);
-      for (let i = 0; i < arr.length; i++)
-        arr[i] = parseInt(data.slice(i*2, i*2+2), 16);
-      return arr;
-    }
-    return new TextEncoder().encode(data);
-  }
-  return new Uint8Array(data);
-}
-
-function fromBytes(bytes, encoding = 'utf8') {
-  if (!encoding || encoding === 'utf8') return new TextDecoder().decode(bytes);
-  if (encoding === 'hex') return Array.from(bytes).map(b => b.toString(16).padStart(2,'0')).join('');
-  if (encoding === 'base64') return btoa(String.fromCharCode(...bytes));
-  return new TextDecoder().decode(bytes);
-}
-
-function parentPath(p) {
-  const parts = p.split('/').filter(Boolean);
-  parts.pop();
-  return '/' + parts.join('/');
-}
-
-// ── Sync API (reads from memCache) ───────────────────────────────────────────
-
-export function existsSync(path) {
-  return memCache.has(path);
-}
-
-export function readFileSync(path, optionsOrEncoding) {
-  if (!memCache.has(path)) throw Object.assign(new Error(`ENOENT: no such file: ${path}`), { code: 'ENOENT' });
-  const bytes = memCache.get(path);
-  if (bytes === '__DIR__') throw Object.assign(new Error(`EISDIR: ${path}`), { code: 'EISDIR' });
-  const enc = typeof optionsOrEncoding === 'string' ? optionsOrEncoding : optionsOrEncoding?.encoding;
-  if (enc) return fromBytes(bytes, enc);
-  return globalThis.Buffer.from(bytes); 
-}
-
-export function writeFileSync(path, data, optionsOrEncoding) {
-  const enc = typeof optionsOrEncoding === 'string' ? optionsOrEncoding : optionsOrEncoding?.encoding;
-  const bytes = toBytes(data, enc);
-  memCache.set(path, bytes);
-  idbSet(path, bytes);
-}
-
-export function appendFileSync(path, data, optionsOrEncoding) {
-  const enc = typeof optionsOrEncoding === 'string' ? optionsOrEncoding : optionsOrEncoding?.encoding;
-  const newBytes = toBytes(data, enc);
-  const existing = memCache.has(path) ? memCache.get(path) : new Uint8Array(0);
-  const merged = new Uint8Array(existing.length + newBytes.length);
-  merged.set(existing);
-  merged.set(newBytes, existing.length);
-  memCache.set(path, merged);
-  idbSet(path, merged);
-}
-
-export function unlinkSync(path) {
-  memCache.delete(path);
-  idbSet(path, null);
-}
-
-export function rmSync(path, options = {}) {
-  if (options.recursive) {
-    for (const key of [...memCache.keys()]) {
-      if (key === path || key.startsWith(path + '/')) {
-        memCache.delete(key);
-        idbSet(key, null);
-      }
-    }
-  } else {
-    unlinkSync(path);
-  }
-}
-
-export function mkdirSync(path, options = {}) {
-  if (options.recursive) {
-    // ensure all parents exist
-    const parts = path.split('/').filter(Boolean);
-    let cur = '';
-    for (const p of parts) {
-      cur += '/' + p;
-      if (!memCache.has(cur)) { memCache.set(cur, '__DIR__'); idbSet(cur, '__DIR__'); }
-    }
-  } else {
-    memCache.set(path, '__DIR__');
-    idbSet(path, '__DIR__');
-  }
-}
-
-export function readdirSync(path) {
-  const prefix = path.endsWith('/') ? path : path + '/';
-  return [...memCache.keys()]
-    .filter(k => k.startsWith(prefix) && k.slice(prefix.length).split('/').length === 1)
-    .map(k => k.slice(prefix.length));
-}
-
-export function statSync(path) {
-  if (!memCache.has(path)) throw Object.assign(new Error(`ENOENT: ${path}`), { code: 'ENOENT' });
-  const val = memCache.get(path);
-  const isDir = val === '__DIR__';
-  return {
-    isDirectory: () => isDir,
-    isFile: () => !isDir,
-    size: isDir ? 0 : val.length,
-  };
-}
-
-// ── fd stubs (journal uses these) ────────────────────────────────────────────
-
-const fdMap = new Map();
-let fdCounter = 10;
-
-export const constants = { O_WRONLY: 1, O_CREAT: 64, O_APPEND: 1024 };
-
-export function openSync(path, flags) {
-  const fd = fdCounter++;
-  const append = (flags & constants.O_APPEND) !== 0;
-  const existing = memCache.has(path) ? memCache.get(path) : new Uint8Array(0);
-  fdMap.set(fd, { path, data: append ? existing : new Uint8Array(0) });
-  return fd;
-}
-
-export function writeSync(fd, buf) {
-  const entry = fdMap.get(fd);
-  if (!entry) return;
-  const merged = new Uint8Array(entry.data.length + buf.length);
-  merged.set(entry.data);
-  merged.set(buf, entry.data.length);
-  entry.data = merged;
-}
-
-export function closeSync(fd) {
-  const entry = fdMap.get(fd);
-  if (!entry) return;
-  memCache.set(entry.path, entry.data);
-  idbSet(entry.path, entry.data);
-  fdMap.delete(fd);
-}
-
-export const ready = openDB().then(db => new Promise(resolve => {
-  const tx = db.transaction(STORE, 'readonly');
-  const req = tx.objectStore(STORE).openCursor();
-  req.onsuccess = e => {
-    const cursor = e.target.result;
-    if (!cursor) return resolve(true);
-    memCache.set(cursor.key, cursor.value);
-    cursor.continue();
-  };
-}));
-
-globalThis.__fsReady__ = ready; 
-
-export default {
-  existsSync, readFileSync, writeFileSync, appendFileSync,
-  unlinkSync, rmSync, mkdirSync, readdirSync, statSync,
-  openSync, writeSync, closeSync, constants, ready
-};

package/polyfills/node_fs/promises.js

@@ -1,4 +0,0 @@
-export async function readFile(){ throw new Error('node:fs/promises.readFile is not supported in browser'); }
-export async function writeFile(){ throw new Error('node:fs/promises.writeFile is not supported in browser'); }
-export async function unlink(){ throw new Error('node:fs/promises.unlink is not supported in browser'); }
-export default { readFile, writeFile, unlink };

package/polyfills/node_os/index.js

@@ -1,9 +0,0 @@
-export function totalmem(){ try{ return navigator?.deviceMemory? navigator.deviceMemory*1024*1024 : 1024*1024*1024; }catch(e){return 1024*1024*1024;} }
-export function freemem(){ return Math.floor(totalmem()*0.5); }
-export function cpus(){ return [{ model: 'web-cpu', speed: 1000 }]; }
-export function platform(){ return 'browser'; }
-export function type(){ return 'web'; }
-export function arch(){ return 'x86_64'; }
-export function release(){ return 'web-release'; }
-export function uptime(){ return Math.floor(performance.now()/1000); }
-export default { totalmem, freemem, cpus, platform, type, arch, release, uptime };

package/polyfills/node_path/index.js

@@ -1,28 +0,0 @@
-export const posix = {
-  basename(p) { const parts = p.split('/').filter(Boolean); return parts.length ? parts[parts.length - 1] : ''; },
-  dirname(p) { if (!p) return '.'; const parts = p.split('/').filter(Boolean); parts.pop(); return parts.length ? '/' + parts.join('/') : '/'; },
-  join(...parts) { return parts.join('/').replace(/\/+/g, '/'); },
-  resolve(...parts) { // naive resolve
-    const joined = parts.join('/');
-    if (joined.startsWith('/')) return joined;
-    return '/' + joined;
-  },
-  normalize(p) {
-    const parts = p.split('/');
-    const stack = [];
-    for (const part of parts) {
-      if (part === '..') stack.pop();
-      else if (part && part !== '.') stack.push(part);
-    }
-    return (p.startsWith('/') ? '/' : '') + stack.join('/') || '.';
-  }
-};
-export function basename(p) { return posix.basename(p); }
-export function dirname(p) { return posix.dirname(p); }
-export function resolve(...parts) { return posix.resolve(...parts); }
-export function join(...parts) {
-  return parts.join('/').replace(/\/+/g, '/');
-}
-export function normalize(p) {
-  return posix.normalize(p);
-}

package/polyfills/node_vm/index.js

@@ -1,7 +0,0 @@
-// Minimal vm shim: execute code in Function scope (no sandbox guarantees)
-export default function runInVm(code, options){
-  const fn = new Function('exports','require','module','__filename','__dirname', code);
-  const module = { exports: {} };
-  fn(module.exports, ()=>{throw new Error('require not supported in vm shim')}, module, '', '');
-  return module.exports;
-}

package/polyfills/node_zlib/index.js

@@ -1,3 +0,0 @@
-export function gzipSync(buf){ return buf; }
-export function gunzipSync(buf){ return buf; }
-export default { gzipSync, gunzipSync };

package/polyfills/process.js

@@ -1,14 +0,0 @@
-globalThis.startedat = Date.now();
-export const process = {
-  env: { NODE_ENV: 'production' },
-  version: 'v20.0.0',
-  platform: 'browser',
-  browser: true,
-  argv: [],
-  cwd: () => '/',
-  exit: () => {},
-  nextTick: (fn, ...args) => queueMicrotask(() => fn(...args)),
-  memoryUsage: () => ({ rss: 0, heapTotal: 0, heapUsed: 0, external: 0 }),
-  uptime: () => (Date.now() - globalThis.startedat) / 1000,
-};
-globalThis.process = process;

package/polyfills/ssh2/index.js

@@ -1,75 +0,0 @@
-// ssh2 polyfill — browser stub. All methods throw NotImplemented.
-
-function notImpl(name) {
-  return function() {
-    throw new Error(`ssh2: ${name} not implemented in browser`);
-  };
-}
-
-// ── Client ────────────────────────────────────────────────────────────────────
-
-export class Client {
-  connect()              { notImpl('Client.connect')(); }
-  end()                  { notImpl('Client.end')(); }
-  destroy()              { notImpl('Client.destroy')(); }
-  exec()                 { notImpl('Client.exec')(); }
-  shell()                { notImpl('Client.shell')(); }
-  subsys()               { notImpl('Client.subsys')(); }
-  sftp()                 { notImpl('Client.sftp')(); }
-  forwardIn()            { notImpl('Client.forwardIn')(); }
-  unforwardIn()          { notImpl('Client.unforwardIn')(); }
-  forwardOut()           { notImpl('Client.forwardOut')(); }
-  openssh_noMoreSessions(){ notImpl('Client.openssh_noMoreSessions')(); }
-  openssh_forwardInStreamLocal() { notImpl('Client.openssh_forwardInStreamLocal')(); }
-  openssh_unforwardInStreamLocal(){ notImpl('Client.openssh_unforwardInStreamLocal')(); }
-  openssh_forwardOutStreamLocal() { notImpl('Client.openssh_forwardOutStreamLocal')(); }
-  on()                   { return this; }
-  once()                 { return this; }
-  off()                  { return this; }
-  emit()                 { return false; }
-  removeListener()       { return this; }
-}
-
-// ── Server ────────────────────────────────────────────────────────────────────
-
-export class Server {
-  constructor()          { notImpl('Server constructor')(); }
-  listen()               { notImpl('Server.listen')(); }
-  close()                { notImpl('Server.close')(); }
-  on()                   { return this; }
-  once()                 { return this; }
-  off()                  { return this; }
-  emit()                 { return false; }
-  removeListener()       { return this; }
-}
-
-// ── utils ─────────────────────────────────────────────────────────────────────
-
-export const utils = {
-  generateKeyPair:       notImpl('utils.generateKeyPair'),
-  generateKeyPairSync:   notImpl('utils.generateKeyPairSync'),
-  parseKey:              notImpl('utils.parseKey'),
-  parsePrivateKey:       notImpl('utils.parsePrivateKey'),
-  parsePublicKey:        notImpl('utils.parsePublicKey'),
-  decryptKey:            notImpl('utils.decryptKey'),
-  sftp: {
-    OPEN_MODE:  {},
-    STATUS_CODE: {},
-    flagsToString: notImpl('utils.sftp.flagsToString'),
-    stringToFlags:  notImpl('utils.sftp.stringToFlags'),
-  },
-};
-
-// ── HTTPAgent stubs ───────────────────────────────────────────────────────────
-
-export class HTTPAgent {
-  constructor() { notImpl('HTTPAgent constructor')(); }
-}
-
-export class HTTPSAgent {
-  constructor() { notImpl('HTTPSAgent constructor')(); }
-}
-
-// ── default export (mirrors ssh2 CommonJS shape) ─────────────────────────────
-
-export default { Client, Server, utils, HTTPAgent, HTTPSAgent };