visaljs 0.0.0-stage → 0.0.2

package/node/prelude/internal/crypto/random.js

@@ -0,0 +1,118 @@
+// node:crypto's random numbers (ADR 0018): Node's lib/internal/crypto/random.js over the
+// runtime's CSPRNG (an HMAC_DRBG seeded from the system). The asynchronous forms fill at the
+// call and call back from a timer, where Node's thread pool would.
+import { cryptoHostRandomUUID, cryptoRandomFill } from "visaljs:host";
+import { invalidArgType, outOfRange, validateFunction } from "../errors.js";
+import { isAnyArrayBuffer, isArrayBufferView, validateBoolean, validateNumber, validateObject } from "./util.js";
+
+const kMaxPossibleLength = 2147483647;
+const later = (fn) => setTimeout(fn, 0);
+
+function assertOffset(offset, elementSize, length) {
+  validateNumber(offset, "offset");
+  offset *= elementSize;
+  const maxLength = Math.min(length, kMaxPossibleLength);
+  if (Number.isNaN(offset) || offset > maxLength || offset < 0) throw outOfRange("offset", `>= 0 && <= ${maxLength}`, offset);
+  return offset >>> 0;
+}
+
+function assertSize(size, elementSize, offset, length) {
+  validateNumber(size, "size");
+  size *= elementSize;
+  if (Number.isNaN(size) || size > kMaxPossibleLength || size < 0) throw outOfRange("size", `>= 0 && <= ${kMaxPossibleLength}`, size);
+  if (size + offset > length) throw outOfRange("size + offset", `<= ${length}`, size + offset);
+  return size >>> 0;
+}
+
+function validateBuf(buf) {
+  if (!isAnyArrayBuffer(buf) && !isArrayBufferView(buf)) throw invalidArgType("buf", "an instance of ArrayBuffer or ArrayBufferView", buf);
+}
+
+export function randomBytes(size, callback) {
+  size = assertSize(size, 1, 0, Infinity);
+  if (callback !== undefined) validateFunction(callback, "callback");
+  const buf = Buffer.alloc(size);
+  cryptoRandomFill(buf, 0, size);
+  if (callback === undefined) return buf;
+  later(() => callback(null, buf));
+}
+
+export function randomFillSync(buf, offset = 0, size) {
+  validateBuf(buf);
+  const elementSize = buf.BYTES_PER_ELEMENT || 1;
+  offset = assertOffset(offset, elementSize, buf.byteLength);
+  if (size === undefined) size = buf.byteLength - offset;
+  else size = assertSize(size, elementSize, offset, buf.byteLength);
+  if (size === 0) return buf;
+  cryptoRandomFill(buf, offset, size);
+  return buf;
+}
+
+export function randomFill(buf, offset, size, callback) {
+  validateBuf(buf);
+  const elementSize = buf.BYTES_PER_ELEMENT || 1;
+  if (typeof offset === "function") {
+    callback = offset;
+    offset = 0;
+    size = buf.byteLength;
+  } else if (typeof size === "function") {
+    validateNumber(offset, "offset");
+    offset *= elementSize;
+    callback = size;
+    size = buf.byteLength - offset;
+  } else {
+    validateFunction(callback, "callback");
+  }
+  offset = assertOffset(offset, 1, buf.byteLength);
+  if (size === undefined) size = buf.byteLength - offset;
+  else size = assertSize(size, elementSize, offset, buf.byteLength);
+  if (size === 0) {
+    callback(null, buf);
+    return;
+  }
+  cryptoRandomFill(buf, offset, size);
+  later(() => callback(null, buf));
+}
+
+/* randomInt: 6 random bytes per attempt, from a cache, as Node draws them */
+const RAND_MAX = 0xffffffffffff;
+const randomCache = Buffer.alloc(6 * 1024);
+let randomCacheOffset = randomCache.length;
+
+export function randomInt(min, max, callback) {
+  const minNotSpecified = typeof max === "undefined" || typeof max === "function";
+  if (minNotSpecified) {
+    callback = max;
+    max = min;
+    min = 0;
+  }
+  const isSync = typeof callback === "undefined";
+  if (!isSync) validateFunction(callback, "callback");
+  if (!Number.isSafeInteger(min)) throw invalidArgType("min", "a safe integer", min);
+  if (!Number.isSafeInteger(max)) throw invalidArgType("max", "a safe integer", max);
+  if (max <= min) throw outOfRange("max", `greater than the value of "min" (${min})`, max);
+  const range = max - min;
+  if (!(range <= RAND_MAX)) throw outOfRange(`max${minNotSpecified ? "" : " - min"}`, `<= ${RAND_MAX}`, range);
+  const randLimit = RAND_MAX - (RAND_MAX % range);
+  for (;;) {
+    if (randomCacheOffset === randomCache.length) {
+      cryptoRandomFill(randomCache, 0, randomCache.length);
+      randomCacheOffset = 0;
+    }
+    const x = randomCache.readUIntBE(randomCacheOffset, 6);
+    randomCacheOffset += 6;
+    if (x < randLimit) {
+      const n = (x % range) + min;
+      if (isSync) return n;
+      process.nextTick(callback, undefined, n);
+      return;
+    }
+  }
+}
+
+export function randomUUID(options) {
+  if (options !== undefined) validateObject(options, "options");
+  const { disableEntropyCache = false } = options || {};
+  validateBoolean(disableEntropyCache, "options.disableEntropyCache");
+  return cryptoHostRandomUUID();
+}

package/node/prelude/internal/crypto/util.js

@@ -0,0 +1,76 @@
+// What node:crypto's parts share (ADR 0018): argument checks with Node's errors, encodings
+// through Buffer, and LazyTransform, the stream base of Hash, Hmac and the ciphers (a Transform
+// set up only when a stream property is first used, as Node's is).
+import { Transform } from "../../stream.js";
+import { codeError, invalidArgType } from "../errors.js";
+
+export const kHandle = Symbol("kHandle");
+export const kState = Symbol("kState");
+export const kFinalized = Symbol("kFinalized");
+
+export const isArrayBufferView = (v) => ArrayBuffer.isView(v);
+export const isAnyArrayBuffer = (v) => v instanceof ArrayBuffer || (typeof SharedArrayBuffer === "function" && v instanceof SharedArrayBuffer);
+
+/** An encoding Node's C++ takes (ParseEncoding): its Buffer name, or undefined ("buffer" too). */
+export function bufferEncoding(enc) {
+  if (typeof enc !== "string" || enc.toLowerCase() === "buffer") return undefined;
+  return Buffer.isEncoding(enc) ? enc : undefined;
+}
+
+/** Bytes as Node returns them: a string in `enc`, or the Buffer. */
+export function encodeOutput(buf, enc) {
+  const e = bufferEncoding(enc);
+  return e === undefined ? buf : buf.toString(e);
+}
+
+/** A string's bytes in an encoding (UTF-8 for none or an unknown one), as Node's C++ reads them. */
+export function stringBytes(data, enc) {
+  const e = bufferEncoding(enc);
+  return e === undefined || e === "utf8" || e === "utf-8" ? data : Buffer.from(data, e);
+}
+
+/** validateEncoding: hex data must have an even length. */
+export function validateEncoding(data, enc) {
+  if (typeof enc === "string" && enc.toLowerCase() === "hex" && data.length % 2 !== 0) {
+    throw codeError(TypeError, "ERR_INVALID_ARG_VALUE", "The argument 'encoding' is invalid for data of length " + data.length + ". Received '" + enc + "'");
+  }
+}
+
+export function validateObject(value, name) {
+  if (value === null || typeof value !== "object") throw invalidArgType(name, "of type object", value);
+}
+
+export function validateBoolean(value, name) {
+  if (typeof value !== "boolean") throw invalidArgType(name, "of type boolean", value);
+}
+
+export function validateNumber(value, name) {
+  if (typeof value !== "number") throw invalidArgType(name, "of type number", value);
+}
+
+/* ---- LazyTransform ------------------------------------------------------------------------------ */
+
+export function LazyTransform(options) {
+  this._options = options;
+}
+Object.setPrototypeOf(LazyTransform.prototype, Transform.prototype);
+Object.setPrototypeOf(LazyTransform, Transform);
+
+function makeGetter(name) {
+  return function () {
+    Transform.call(this, this._options);
+    this._writableState.decodeStrings = false;
+    if (!this._options || !this._options.defaultEncoding) this._writableState.defaultEncoding = "buffer";
+    return this[name];
+  };
+}
+
+function makeSetter(name) {
+  return function (val) {
+    Object.defineProperty(this, name, { value: val, enumerable: true, configurable: true, writable: true });
+  };
+}
+
+for (const name of ["_readableState", "_writableState", "_transformState"]) {
+  Object.defineProperty(LazyTransform.prototype, name, { get: makeGetter(name), set: makeSetter(name), configurable: true, enumerable: true });
+}

package/node/prelude/internal/errors.js

@@ -0,0 +1,88 @@
+// Node's error shapes (ADR 0012): argument errors with a `code`, and system errors built
+// from the -errno that host primitives return.
+import { errnoMessage, errnoName, utilInspect } from "visaljs:host";
+
+/** How Node describes a bad argument: "Received type number (1)", "Received undefined", … */
+function received(value) {
+  if (value == null) return " Received " + value;
+  if (typeof value === "function") return " Received function " + (value.name || "<anonymous>");
+  if (typeof value === "object") {
+    const ctor = value.constructor;
+    return ctor && ctor.name ? " Received an instance of " + ctor.name : " Received " + String(value);
+  }
+  let shown = typeof value === "string" ? "'" + value + "'" : String(value);
+  if (shown.length > 28) shown = shown.slice(0, 25) + "...";
+  return " Received type " + typeof value + " (" + shown + ")";
+}
+
+function withCode(error, code) {
+  Object.defineProperty(error, "code", { value: code, writable: true, enumerable: true, configurable: true });
+  return error;
+}
+
+/** An error of class Ctor with Node's `code`: codeError(TypeError, "ERR_X", "message"). */
+export function codeError(Ctor, code, message) {
+  return withCode(new Ctor(message), code);
+}
+
+/** ERR_INVALID_ARG_TYPE: `The "path" argument must be of type string. Received …` (a dotted
+ *  name is a property: `The "options.encoding" property must be …`). */
+export function invalidArgType(name, expected, value) {
+  const what = name.indexOf(".") !== -1 ? "property" : "argument";
+  return withCode(new TypeError("The \"" + name + "\" " + what + " must be " + expected + "." + received(value)), "ERR_INVALID_ARG_TYPE");
+}
+
+/** ERR_INVALID_ARG_VALUE: `The argument 'path' must be a string without null bytes. Received …`
+ *  (a dotted name is a property; the value as util.inspect shows it). */
+export function invalidArgValue(name, reason, value) {
+  const what = name.indexOf(".") !== -1 ? "property" : "argument";
+  return withCode(new TypeError("The " + what + " '" + name + "' " + reason + ". Received " + utilInspect(value)), "ERR_INVALID_ARG_VALUE");
+}
+
+/** A feature of the Node API that visaljs doesn't provide yet. */
+export function notSupported(what) {
+  return withCode(new Error(what + " is not supported by visaljs yet"), "ERR_VISALJS_UNSUPPORTED");
+}
+
+/** A failed system call: `ENOENT: no such file or directory, open 'x'`, with errno, code,
+ *  syscall and path, as Node's uvException builds it. */
+export function systemError(errno, syscall, path) {
+  const code = errnoName(errno);
+  const error = new Error(code + ": " + errnoMessage(errno) + ", " + syscall + (path === undefined ? "" : " '" + path + "'"));
+  error.errno = errno;
+  error.code = code;
+  error.syscall = syscall;
+  if (path !== undefined) error.path = path;
+  return error;
+}
+
+export function validateString(value, name) {
+  if (typeof value !== "string") throw invalidArgType(name, "of type string", value);
+}
+
+/** 1_000_000_000_000: Node's separators for large integers in messages. */
+function separated(digits) {
+  let out = "";
+  let i = digits.length;
+  const start = digits[0] === "-" ? 1 : 0;
+  for (; i >= start + 4; i -= 3) out = "_" + digits.slice(i - 3, i) + out;
+  return digits.slice(0, i) + out;
+}
+
+/** ERR_OUT_OF_RANGE: `The value of "code" is out of range. It must be an integer. Received 1.5` */
+export function outOfRange(name, range, value) {
+  let shown;
+  if (Number.isInteger(value) && Math.abs(value) > 2 ** 32) shown = separated(String(value));
+  else if (typeof value === "bigint") shown = String(value) + "n";  /* no BigInt literal here: it would link BigInt into every program */
+  else shown = utilInspect(value);
+  return withCode(new RangeError("The value of \"" + name + "\" is out of range. It must be " + range + ". Received " + shown), "ERR_OUT_OF_RANGE");
+}
+
+export function validateInteger(value, name) {
+  if (typeof value !== "number") throw invalidArgType(name, "of type number", value);
+  if (value !== value || value === Infinity || value === -Infinity || value % 1 !== 0) throw outOfRange(name, "an integer", value);
+}
+
+export function validateFunction(value, name) {
+  if (typeof value !== "function") throw invalidArgType(name, "of type function", value);
+}

package/node/prelude/internal/querystring.js

@@ -0,0 +1,105 @@
+// Node's lib/internal/querystring.js (v22.22.2; Copyright Node.js contributors, MIT), ported to the
+// host prelude: the percent-encoding querystring and the url module share.
+import { codeError } from "./errors.js";
+
+const invalidUri = () => codeError(URIError, "ERR_INVALID_URI", "URI malformed");
+
+export const hexTable = new Array(256);
+for (let i = 0; i < 256; ++i)
+  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
+
+export const isHexTable = new Int8Array([
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 64 - 79
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80 - 95
+  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 96 - 111
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 112 - 127
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 128 ...
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,  // ... 256
+]);
+
+/**
+ * @param {string} str
+ * @param {Int8Array} noEscapeTable
+ * @param {string[]} hexTable
+ * @returns {string}
+ */
+export function encodeStr(str, noEscapeTable, hexTable) {
+  const len = str.length;
+  if (len === 0)
+    return '';
+
+  let out = '';
+  let lastPos = 0;
+  let i = 0;
+
+  outer:
+  for (; i < len; i++) {
+    let c = str.charCodeAt(i);
+
+    // ASCII
+    while (c < 0x80) {
+      if (noEscapeTable[c] !== 1) {
+        if (lastPos < i)
+          out += str.slice(lastPos, i);
+        lastPos = i + 1;
+        out += hexTable[c];
+      }
+
+      if (++i === len)
+        break outer;
+
+      c = str.charCodeAt(i);
+    }
+
+    if (lastPos < i)
+      out += str.slice(lastPos, i);
+
+    // Multi-byte characters ...
+    if (c < 0x800) {
+      lastPos = i + 1;
+      out += hexTable[0xC0 | (c >> 6)] +
+             hexTable[0x80 | (c & 0x3F)];
+      continue;
+    }
+    if (c < 0xD800 || c >= 0xE000) {
+      lastPos = i + 1;
+      out += hexTable[0xE0 | (c >> 12)] +
+             hexTable[0x80 | ((c >> 6) & 0x3F)] +
+             hexTable[0x80 | (c & 0x3F)];
+      continue;
+    }
+    // Surrogate pair
+    ++i;
+
+    // This branch should never happen because all URLSearchParams entries
+    // should already be converted to USVString. But, included for
+    // completion's sake anyway.
+    if (i >= len)
+      throw invalidUri();
+
+    const c2 = str.charCodeAt(i) & 0x3FF;
+
+    lastPos = i + 1;
+    c = 0x10000 + (((c & 0x3FF) << 10) | c2);
+    out += hexTable[0xF0 | (c >> 18)] +
+           hexTable[0x80 | ((c >> 12) & 0x3F)] +
+           hexTable[0x80 | ((c >> 6) & 0x3F)] +
+           hexTable[0x80 | (c & 0x3F)];
+  }
+  if (lastPos === 0)
+    return str;
+  if (lastPos < len)
+    return out + str.slice(lastPos);
+  return out;
+}
+

package/node/prelude/module.js

@@ -0,0 +1,53 @@
+// node:module (ADR 0009, 0012): createRequire, which the bundler's code uses for a require() it
+// couldn't resolve at build time: a specifier computed at runtime. A compiled program can't load
+// new code, so such a require throws as Node's does for a module it can't find (as a computed
+// import() rejects). builtinModules and isBuiltin list Node's built-in modules.
+//
+// It imports nothing: the bundler's own runtime imports it, and so runs it before any helper the
+// bundler would wrap an imported module in.
+
+export const builtinModules = [
+  "_http_agent", "_http_client", "_http_common", "_http_incoming", "_http_outgoing", "_http_server", "_stream_duplex",
+  "_stream_passthrough", "_stream_readable", "_stream_transform", "_stream_wrap", "_stream_writable", "_tls_common", "_tls_wrap",
+  "assert", "assert/strict", "async_hooks", "buffer", "child_process", "cluster", "console", "constants", "crypto", "dgram",
+  "diagnostics_channel", "dns", "dns/promises", "domain", "events", "fs", "fs/promises", "http", "http2", "https", "inspector",
+  "inspector/promises", "module", "net", "os", "path", "path/posix", "path/win32", "perf_hooks", "process", "punycode",
+  "querystring", "readline", "readline/promises", "repl", "stream", "stream/consumers", "stream/promises", "stream/web",
+  "string_decoder", "sys", "timers", "timers/promises", "tls", "trace_events", "tty", "url", "util", "util/types", "v8", "vm",
+  "wasi", "worker_threads", "zlib",
+];
+
+export function isBuiltin(moduleName) {
+  const name = String(moduleName);
+  return builtinModules.includes(name.startsWith("node:") ? name.slice(5) : name);
+}
+
+function withCode(error, code) {
+  Object.defineProperty(error, "code", { value: code, writable: true, enumerable: true, configurable: true });
+  return error;
+}
+
+function notFound(id) {
+  const e = withCode(new Error(`Cannot find module '${id}'`), "MODULE_NOT_FOUND");
+  e.requireStack = [];
+  return e;
+}
+
+export function createRequire(filename) {
+  if (typeof filename !== "string" && !(typeof URL === "function" && filename instanceof URL)) {
+    throw withCode(new TypeError("The argument 'filename' must be a file URL object, file URL string, or absolute path string. Received " +
+      String(filename)), "ERR_INVALID_ARG_VALUE");
+  }
+  const require = (id) => {
+    throw notFound(id);
+  };
+  require.resolve = (id) => {
+    throw notFound(id);
+  };
+  require.resolve.paths = () => null;
+  require.cache = { __proto__: null };
+  require.main = undefined;
+  return require;
+}
+
+export default { builtinModules, createRequire, isBuiltin };

package/node/prelude/net.js

@@ -0,0 +1,51 @@
+// node:net (ADR 0012, layer 3): the IP address checks (Node's lib/internal/net.js regexes). TCP
+// sockets and servers aren't provided yet (node:http has its own); using them throws
+// ERR_VISALJS_UNSUPPORTED.
+import { notSupported } from "./internal/errors.js";
+
+// IPv4 Segment
+const v4Seg = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])";
+const v4Str = `(?:${v4Seg}\\.){3}${v4Seg}`;
+const IPv4Reg = new RegExp(`^${v4Str}$`);
+
+// IPv6 Segment
+const v6Seg = "(?:[0-9a-fA-F]{1,4})";
+const IPv6Reg = new RegExp("^(?:" +
+  `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +
+  `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +
+  `(?:${v6Seg}:){5}(?::${v4Str}|(?::${v6Seg}){1,2}|:)|` +
+  `(?:${v6Seg}:){4}(?:(?::${v6Seg}){0,1}:${v4Str}|(?::${v6Seg}){1,3}|:)|` +
+  `(?:${v6Seg}:){3}(?:(?::${v6Seg}){0,2}:${v4Str}|(?::${v6Seg}){1,4}|:)|` +
+  `(?:${v6Seg}:){2}(?:(?::${v6Seg}){0,3}:${v4Str}|(?::${v6Seg}){1,5}|:)|` +
+  `(?:${v6Seg}:){1}(?:(?::${v6Seg}){0,4}:${v4Str}|(?::${v6Seg}){1,6}|:)|` +
+  `(?::(?:(?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +
+")(?:%[0-9a-zA-Z-.:]{1,})?$");
+
+export function isIPv4(s) {
+  return IPv4Reg.test(s);
+}
+
+export function isIPv6(s) {
+  return IPv6Reg.test(s);
+}
+
+export function isIP(s) {
+  if (isIPv4(s)) return 4;
+  if (isIPv6(s)) return 6;
+  return 0;
+}
+
+const unsupported = (name) =>
+  function () {
+    throw notSupported("net." + name);
+  };
+export const Socket = unsupported("Socket");
+export const Stream = Socket;
+export const Server = unsupported("Server");
+export const BlockList = unsupported("BlockList");
+export const SocketAddress = unsupported("SocketAddress");
+export const connect = unsupported("connect");
+export const createConnection = unsupported("createConnection");
+export const createServer = unsupported("createServer");
+
+export default { isIP, isIPv4, isIPv6, Socket, Stream, Server, BlockList, SocketAddress, connect, createConnection, createServer };

package/node/prelude/os.js

@@ -0,0 +1,129 @@
+// node:os (ADR 0012, layer 3): the system's facts through libuv, as Node's lib/os.js gets them,
+// and the constants of the platform the program was built for. Not provided yet:
+// networkInterfaces, getPriority and setPriority (ERR_VISALJS_UNSUPPORTED).
+import {
+  osConstants, osCpus, osHomedir, osHostname, osLoadavg, osMemory, osParallelism, osTmpdir, osUname, osUptime, osUserInfo,
+} from "visaljs:host";
+import { notSupported, systemError } from "./internal/errors.js";
+
+const check = (result, syscall) => {
+  if (typeof result === "number" && result < 0) throw systemError(result, syscall);
+  return result;
+};
+const uname = () => check(osUname(), "uv_os_uname");
+
+export const EOL = "\n";
+export const devNull = "/dev/null";
+
+export function arch() {
+  return process.arch;
+}
+
+export function platform() {
+  return process.platform;
+}
+
+export function endianness() {
+  return "LE";
+}
+
+export function type() {
+  return uname()[0];
+}
+
+export function release() {
+  return uname()[1];
+}
+
+export function version() {
+  return uname()[2];
+}
+
+export function machine() {
+  return uname()[3];
+}
+
+export function hostname() {
+  return check(osHostname(), "uv_os_gethostname");
+}
+
+export function homedir() {
+  return check(osHomedir(), "uv_os_homedir");
+}
+
+export function tmpdir() {
+  const dir = osTmpdir();
+  return typeof dir === "string" && dir !== "" ? dir : "/tmp";
+}
+
+export function totalmem() {
+  return osMemory()[0];
+}
+
+export function freemem() {
+  return osMemory()[1];
+}
+
+export function uptime() {
+  return check(osUptime(), "uv_uptime");
+}
+
+export function loadavg() {
+  return osLoadavg();
+}
+
+export function availableParallelism() {
+  return osParallelism();
+}
+
+export function cpus() {
+  const list = osCpus();
+  if (typeof list === "number") return [];
+  return list.map(([model, speed, user, nice, sys, idle, irq]) => ({ model, speed, times: { user, nice, sys, idle, irq } }));
+}
+
+export function userInfo(options) {
+  const [uid, gid, username, home, shell] = check(osUserInfo(), "uv_os_get_passwd");
+  const asBuffer = options != null && typeof options === "object" && options.encoding === "buffer";
+  const enc = (s) => (asBuffer && s !== null ? Buffer.from(s) : s);
+  return { uid, gid, username: enc(username), homedir: enc(home), shell: enc(shell) };
+}
+
+export function networkInterfaces() {
+  throw notSupported("os.networkInterfaces");
+}
+
+export function getPriority() {
+  throw notSupported("os.getPriority");
+}
+
+export function setPriority() {
+  throw notSupported("os.setPriority");
+}
+
+function nameTable(flat) {
+  const o = { __proto__: null };
+  for (let i = 0; i < flat.length; i += 2) o[flat[i]] = flat[i + 1];
+  return Object.freeze(o);
+}
+
+const [signals, errno] = osConstants();
+
+export const constants = Object.freeze({
+  __proto__: null,
+  UV_UDP_REUSEADDR: 4,
+  dlopen: Object.freeze(process.platform === "darwin"
+    ? { __proto__: null, RTLD_LAZY: 1, RTLD_NOW: 2, RTLD_GLOBAL: 8, RTLD_LOCAL: 4 }
+    : { __proto__: null, RTLD_LAZY: 1, RTLD_NOW: 2, RTLD_GLOBAL: 256, RTLD_LOCAL: 0, RTLD_DEEPBIND: 8 }),
+  errno: nameTable(errno),
+  signals: nameTable(signals),
+  priority: Object.freeze({
+    __proto__: null, PRIORITY_LOW: 19, PRIORITY_BELOW_NORMAL: 10, PRIORITY_NORMAL: 0, PRIORITY_ABOVE_NORMAL: -7, PRIORITY_HIGH: -14,
+    PRIORITY_HIGHEST: -20,
+  }),
+});
+
+export default {
+  arch, availableParallelism, cpus, endianness, freemem, getPriority, homedir, hostname, loadavg, networkInterfaces, platform, release,
+  setPriority, tmpdir, totalmem, type, userInfo, uptime, version, machine, constants, EOL, devNull,
+};