@scelar/nodepod 1.0.0

package/src/polyfills/punycode.ts

@@ -0,0 +1,159 @@
+// Punycode/IDNA encoding for internationalized domain names (deprecated but still required by some packages)
+
+
+const BASE = 36;
+const TMIN = 1;
+const TMAX = 26;
+const SKEW = 38;
+const DAMP = 700;
+const INITIAL_BIAS = 72;
+const INITIAL_N = 128;
+const DELIMITER = "-";
+
+function adapt(delta: number, numPoints: number, firstTime: boolean): number {
+  let d = firstTime ? Math.floor(delta / DAMP) : delta >> 1;
+  d += Math.floor(d / numPoints);
+  let k = 0;
+  while (d > ((BASE - TMIN) * TMAX) >> 1) {
+    d = Math.floor(d / (BASE - TMIN));
+    k += BASE;
+  }
+  return Math.floor(k + ((BASE - TMIN + 1) * d) / (d + SKEW));
+}
+
+function basicToDigit(cp: number): number {
+  if (cp - 48 < 10) return cp - 22;
+  if (cp - 65 < 26) return cp - 65;
+  if (cp - 97 < 26) return cp - 97;
+  return BASE;
+}
+
+function digitToBasic(digit: number, flag: boolean): number {
+  return digit + 22 + 75 * (digit < 26 ? 1 : 0) - ((flag ? 1 : 0) << 5);
+}
+
+export function decode(input: string): string {
+  const output: number[] = [];
+  let i = 0;
+  let n = INITIAL_N;
+  let bias = INITIAL_BIAS;
+
+  let basic = input.lastIndexOf(DELIMITER);
+  if (basic < 0) basic = 0;
+
+  for (let j = 0; j < basic; ++j) {
+    output.push(input.charCodeAt(j));
+  }
+
+  let index = basic > 0 ? basic + 1 : 0;
+
+  while (index < input.length) {
+    const oldi = i;
+    let w = 1;
+    let k = BASE;
+
+    while (true) {
+      if (index >= input.length) throw new RangeError("Invalid input");
+      const digit = basicToDigit(input.charCodeAt(index++));
+      if (digit >= BASE) throw new RangeError("Invalid input");
+      if (digit > Math.floor((0x7fffffff - i) / w)) throw new RangeError("Overflow");
+      i += digit * w;
+      const t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;
+      if (digit < t) break;
+      if (w > Math.floor(0x7fffffff / (BASE - t))) throw new RangeError("Overflow");
+      w *= BASE - t;
+      k += BASE;
+    }
+
+    const out = output.length + 1;
+    bias = adapt(i - oldi, out, oldi === 0);
+    if (Math.floor(i / out) > 0x7fffffff - n) throw new RangeError("Overflow");
+    n += Math.floor(i / out);
+    i %= out;
+    output.splice(i++, 0, n);
+  }
+
+  return String.fromCodePoint(...output);
+}
+
+export function encode(input: string): string {
+  const output: string[] = [];
+  const inputCodes = Array.from(input).map((c) => c.codePointAt(0)!);
+  let n = INITIAL_N;
+  let delta = 0;
+  let bias = INITIAL_BIAS;
+
+  for (const cp of inputCodes) {
+    if (cp < 0x80) output.push(String.fromCharCode(cp));
+  }
+
+  let h = output.length;
+  const b = h;
+  if (b > 0) output.push(DELIMITER);
+
+  while (h < inputCodes.length) {
+    let m = 0x7fffffff;
+    for (const cp of inputCodes) {
+      if (cp >= n && cp < m) m = cp;
+    }
+
+    if (m - n > Math.floor((0x7fffffff - delta) / (h + 1)))
+      throw new RangeError("Overflow");
+    delta += (m - n) * (h + 1);
+    n = m;
+
+    for (const cp of inputCodes) {
+      if (cp < n && ++delta > 0x7fffffff) throw new RangeError("Overflow");
+      if (cp === n) {
+        let q = delta;
+        let k = BASE;
+        while (true) {
+          const t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias;
+          if (q < t) break;
+          output.push(String.fromCharCode(digitToBasic(t + ((q - t) % (BASE - t)), false)));
+          q = Math.floor((q - t) / (BASE - t));
+          k += BASE;
+        }
+        output.push(String.fromCharCode(digitToBasic(q, false)));
+        bias = adapt(delta, h + 1, h === b);
+        delta = 0;
+        ++h;
+      }
+    }
+
+    ++delta;
+    ++n;
+  }
+
+  return output.join("");
+}
+
+export function toUnicode(domain: string): string {
+  return domain
+    .split(".")
+    .map((label) =>
+      label.startsWith("xn--") ? decode(label.slice(4)) : label,
+    )
+    .join(".");
+}
+
+export function toASCII(domain: string): string {
+  return domain
+    .split(".")
+    .map((label) => {
+      if (/[^\x00-\x7E]/.test(label)) {
+        return "xn--" + encode(label);
+      }
+      return label;
+    })
+    .join(".");
+}
+
+export const ucs2 = {
+  decode: (str: string): number[] => Array.from(str).map((c) => c.codePointAt(0)!),
+  encode: (codePoints: number[]): string => String.fromCodePoint(...codePoints),
+};
+
+export const version = "2.3.1";
+
+export default { decode, encode, toUnicode, toASCII, ucs2, version };

package/src/polyfills/querystring.ts

@@ -0,0 +1,93 @@
+// Querystring parse/stringify/escape/unescape
+
+
+export type ParsedQuery = Record<string, string | string[]>;
+
+// supports duplicate keys (values become arrays) and custom separators
+export function parse(
+  input: string,
+  pairSep: string = '&',
+  kvSep: string = '=',
+  options?: { maxKeys?: number }
+): ParsedQuery {
+  const output: ParsedQuery = {};
+  if (!input || typeof input !== 'string') return output;
+
+  const ceiling = options?.maxKeys || 1000;
+  const segments = input.split(pairSep);
+  const limit = ceiling > 0 ? Math.min(segments.length, ceiling) : segments.length;
+
+  for (let i = 0; i < limit; i++) {
+    const segment = segments[i];
+    const eqPos = segment.indexOf(kvSep);
+    let k: string;
+    let v: string;
+
+    if (eqPos >= 0) {
+      k = decodeURIComponent(segment.substring(0, eqPos).replace(/\+/g, ' '));
+      v = decodeURIComponent(segment.substring(eqPos + 1).replace(/\+/g, ' '));
+    } else {
+      k = decodeURIComponent(segment.replace(/\+/g, ' '));
+      v = '';
+    }
+
+    if (k in output) {
+      const prev = output[k];
+      if (Array.isArray(prev)) {
+        prev.push(v);
+      } else {
+        output[k] = [prev, v];
+      }
+    } else {
+      output[k] = v;
+    }
+  }
+
+  return output;
+}
+
+export function stringify(
+  obj: Record<string, string | string[] | number | boolean | undefined>,
+  pairSep: string = '&',
+  kvSep: string = '='
+): string {
+  if (!obj || typeof obj !== 'object') return '';
+
+  const parts: string[] = [];
+
+  for (const [key, val] of Object.entries(obj)) {
+    if (val === undefined) continue;
+    const encodedKey = encodeURIComponent(key);
+
+    if (Array.isArray(val)) {
+      for (const item of val) {
+        parts.push(`${encodedKey}${kvSep}${encodeURIComponent(String(item))}`);
+      }
+    } else {
+      parts.push(`${encodedKey}${kvSep}${encodeURIComponent(String(val))}`);
+    }
+  }
+
+  return parts.join(pairSep);
+}
+
+export function escape(text: string): string {
+  return encodeURIComponent(text);
+}
+
+export function unescape(text: string): string {
+  return decodeURIComponent(text.replace(/\+/g, ' '));
+}
+
+// Node.js compatibility aliases
+export const encode = stringify;
+export const decode = parse;
+
+export default {
+  parse,
+  stringify,
+  escape,
+  unescape,
+  encode,
+  decode,
+};

package/src/polyfills/quic.ts

@@ -0,0 +1,118 @@
+// stub - not available in browser
+
+
+import { EventEmitter } from "./events";
+
+/* ------------------------------------------------------------------ */
+/*  QuicEndpoint                                                       */
+/* ------------------------------------------------------------------ */
+
+export interface QuicEndpoint extends EventEmitter {
+  close(): void;
+  destroy(_err?: Error): void;
+  readonly address: { address: string; family: string; port: number };
+}
+
+interface QuicEndpointConstructor {
+  new (_opts?: object): QuicEndpoint;
+  (this: any, _opts?: object): void;
+  prototype: any;
+}
+
+export const QuicEndpoint = function QuicEndpoint(this: any, _opts?: object) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as QuicEndpointConstructor;
+
+Object.setPrototypeOf(QuicEndpoint.prototype, EventEmitter.prototype);
+
+QuicEndpoint.prototype.close = function close(this: any): void {
+  this.emit("close");
+};
+
+QuicEndpoint.prototype.destroy = function destroy(this: any, _err?: Error): void {
+  this.emit("close");
+};
+
+Object.defineProperty(QuicEndpoint.prototype, "address", {
+  get: function(this: any): { address: string; family: string; port: number } {
+    return { address: "0.0.0.0", family: "IPv4", port: 0 };
+  },
+  configurable: true,
+});
+
+/* ------------------------------------------------------------------ */
+/*  QuicSession                                                        */
+/* ------------------------------------------------------------------ */
+
+export interface QuicSession extends EventEmitter {
+  close(): void;
+  destroy(_err?: Error): void;
+  readonly destroyed: boolean;
+}
+
+interface QuicSessionConstructor {
+  new (): QuicSession;
+  (this: any): void;
+  prototype: any;
+}
+
+export const QuicSession = function QuicSession(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as QuicSessionConstructor;
+
+Object.setPrototypeOf(QuicSession.prototype, EventEmitter.prototype);
+
+QuicSession.prototype.close = function close(this: any): void {
+  this.emit("close");
+};
+
+QuicSession.prototype.destroy = function destroy(this: any, _err?: Error): void {
+  this.emit("close");
+};
+
+Object.defineProperty(QuicSession.prototype, "destroyed", {
+  get: function(this: any): boolean {
+    return false;
+  },
+  configurable: true,
+});
+
+/* ------------------------------------------------------------------ */
+/*  QuicStream                                                         */
+/* ------------------------------------------------------------------ */
+
+export interface QuicStream extends EventEmitter {
+  readonly id: number;
+}
+
+interface QuicStreamConstructor {
+  new (): QuicStream;
+  (this: any): void;
+  prototype: any;
+}
+
+export const QuicStream = function QuicStream(this: any) {
+  if (!this) return;
+  EventEmitter.call(this);
+} as unknown as QuicStreamConstructor;
+
+Object.setPrototypeOf(QuicStream.prototype, EventEmitter.prototype);
+
+Object.defineProperty(QuicStream.prototype, "id", {
+  get: function(this: any): number {
+    return 0;
+  },
+  configurable: true,
+});
+
+/* ------------------------------------------------------------------ */
+/*  Default export                                                     */
+/* ------------------------------------------------------------------ */
+
+export default {
+  QuicEndpoint,
+  QuicSession,
+  QuicStream,
+};

package/src/polyfills/readdirp.ts

@@ -0,0 +1,229 @@
+// Recursive directory listing polyfill (readdirp-compatible) on MemoryVolume
+
+
+import type { MemoryVolume, FileStat } from "../memory-volume";
+import { setSharedVolume, getSharedVolume } from "./volume-registry";
+
+
+export function setVolume(vol: MemoryVolume): void {
+  setSharedVolume(vol);
+}
+
+
+export interface ScanOptions {
+  root?: string;
+  fileFilter?: string | string[] | ((entry: ScanEntry) => boolean);
+  directoryFilter?: string | string[] | ((entry: ScanEntry) => boolean);
+  depth?: number;
+  type?: "files" | "directories" | "files_directories" | "all";
+  lstat?: boolean;
+  alwaysStat?: boolean;
+}
+
+export interface ScanEntry {
+  path: string;
+  fullPath: string;
+  basename: string;
+  stats?: FileStat;
+  dirent?: {
+    isFile(): boolean;
+    isDirectory(): boolean;
+    name: string;
+  };
+}
+
+// collects entries synchronously, yields asynchronously
+
+interface DirectoryScanner {
+  cfg: ScanOptions;
+  rootDir: string;
+  results: ScanEntry[];
+  scanned: boolean;
+  handlerMap: Map<string, Array<(...args: unknown[]) => void>>;
+  [Symbol.asyncIterator](): AsyncIterableIterator<ScanEntry>;
+  toArray(): Promise<ScanEntry[]>;
+  on(event: string, handler: (...args: unknown[]) => void): this;
+  once(event: string, handler: (...args: unknown[]) => void): this;
+  off(event: string, handler: (...args: unknown[]) => void): this;
+  fireEvent(event: string, ...args: unknown[]): void;
+  runScan(): void;
+  crawl(dir: string, level: number, relative: string): void;
+  applyFilter(entry: ScanEntry, filter?: string | string[] | ((e: ScanEntry) => boolean)): boolean;
+  globMatch(filename: string, pattern: string): boolean;
+}
+
+interface DirectoryScannerConstructor {
+  new (root: string, cfg?: ScanOptions): DirectoryScanner;
+  (this: any, root: string, cfg?: ScanOptions): void;
+  prototype: any;
+}
+
+const DirectoryScanner = function DirectoryScanner(this: any, root: string, cfg: ScanOptions = {}) {
+  if (!this) return;
+  this.rootDir = root;
+  this.cfg = cfg;
+  this.results = [];
+  this.scanned = false;
+  this.handlerMap = new Map<string, Array<(...args: unknown[]) => void>>();
+} as unknown as DirectoryScannerConstructor;
+
+DirectoryScanner.prototype[Symbol.asyncIterator] = async function*(this: any): AsyncIterableIterator<ScanEntry> {
+  this.runScan();
+  for (const entry of this.results) yield entry;
+};
+
+DirectoryScanner.prototype.toArray = async function toArray(this: any): Promise<ScanEntry[]> {
+  this.runScan();
+  return [...this.results];
+};
+
+DirectoryScanner.prototype.on = function on(this: any, event: string, handler: (...args: unknown[]) => void): any {
+  if (event === "data") {
+    setTimeout(() => {
+      this.runScan();
+      for (const entry of this.results) handler(entry);
+      this.fireEvent("end");
+    }, 0);
+  } else {
+    if (!this.handlerMap.has(event)) this.handlerMap.set(event, []);
+    this.handlerMap.get(event)!.push(handler);
+  }
+  return this;
+};
+
+DirectoryScanner.prototype.once = function once(this: any, event: string, handler: (...args: unknown[]) => void): any {
+  const self = this;
+  const wrapped = (...args: unknown[]) => {
+    handler(...args);
+    self.off(event, wrapped);
+  };
+  return this.on(event, wrapped);
+};
+
+DirectoryScanner.prototype.off = function off(this: any, event: string, handler: (...args: unknown[]) => void): any {
+  const arr = this.handlerMap.get(event);
+  if (arr) {
+    const idx = arr.indexOf(handler);
+    if (idx !== -1) arr.splice(idx, 1);
+  }
+  return this;
+};
+
+DirectoryScanner.prototype.fireEvent = function fireEvent(this: any, event: string, ...args: unknown[]): void {
+  const arr = this.handlerMap.get(event);
+  if (arr) for (const fn of arr) fn(...args);
+};
+
+DirectoryScanner.prototype.runScan = function runScan(this: any): void {
+  if (this.scanned) return;
+  this.scanned = true;
+  this.crawl(this.rootDir, 0, "");
+};
+
+DirectoryScanner.prototype.crawl = function crawl(this: any, dir: string, level: number, relative: string): void {
+  const vol = getSharedVolume();
+  if (!vol) return;
+  if (this.cfg.depth !== undefined && level > this.cfg.depth) return;
+
+  let children: string[];
+  try {
+    children = vol.readdirSync(dir);
+  } catch {
+    return;
+  }
+
+  for (const name of children) {
+    const absolute = dir === "/" ? "/" + name : dir + "/" + name;
+    const rel = relative ? relative + "/" + name : name;
+
+    let st: FileStat;
+    try {
+      st = vol.statSync(absolute);
+    } catch {
+      continue;
+    }
+
+    const isDir = st.isDirectory();
+
+    const entry: ScanEntry = {
+      path: rel,
+      fullPath: absolute,
+      basename: name,
+      stats: this.cfg.alwaysStat ? st : undefined,
+      dirent: {
+        isFile: () => !isDir,
+        isDirectory: () => isDir,
+        name,
+      },
+    };
+
+    const category = this.cfg.type || "files";
+
+    if (isDir) {
+      if (!this.applyFilter(entry, this.cfg.directoryFilter)) continue;
+
+      if (
+        category === "directories" ||
+        category === "files_directories" ||
+        category === "all"
+      ) {
+        this.results.push(entry);
+      }
+      this.crawl(absolute, level + 1, rel);
+    } else {
+      if (
+        category === "files" ||
+        category === "files_directories" ||
+        category === "all"
+      ) {
+        if (this.applyFilter(entry, this.cfg.fileFilter)) {
+          this.results.push(entry);
+        }
+      }
+    }
+  }
+};
+
+DirectoryScanner.prototype.applyFilter = function applyFilter(
+  this: any,
+  entry: ScanEntry,
+  filter?: string | string[] | ((e: ScanEntry) => boolean),
+): boolean {
+  if (!filter) return true;
+
+  if (typeof filter === "function") return filter(entry);
+
+  const patterns = Array.isArray(filter) ? filter : [filter];
+  for (const pat of patterns) {
+    if (pat.startsWith("!")) {
+      if (this.globMatch(entry.basename, pat.slice(1))) return false;
+    } else if (this.globMatch(entry.basename, pat)) {
+      return true;
+    }
+  }
+  // If every pattern was a negation and none matched, the entry is allowed
+  return patterns.length === 0 || patterns.every((p: string) => p.startsWith("!"));
+};
+
+DirectoryScanner.prototype.globMatch = function globMatch(filename: string, pattern: string): boolean {
+  if (pattern === "*") return true;
+  if (pattern.startsWith("*.")) return filename.endsWith(pattern.slice(1));
+  if (pattern.endsWith("*")) return filename.startsWith(pattern.slice(0, -1));
+  return filename === pattern;
+};
+
+export default function readdirp(
+  root: string,
+  options?: ScanOptions,
+): DirectoryScanner {
+  return new DirectoryScanner(root, options);
+}
+
+export async function readdirpPromise(
+  root: string,
+  options?: ScanOptions,
+): Promise<ScanEntry[]> {
+  return new DirectoryScanner(root, options).toArray();
+}
+
+export { readdirp, DirectoryScanner };