visaljs 0.0.2 → 0.0.3

package/node/prelude/stream.js

@@ -430,6 +430,12 @@ function endReadable(stream) {
         state.endEmitted = true;
         stream.emit("end");
         const ws = stream._writableState;
+        if (stream.writable && stream.allowHalfOpen === false) {  /* a Duplex that isn't half-open ends its writable side too */
+          nextTick(() => {
+            if (stream.writable && !stream.writableEnded && !stream.destroyed) stream.end();
+          });
+          return;
+        }
         const autoDestroy = !ws || (ws.autoDestroy && (ws.finished || ws.writable === false));
         if (state.autoDestroy && autoDestroy) stream.destroy();
       }

package/node/prelude/tls.js

@@ -0,0 +1,141 @@
+// node:tls (ADR 0019): TLS 1.0–1.3 clients and servers on BoringSSL, following Node's lib/tls.js.
+// TLSSocket, Server and connect are in internal/tls/wrap.js; SecureContext, the cipher suites and
+// the errors in internal/tls/common.js; certificates in internal/tls/x509.js. The root
+// certificates are the ones Node bundles (Mozilla's), built into the runtime.
+import { fsReadFile, tlsRootCertificates } from "visaljs:host";
+import { EventEmitter } from "./events.js";
+import { invalidArgType, invalidArgValue, validateString } from "./internal/errors.js";
+import { cipherNames, createSecureContext, defaults, extraCAs, SecureContext } from "./internal/tls/common.js";
+import { checkServerIdentity, connect, convertALPNProtocols, createServer, Server, TLSSocket } from "./internal/tls/wrap.js";
+import { toPem } from "./internal/tls/x509.js";
+import { Duplex } from "./stream.js";
+
+export { checkServerIdentity, connect, convertALPNProtocols, createSecureContext, createServer, SecureContext, Server, TLSSocket };
+
+export const CLIENT_RENEG_LIMIT = 3;
+export const CLIENT_RENEG_WINDOW = 600;
+
+export const getCiphers = () => cipherNames();
+
+let bundled;
+const bundledRoots = () => (bundled ??= Object.freeze(tlsRootCertificates()));
+
+/* where Linux distributions and macOS keep the system's trusted certificates */
+const SYSTEM_BUNDLES = ["/etc/ssl/certs/ca-certificates.crt", "/etc/pki/tls/certs/ca-bundle.crt", "/etc/ssl/ca-bundle.pem", "/etc/ssl/cert.pem"];
+let system;
+function systemRoots() {
+  if (system) return system;
+  let pems = [];
+  for (const file of SYSTEM_BUNDLES) {
+    const text = fsReadFile(file);
+    if (typeof text === "string") {
+      pems = (text.match(/-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----/g) ?? []).map((p) => p.replace(/\r\n/g, "\n") + "\n");
+      break;
+    }
+  }
+  return (system = Object.freeze(pems));
+}
+
+let extraPems;
+const extraRoots = () => (extraPems ??= Object.freeze(extraCAs().map((der) => toPem(der))));
+
+let defaultPems;
+function defaultRoots() {
+  if (defaultPems) return defaultPems;
+  const out = defaults.defaultCA ? [...defaults.defaultCA] : [...bundledRoots()];
+  if (!defaults.defaultCA) out.push(...extraRoots());
+  return (defaultPems = Object.freeze(out));
+}
+
+export function getCACertificates(type = "default") {
+  validateString(type, "type");
+  switch (type) {
+    case "default": return defaultRoots();
+    case "bundled": return bundledRoots();
+    case "system": return systemRoots();
+    case "extra": return extraRoots();
+    default: throw invalidArgValue("type", "is invalid", type);
+  }
+}
+
+export function setDefaultCACertificates(certs) {
+  if (!Array.isArray(certs)) throw invalidArgType("certs", "an instance of Array", certs);
+  for (let i = 0; i < certs.length; i++) {
+    if (typeof certs[i] !== "string" && !ArrayBuffer.isView(certs[i])) {
+      throw invalidArgType(`certs[${i}]`, "of type string or an instance of ArrayBufferView", certs[i]);
+    }
+  }
+  defaults.defaultCA = certs.map((c) => (typeof c === "string" ? c : Buffer.from(c.buffer, c.byteOffset, c.byteLength).toString("latin1")));
+  defaultPems = undefined;
+}
+
+/* ---- createSecurePair (deprecated): a TLSSocket over one end of an in-memory pair ---------------- */
+
+class PairSide extends Duplex {
+  constructor() {
+    super();
+    this.other = null;
+  }
+
+  _read() {}
+
+  _write(chunk, encoding, cb) {
+    this.other.push(chunk);
+    cb();
+  }
+
+  _final(cb) {
+    this.other.push(null);
+    cb();
+  }
+}
+
+class SecurePair extends EventEmitter {
+  constructor(secureContext = createSecureContext(), isServer = false, requestCert = !isServer, rejectUnauthorized = false) {
+    super();
+    const encrypted = new PairSide();
+    const inner = new PairSide();
+    encrypted.other = inner;
+    inner.other = encrypted;
+    this.server = undefined;
+    this.encrypted = encrypted;
+    this.cleartext = new TLSSocket(inner, { secureContext, isServer, requestCert, rejectUnauthorized });
+    this.cleartext.once("secure", () => this.emit("secure"));
+    if (!isServer) this.cleartext._start();
+  }
+}
+
+let securePairWarned = false;
+export function createSecurePair(...args) {
+  if (!securePairWarned) {
+    securePairWarned = true;
+    process.emitWarning("tls.createSecurePair() is deprecated. Please use tls.TLSSocket instead.", "DeprecationWarning", "DEP0064");
+  }
+  return new SecurePair(...args);
+}
+
+/* Node's settable defaults: assigning tls.DEFAULT_CIPHERS (on require("tls")) changes what new
+ * contexts use */
+const tls = {
+  CLIENT_RENEG_LIMIT, CLIENT_RENEG_WINDOW,
+  get DEFAULT_CIPHERS() { return defaults.DEFAULT_CIPHERS; },
+  set DEFAULT_CIPHERS(v) { defaults.DEFAULT_CIPHERS = v; },
+  get DEFAULT_ECDH_CURVE() { return defaults.DEFAULT_ECDH_CURVE; },
+  set DEFAULT_ECDH_CURVE(v) { defaults.DEFAULT_ECDH_CURVE = v; },
+  get DEFAULT_MIN_VERSION() { return defaults.DEFAULT_MIN_VERSION; },
+  set DEFAULT_MIN_VERSION(v) { defaults.DEFAULT_MIN_VERSION = v; },
+  get DEFAULT_MAX_VERSION() { return defaults.DEFAULT_MAX_VERSION; },
+  set DEFAULT_MAX_VERSION(v) { defaults.DEFAULT_MAX_VERSION = v; },
+  getCiphers,
+  get rootCertificates() { return bundledRoots(); },
+  getCACertificates, setDefaultCACertificates, convertALPNProtocols, checkServerIdentity, createSecureContext, SecureContext,
+  TLSSocket, Server, createServer, connect, createSecurePair,
+};
+
+export const DEFAULT_CIPHERS = defaults.DEFAULT_CIPHERS;
+export const DEFAULT_ECDH_CURVE = defaults.DEFAULT_ECDH_CURVE;
+export const DEFAULT_MIN_VERSION = defaults.DEFAULT_MIN_VERSION;
+export const DEFAULT_MAX_VERSION = defaults.DEFAULT_MAX_VERSION;
+export const rootCertificates = bundledRoots();
+
+export default tls;

package/node/prelude/util.js

@@ -1,6 +1,9 @@
 // node:util (ADR 0012, layer 3): inspect and format are the runtime's (console prints
-// with them), Node's algorithms in C; deprecate and inherits.
+// with them), Node's algorithms in C; deprecate, inherits and types (node:util/types).
 import { utilFormat, utilFormatWithOptions, utilInspect } from "visaljs:host";
+import types from "./util_types.js";
+
+export { types };
 
 export const inspect = utilInspect;
 inspect.custom = Symbol.for("nodejs.util.inspect.custom");
@@ -61,4 +64,4 @@ export function inherits(ctor, superCtor) {
   Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
 }
 
-export default { format, formatWithOptions, inspect, deprecate, inherits };
+export default { format, formatWithOptions, inspect, deprecate, inherits, types };

package/node/prelude/util_types.js

@@ -0,0 +1,85 @@
+// node:util/types (and util.types): what a value is inside, as V8 answers it — Symbol.toStringTag,
+// prototypes and subclassing don't change the answer. The runtime gives each object's internal
+// kind (utilTypeTag, runtime/src/util_types.c); these compare it. Modules are bundled into one
+// program, so there are no module namespace objects to recognize.
+import { utilTypeTag } from "visaljs:host";
+import { kKeyType } from "./internal/crypto/key_type.js";
+
+const tag = (value) => (typeof value === "object" || typeof value === "function") && value !== null ? utilTypeTag(value) : "";
+
+const TYPED_ARRAYS = new Set([
+  "Int8Array", "Uint8Array", "Uint8ClampedArray", "Int16Array", "Uint16Array", "Int32Array", "Uint32Array",
+  "BigInt64Array", "BigUint64Array", "Float16Array", "Float32Array", "Float64Array",
+]);
+
+export const isExternal = (_value) => false;
+export const isDate = (value) => tag(value) === "Date";
+export const isArgumentsObject = (value) => tag(value) === "Arguments";
+export const isBigIntObject = (value) => tag(value) === "BigIntObject";
+export const isBooleanObject = (value) => tag(value) === "BooleanObject";
+export const isNumberObject = (value) => tag(value) === "NumberObject";
+export const isStringObject = (value) => tag(value) === "StringObject";
+export const isSymbolObject = (value) => tag(value) === "SymbolObject";
+export function isBoxedPrimitive(value) {
+  const t = tag(value);
+  return t === "NumberObject" || t === "StringObject" || t === "BooleanObject" || t === "BigIntObject" || t === "SymbolObject";
+}
+export const isNativeError = (value) => tag(value) === "Error";
+export const isRegExp = (value) => tag(value) === "RegExp";
+export const isAsyncFunction = (value) => {
+  const t = tag(value);
+  return t === "AsyncFunction" || t === "AsyncGeneratorFunction";
+};
+export const isGeneratorFunction = (value) => {
+  const t = tag(value);
+  return t === "GeneratorFunction" || t === "AsyncGeneratorFunction";
+};
+export const isGeneratorObject = (value) => {
+  const t = tag(value);
+  return t === "Generator" || t === "AsyncGenerator";
+};
+export const isPromise = (value) => tag(value) === "Promise";
+export const isMap = (value) => tag(value) === "Map";
+export const isSet = (value) => tag(value) === "Set";
+export const isMapIterator = (value) => tag(value) === "Map Iterator";
+export const isSetIterator = (value) => tag(value) === "Set Iterator";
+export const isWeakMap = (value) => tag(value) === "WeakMap";
+export const isWeakSet = (value) => tag(value) === "WeakSet";
+export const isArrayBuffer = (value) => tag(value) === "ArrayBuffer";
+export const isDataView = (value) => tag(value) === "DataView";
+export const isSharedArrayBuffer = (value) => tag(value) === "SharedArrayBuffer";
+export const isProxy = (value) => tag(value) === "Proxy";
+export const isModuleNamespaceObject = (_value) => false;
+export const isAnyArrayBuffer = (value) => {
+  const t = tag(value);
+  return t === "ArrayBuffer" || t === "SharedArrayBuffer";
+};
+export const isCryptoKey = (value) => tag(value) === "CryptoKey";
+export const isKeyObject = (value) => value != null && value[kKeyType] !== undefined;
+export const isArrayBufferView = (value) => {
+  const t = tag(value);
+  return t === "DataView" || TYPED_ARRAYS.has(t);
+};
+export const isTypedArray = (value) => TYPED_ARRAYS.has(tag(value));
+export const isUint8Array = (value) => tag(value) === "Uint8Array";
+export const isUint8ClampedArray = (value) => tag(value) === "Uint8ClampedArray";
+export const isUint16Array = (value) => tag(value) === "Uint16Array";
+export const isUint32Array = (value) => tag(value) === "Uint32Array";
+export const isInt8Array = (value) => tag(value) === "Int8Array";
+export const isInt16Array = (value) => tag(value) === "Int16Array";
+export const isInt32Array = (value) => tag(value) === "Int32Array";
+export const isFloat16Array = (value) => tag(value) === "Float16Array";
+export const isFloat32Array = (value) => tag(value) === "Float32Array";
+export const isFloat64Array = (value) => tag(value) === "Float64Array";
+export const isBigInt64Array = (value) => tag(value) === "BigInt64Array";
+export const isBigUint64Array = (value) => tag(value) === "BigUint64Array";
+
+/* Node's order, which Object.keys(util.types) shows */
+export default {
+  isArgumentsObject, isArrayBuffer, isAsyncFunction, isBigIntObject, isBooleanObject, isDataView, isDate, isExternal,
+  isGeneratorFunction, isGeneratorObject, isMap, isMapIterator, isModuleNamespaceObject, isNativeError, isNumberObject,
+  isPromise, isProxy, isRegExp, isSet, isSetIterator, isSharedArrayBuffer, isStringObject, isSymbolObject, isWeakMap,
+  isWeakSet, isAnyArrayBuffer, isBoxedPrimitive, isArrayBufferView, isTypedArray, isUint8Array, isUint8ClampedArray,
+  isUint16Array, isUint32Array, isInt8Array, isInt16Array, isInt32Array, isFloat16Array, isFloat32Array,
+  isFloat64Array, isBigInt64Array, isBigUint64Array, isKeyObject, isCryptoKey,
+};