thebird 1.2.79 → 1.2.81

package/docs/shell-node-stdlib.js

@@ -0,0 +1,103 @@
+const COLORS = { string: '\x1b[32m', number: '\x1b[33m', boolean: '\x1b[33m', bigint: '\x1b[33m', null: '\x1b[1m', undefined: '\x1b[90m', symbol: '\x1b[35m', regexp: '\x1b[31m', date: '\x1b[35m', special: '\x1b[36m' };
+const RESET = '\x1b[0m';
+const paint = (s, c, on) => on ? c + s + RESET : s;
+
+function inspectPrimitive(v, colors) {
+  if (v === null) return paint('null', COLORS.null, colors);
+  if (v === undefined) return paint('undefined', COLORS.undefined, colors);
+  const t = typeof v;
+  if (t === 'string') return paint("'" + v.replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "'", COLORS.string, colors);
+  if (t === 'bigint') return paint(String(v) + 'n', COLORS.bigint, colors);
+  if (t === 'number' || t === 'boolean') return paint(String(v), COLORS[t], colors);
+  if (t === 'symbol') return paint(v.toString(), COLORS.symbol, colors);
+  if (t === 'function') return paint('[Function' + (v.name ? ': ' + v.name : ' (anonymous)') + ']', COLORS.special, colors);
+  return null;
+}
+
+export function inspect(v, opts = {}, depth = 0, seen = new Map(), refCount = { n: 0 }) {
+  const colors = !!opts.colors;
+  const prim = inspectPrimitive(v, colors);
+  if (prim !== null) return prim;
+  if (v instanceof Date) return paint(v.toISOString(), COLORS.date, colors);
+  if (v instanceof RegExp) return paint(v.toString(), COLORS.regexp, colors);
+  if (v instanceof Error) return v.stack || (v.name + ': ' + v.message);
+  if (seen.has(v)) { const id = seen.get(v); if (id.ref == null) id.ref = ++refCount.n; return '[Circular *' + id.ref + ']'; }
+  const entry = { ref: null }; seen.set(v, entry);
+  const maxDepth = opts.depth ?? 2;
+  if (depth > maxDepth) return Array.isArray(v) ? '[Array]' : '[Object]';
+  if (Array.isArray(v)) {
+    if (!v.length) return '[]';
+    return '[ ' + v.map(x => inspect(x, opts, depth + 1, seen, refCount)).join(', ') + ' ]';
+  }
+  if (v instanceof Map) {
+    const entries = [...v.entries()].map(([k, val]) => inspect(k, opts, depth + 1, seen, refCount) + ' => ' + inspect(val, opts, depth + 1, seen, refCount));
+    return 'Map(' + v.size + ')' + (v.size ? ' { ' + entries.join(', ') + ' }' : ' {}');
+  }
+  if (v instanceof Set) {
+    const items = [...v].map(x => inspect(x, opts, depth + 1, seen, refCount));
+    return 'Set(' + v.size + ')' + (v.size ? ' { ' + items.join(', ') + ' }' : ' {}');
+  }
+  if (v instanceof Uint8Array) {
+    const hex = [...v.slice(0, 16)].map(b => b.toString(16).padStart(2, '0')).join(' ');
+    return '<Buffer ' + hex + (v.length > 16 ? ' ... ' + (v.length - 16) + ' more bytes' : '') + '>';
+  }
+  const keys = opts.showHidden ? Object.getOwnPropertyNames(v) : Object.keys(v);
+  const syms = Object.getOwnPropertySymbols(v);
+  if (!keys.length && !syms.length) return '{}';
+  const parts = keys.map(k => {
+    const ks = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : "'" + k + "'";
+    return ks + ': ' + inspect(v[k], opts, depth + 1, seen, refCount);
+  }).concat(syms.map(s => '[' + s.toString() + ']: ' + inspect(v[s], opts, depth + 1, seen, refCount)));
+  const ctor = v.constructor && v.constructor !== Object ? v.constructor.name + ' ' : '';
+  const body = ctor + '{ ' + parts.join(', ') + ' }';
+  return entry.ref != null ? '<ref *' + entry.ref + '> ' + body : body;
+}
+
+export function format(...args) {
+  if (!args.length) return '';
+  const fmt = args[0];
+  if (typeof fmt !== 'string') return args.map(a => typeof a === 'object' ? inspect(a) : String(a)).join(' ');
+  let i = 1;
+  const out = fmt.replace(/%[sdifjoO%]/g, m => {
+    if (m === '%%') return '%';
+    if (i >= args.length) return m;
+    const a = args[i++];
+    if (m === '%s') return String(a);
+    if (m === '%d' || m === '%i') return String(parseInt(a, 10));
+    if (m === '%f') return String(parseFloat(a));
+    if (m === '%j') return JSON.stringify(a);
+    if (m === '%o' || m === '%O') return inspect(a);
+    return m;
+  });
+  const extra = args.slice(i).map(a => typeof a === 'object' ? inspect(a) : String(a));
+  return extra.length ? out + ' ' + extra.join(' ') : out;
+}
+
+export { createHash } from './shell-node-crypto.js';
+
+let fflatePromise = null;
+async function getFflate() {
+  if (!fflatePromise) fflatePromise = import('https://esm.sh/fflate@0.8.2/es2022/fflate.mjs').then(m => m.gzipSync ? m : (m.default && m.default.gzipSync ? m.default : m));
+  return fflatePromise;
+}
+let fflateSync = null;
+export async function preloadFflate() { fflateSync = await getFflate(); return fflateSync; }
+
+export function createZlib(Buf) {
+  const need = () => { if (!fflateSync) throw new Error('zlib sync: preloadFflate() must run before sync zlib calls (auto-preloaded on node entry)'); return fflateSync; };
+  return {
+    gzipSync: b => Buf.from(need().gzipSync(b instanceof Uint8Array ? b : new TextEncoder().encode(String(b)))),
+    gunzipSync: b => Buf.from(need().gunzipSync(b)),
+    deflateSync: b => Buf.from(need().deflateSync(b instanceof Uint8Array ? b : new TextEncoder().encode(String(b)))),
+    inflateSync: b => Buf.from(need().inflateSync(b)),
+    deflateRawSync: b => Buf.from(need().deflateSync(b, { raw: true }) || need().deflateSync(b)),
+    inflateRawSync: b => Buf.from(need().inflateSync(b, { raw: true }) || need().inflateSync(b)),
+    gzip: async (buf, cb) => { try { const p = await getFflate(); const out = Buf.from(p.gzipSync(buf instanceof Uint8Array ? buf : new TextEncoder().encode(String(buf)))); if (cb) cb(null, out); return out; } catch (e) { if (cb) cb(e); else throw e; } },
+    gunzip: async (buf, cb) => { try { const p = await getFflate(); const out = Buf.from(p.gunzipSync(buf)); if (cb) cb(null, out); return out; } catch (e) { if (cb) cb(e); else throw e; } },
+    deflate: async (buf, cb) => { const p = await getFflate(); const out = Buf.from(p.deflateSync(buf instanceof Uint8Array ? buf : new TextEncoder().encode(String(buf)))); if (cb) cb(null, out); return out; },
+    inflate: async (buf, cb) => { const p = await getFflate(); const out = Buf.from(p.inflateSync(buf)); if (cb) cb(null, out); return out; },
+    createGzip: () => ({ pipe: () => {}, on: () => {}, write: () => {}, end: () => {} }),
+    createGunzip: () => ({ pipe: () => {}, on: () => {}, write: () => {}, end: () => {} }),
+    constants: { Z_NO_FLUSH: 0, Z_PARTIAL_FLUSH: 1, Z_SYNC_FLUSH: 2, Z_FULL_FLUSH: 3, Z_FINISH: 4, Z_BLOCK: 5, Z_TREES: 6, Z_OK: 0, Z_STREAM_END: 1 },
+  };
+}

package/docs/shell-node-streams.js

@@ -0,0 +1,66 @@
+function makeEmitter(){
+  const h={};
+  return {
+    on(e,f){(h[e]=h[e]||[]).push(f);return this;},
+    once(e,f){const w=(...a)=>{this.off(e,w);f(...a);};return this.on(e,w);},
+    off(e,f){h[e]=(h[e]||[]).filter(x=>x!==f);return this;},
+    removeListener(e,f){return this.off(e,f);},
+    removeAllListeners(e){if(e)delete h[e];else for(const k of Object.keys(h))delete h[k];return this;},
+    emit(e,...a){for(const f of(h[e]||[]).slice())f(...a);return(h[e]||[]).length>0;},
+    listenerCount(e){return(h[e]||[]).length;},
+    _h:h,
+  };
+}
+
+class Readable{
+  constructor(opts={}){
+    Object.assign(this,makeEmitter());
+    this._q=[];this._ended=false;this._flowing=null;this._paused=false;this._destroyed=false;
+    this.readable=true;this.readableHighWaterMark=opts.highWaterMark??16384;this.readableEnded=false;this.readableObjectMode=!!opts.objectMode;
+    this._read=opts.read||(()=>{});this._encoding=null;
+  }
+  push(chunk){if(chunk===null){this._ended=true;queueMicrotask(()=>this._drain());return false;}this._q.push(chunk);queueMicrotask(()=>this._drain());return this._q.length<this.readableHighWaterMark;}
+  read(n){if(!this._q.length)return null;return n?this._q.shift():this._q.shift();}
+  _drain(){if(this._paused||this._destroyed)return;while(this._q.length){const c=this._q.shift();const data=this._encoding&&c instanceof Uint8Array?new TextDecoder(this._encoding).decode(c):c;this.emit('data',data);}if(this._ended&&!this.readableEnded){this.readableEnded=true;this.emit('end');}}
+  pause(){this._paused=true;return this;}
+  resume(){this._paused=false;queueMicrotask(()=>this._drain());return this;}
+  pipe(dest){this.on('data',c=>{if(dest.write(c)===false)this.pause();});this.on('end',()=>dest.end?.());dest.on?.('drain',()=>this.resume());return dest;}
+  unpipe(){return this;}
+  setEncoding(enc){this._encoding=enc;return this;}
+  destroy(e){this._destroyed=true;if(e)this.emit('error',e);this.emit('close');return this;}
+  [Symbol.asyncIterator](){const self=this;return{async next(){if(self._q.length)return{value:self._q.shift(),done:false};if(self._ended)return{value:undefined,done:true};return new Promise(r=>{const onData=c=>{self.off('data',onData);self.off('end',onEnd);r({value:c,done:false});};const onEnd=()=>{self.off('data',onData);r({value:undefined,done:true});};self.on('data',onData);self.once('end',onEnd);});}};}
+}
+
+class Writable{
+  constructor(opts={}){
+    Object.assign(this,makeEmitter());
+    this._write=opts.write||((c,e,cb)=>cb());this.writable=true;this.writableEnded=false;this.writableFinished=false;this.writableHighWaterMark=opts.highWaterMark??16384;this._pending=0;
+  }
+  write(chunk,enc,cb){if(typeof enc==='function'){cb=enc;enc=null;}if(this.writableEnded){const e=Object.assign(new Error('write after end'),{code:'ERR_STREAM_WRITE_AFTER_END'});queueMicrotask(()=>cb?.(e));return false;}this._pending++;this._write(chunk,enc,err=>{this._pending--;cb?.(err);if(this._pending===0)this.emit('drain');});return this._pending<this.writableHighWaterMark;}
+  end(chunk,enc,cb){if(chunk!=null)this.write(chunk,enc);this.writableEnded=true;queueMicrotask(()=>{this.writableFinished=true;this.emit('finish');this.emit('close');cb?.();});return this;}
+  destroy(e){if(e)this.emit('error',e);this.emit('close');return this;}
+}
+
+class Duplex extends Readable{constructor(opts={}){super(opts);Object.assign(this,new Writable(opts));this._write=opts.write||((c,e,cb)=>cb());}write(...a){return Writable.prototype.write.call(this,...a);}end(...a){return Writable.prototype.end.call(this,...a);}}
+
+class Transform extends Duplex{
+  constructor(opts={}){super(opts);this._transform=opts.transform||((c,e,cb)=>cb(null,c));this._flush=opts.flush||(cb=>cb());this._write=(c,e,cb)=>{this._transform(c,e,(err,out)=>{if(err)return cb(err);if(out!=null)this.push(out);cb();});};const origEnd=this.end.bind(this);this.end=(...a)=>{this._flush((err,out)=>{if(out!=null)this.push(out);this.push(null);});return origEnd(...a);};}
+}
+
+class PassThrough extends Transform{constructor(opts){super({...opts,transform:(c,e,cb)=>cb(null,c)});}}
+
+function pipeline(...args){const cb=typeof args[args.length-1]==='function'?args.pop():null;const streams=args;let done=false;const fin=e=>{if(done)return;done=true;cb?.(e);};for(let i=0;i<streams.length-1;i++){const src=streams[i],dst=streams[i+1];src.on('error',fin);src.pipe(dst);}streams[streams.length-1].on('finish',()=>fin(null));streams[streams.length-1].on('error',fin);return streams[streams.length-1];}
+
+function finished(stream,cb){const onFin=()=>cb();const onErr=e=>cb(e);stream.on?.('finish',onFin);stream.on?.('end',onFin);stream.on?.('error',onErr);return()=>{stream.off?.('finish',onFin);stream.off?.('end',onFin);stream.off?.('error',onErr);};}
+
+export function makeStream(){
+  const mod={Readable,Writable,Duplex,Transform,PassThrough,pipeline,finished,promises:{pipeline:(...a)=>new Promise((res,rej)=>pipeline(...a,e=>e?rej(e):res())),finished:s=>new Promise((res,rej)=>finished(s,e=>e?rej(e):res()))}};
+  Readable.from=iter=>{const r=new Readable();(async()=>{try{for await(const c of iter)r.push(c);r.push(null);}catch(e){r.destroy(e);}})();return r;};
+  return mod;
+}
+
+export function extendFsStreams(fs,Buf){
+  fs.createReadStream=(path,opts={})=>{const r=new Readable();queueMicrotask(()=>{try{const data=fs.readFileSync(path);const buf=typeof data==='string'?Buf.from(data):data;const start=opts.start||0;const end=opts.end??buf.length;r.push(buf.slice(start,end));r.push(null);}catch(e){r.destroy(e);}});return r;};
+  fs.createWriteStream=(path,opts={})=>{const chunks=[];const w=new Writable({write:(c,e,cb)=>{chunks.push(typeof c==='string'?Buf.from(c):c);cb();}});w.on('finish',()=>{try{fs.writeFileSync(path,Buf.concat(chunks));}catch(e){w.emit('error',e);}});return w;};
+  return fs;
+}

package/docs/shell-node-tar.js

@@ -0,0 +1,47 @@
+const BLOCK=512;
+const readStr=(buf,o,len)=>{let e=o;while(e<o+len&&buf[e]!==0)e++;return new TextDecoder().decode(buf.slice(o,e));};
+const readOctal=(buf,o,len)=>{const s=readStr(buf,o,len).trim();return s?parseInt(s,8):0;};
+
+export function untar(data){
+  const buf=data instanceof Uint8Array?data:new Uint8Array(data);
+  const entries=[];let off=0;
+  while(off+BLOCK<=buf.length){
+    if(buf[off]===0&&buf[off+BLOCK-1]===0){off+=BLOCK;continue;}
+    const name=readStr(buf,off,100);
+    if(!name)break;
+    const mode=readOctal(buf,off+100,8);
+    const size=readOctal(buf,off+124,12);
+    const mtime=readOctal(buf,off+136,12);
+    const type=String.fromCharCode(buf[off+156]||0x30);
+    const prefix=readStr(buf,off+345,155);
+    const fullName=prefix?prefix+'/'+name:name;
+    const dataStart=off+BLOCK;
+    const dataEnd=dataStart+size;
+    const body=type==='0'||type==='\0'?buf.slice(dataStart,dataEnd):null;
+    entries.push({name:fullName,mode,size,mtime,type,data:body});
+    const padded=Math.ceil(size/BLOCK)*BLOCK;
+    off=dataStart+padded;
+  }
+  return entries;
+}
+
+export function makeTar(fs,fflate,Buf){
+  return{
+    async extract(data,dest='/'){
+      let bytes=data instanceof Uint8Array?data:new Uint8Array(data);
+      if(bytes[0]===0x1f&&bytes[1]===0x8b){bytes=fflate?.gunzipSync?fflate.gunzipSync(bytes):bytes;}
+      const entries=untar(bytes);
+      const out=[];
+      for(const e of entries){
+        if(!e.data&&e.type!=='5')continue;
+        const target=(dest.replace(/\/$/,'')+'/'+e.name).replace(/^\/+/,'/');
+        if(e.type==='5'){try{fs.mkdirSync(target,{recursive:true});}catch{}}
+        else{const parts=target.split('/');for(let i=1;i<parts.length;i++){const d=parts.slice(0,i).join('/');if(d&&!fs.existsSync(d)){try{fs.mkdirSync(d,{recursive:true});}catch{}}}fs.writeFileSync(target,Buf.from(e.data));}
+        out.push(target);
+      }
+      return out;
+    },
+    async list(data){let bytes=data instanceof Uint8Array?data:new Uint8Array(data);if(bytes[0]===0x1f&&bytes[1]===0x8b)bytes=fflate?.gunzipSync?fflate.gunzipSync(bytes):bytes;return untar(bytes).map(e=>e.name);},
+    untar,
+  };
+}

package/docs/shell-node-testrunner.js

@@ -0,0 +1,35 @@
+export function makeTestRunner(term){
+  const suites=[];let current=null;const results={pass:0,fail:0,skip:0,failures:[]};
+  const write=term?(s=>term.write(s)):(s=>console.log(s.replace(/\r\n/g,'')));
+  const color=(c,s)=>`\x1b[${c}m${s}\x1b[0m`;
+  async function runOne(name,fn,parentPath=''){
+    const path=(parentPath?parentPath+' > ':'')+name;
+    if(!fn){results.skip++;write(color(33,'  - '+path+' (skip)')+'\r\n');return;}
+    const t0=performance.now();
+    try{await fn(tctx(name,path));results.pass++;write(color(32,'  ✓ '+path)+` ${(performance.now()-t0).toFixed(1)}ms\r\n`);}
+    catch(e){results.fail++;results.failures.push({path,error:e});write(color(31,'  ✗ '+path+' — '+e.message)+'\r\n');}
+  }
+  function tctx(name,path){return{name,fullName:path,diagnostic(m){write(color(90,'    # '+m)+'\r\n');},skip(){throw Object.assign(new Error('skip'),{__skip:true});},todo(){throw Object.assign(new Error('todo'),{__todo:true});},signal:new AbortController().signal,plan(n){}};}
+  function test(name,optsOrFn,maybeFn){const fn=typeof optsOrFn==='function'?optsOrFn:maybeFn;const opts=typeof optsOrFn==='object'?optsOrFn:{};if(opts.skip)return runOne(name,null);if(opts.only){}if(current){current.tests.push({name,fn});return Promise.resolve();}return runOne(name,fn);}
+  function describe(name,fn){const prev=current;current={name,tests:[],parentPath:prev?prev.fullPath:'',fullPath:(prev?prev.fullPath+' > ':'')+name};try{fn(current);}finally{const c=current;current=prev;return(async()=>{for(const t of c.tests)await runOne(t.name,t.fn,c.fullPath);})();}}
+  const mock={
+    fn(impl){const calls=[];const mk=function(...a){calls.push({arguments:a,result:undefined,error:undefined,target:this});try{const r=impl?impl.apply(this,a):undefined;calls[calls.length-1].result=r;return r;}catch(e){calls[calls.length-1].error=e;throw e;}};mk.mock={calls,callCount(){return calls.length;},resetCalls(){calls.length=0;},restore(){}};return mk;},
+    method(obj,key,impl){const orig=obj[key];const m=mock.fn(impl||orig);obj[key]=m;m.mock.restore=()=>{obj[key]=orig;};return m;},
+    timers:{enable(){},reset(){},runAll(){},tick(){},restore(){}},
+  };
+  const api={test,describe,it:test,before:fn=>fn?.(),after:fn=>fn?.(),beforeEach:()=>{},afterEach:()=>{},mock,run(){},results,
+    async summarize(){write('\r\n'+color(1,`# tests ${results.pass+results.fail+results.skip}`)+'\r\n');write(color(32,`# pass ${results.pass}`)+'\r\n');write(color(31,`# fail ${results.fail}`)+'\r\n');write(color(33,`# skip ${results.skip}`)+'\r\n');return results.fail===0;},
+  };
+  return api;
+}
+
+export function makeTapReporter(term){
+  const w=term?(s=>term.write(s)):(s=>console.log(s));
+  let n=0;
+  return{
+    ok(name){w(`ok ${++n} - ${name}\r\n`);},
+    notOk(name,msg){w(`not ok ${++n} - ${name}\r\n  ---\r\n  error: ${msg}\r\n  ...\r\n`);},
+    plan(total){w(`1..${total}\r\n`);},
+    comment(m){w(`# ${m}\r\n`);},
+  };
+}

package/docs/shell-node-util-extras.js

@@ -0,0 +1,66 @@
+const ANSI_RE=/\x1b\[[0-9;]*[a-zA-Z]/g;
+const STYLE_CODES={reset:0,bold:1,dim:2,italic:3,underline:4,inverse:7,hidden:8,strikethrough:9,black:30,red:31,green:32,yellow:33,blue:34,magenta:35,cyan:36,white:37,gray:90,bgBlack:40,bgRed:41,bgGreen:42,bgYellow:43,bgBlue:44,bgMagenta:45,bgCyan:46,bgWhite:47};
+
+export function styleText(styles,text){
+  const arr=Array.isArray(styles)?styles:[styles];
+  const codes=arr.map(s=>STYLE_CODES[s]).filter(c=>c!=null);
+  if(!codes.length)return text;
+  return `\x1b[${codes.join(';')}m${text}\x1b[0m`;
+}
+
+export function stripVTControlCharacters(s){return String(s).replace(ANSI_RE,'');}
+
+export function getCallSites(frames=10){
+  const e=new Error();const lines=(e.stack||'').split('\n').slice(2,2+frames);
+  return lines.map(l=>{const m=l.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);return{functionName:m?.[1]||'<anonymous>',scriptName:m?.[2]||'',lineNumber:m?+m[3]:0,column:m?+m[4]:0,scriptId:'0'};});
+}
+
+export class MIMEType{
+  constructor(input){
+    const [essence,...paramParts]=String(input).split(';');
+    const [type,subtype]=essence.trim().split('/');
+    if(!type||!subtype)throw new TypeError('Invalid MIME: '+input);
+    this._type=type.toLowerCase();this._sub=subtype.toLowerCase();
+    this._params=new MIMEParams();
+    for(const p of paramParts){const [k,v]=p.split('=');if(k&&v)this._params.set(k.trim().toLowerCase(),v.trim().replace(/^["']|["']$/g,''));}
+  }
+  get type(){return this._type;}set type(v){this._type=String(v).toLowerCase();}
+  get subtype(){return this._sub;}set subtype(v){this._sub=String(v).toLowerCase();}
+  get essence(){return `${this._type}/${this._sub}`;}
+  get params(){return this._params;}
+  toString(){const p=[...this._params].map(([k,v])=>`${k}=${v}`).join(';');return this.essence+(p?';'+p:'');}
+}
+
+export class MIMEParams{
+  constructor(){this._m=new Map();}
+  get(k){return this._m.get(k);}
+  set(k,v){this._m.set(String(k).toLowerCase(),String(v));return this;}
+  delete(k){return this._m.delete(k);}
+  has(k){return this._m.has(k);}
+  *entries(){yield*this._m.entries();}
+  *keys(){yield*this._m.keys();}
+  *values(){yield*this._m.values();}
+  [Symbol.iterator](){return this._m[Symbol.iterator]();}
+}
+
+export function makeConsoleExtras(origConsole,term){
+  const write=term?(s=>term.write(s)):(s=>origConsole.log(s));
+  const timers=new Map();const counters=new Map();let groupDepth=0;const ind=()=>'  '.repeat(groupDepth);
+  return{
+    table(data,columns){if(!data||typeof data!=='object')return origConsole.log(data);const rows=Array.isArray(data)?data:Object.entries(data).map(([k,v])=>({'(index)':k,...(typeof v==='object'?v:{Values:v})}));if(!rows.length)return;const cols=columns||[...new Set(rows.flatMap(r=>Object.keys(r)))];const w=cols.map(c=>Math.max(c.length,...rows.map(r=>String(r[c]??'').length)));const line=(cells,pad)=>'│ '+cells.map((c,i)=>String(c??'').padEnd(w[i]))+' │\r\n';const sep=s=>s+cols.map((_,i)=>'─'.repeat(w[i]+2)).join(s==='├'?'┼':'─')+(s==='├'?'┤':'╯')+'\r\n';write('╭'+cols.map((_,i)=>'─'.repeat(w[i]+2)).join('─')+'╮\r\n');write('│ '+cols.map((c,i)=>c.padEnd(w[i])).join(' │ ')+' │\r\n');write('├'+cols.map((_,i)=>'─'.repeat(w[i]+2)).join('┼')+'┤\r\n');for(const r of rows)write('│ '+cols.map((c,i)=>String(r[c]??'').padEnd(w[i])).join(' │ ')+' │\r\n');write('╰'+cols.map((_,i)=>'─'.repeat(w[i]+2)).join('─')+'╯\r\n');},
+    group(label){if(label)write(ind()+label+'\r\n');groupDepth++;},
+    groupCollapsed(label){this.group(label);},
+    groupEnd(){groupDepth=Math.max(0,groupDepth-1);},
+    time(label='default'){timers.set(label,performance.now());},
+    timeEnd(label='default'){const t=timers.get(label);if(t==null)return;timers.delete(label);write(`${label}: ${(performance.now()-t).toFixed(3)}ms\r\n`);},
+    timeLog(label='default',...rest){const t=timers.get(label);if(t==null)return;write(`${label}: ${(performance.now()-t).toFixed(3)}ms ${rest.join(' ')}\r\n`);},
+    count(label='default'){const n=(counters.get(label)||0)+1;counters.set(label,n);write(`${label}: ${n}\r\n`);},
+    countReset(label='default'){counters.set(label,0);},
+    dir(v){write(JSON.stringify(v,null,2)+'\r\n');},
+    dirxml(v){this.dir(v);},
+    trace(...a){write('Trace: '+a.join(' ')+'\r\n'+new Error().stack+'\r\n');},
+    assert(cond,...msg){if(!cond)write('Assertion failed: '+msg.join(' ')+'\r\n');},
+    clear(){write('\x1b[2J\x1b[H');},
+    profile(){},profileEnd(){},timeStamp(){},
+  };
+}