@blamejs/pki 0.5.31 → 0.5.33

package/lib/guard-bytes.js

@@ -27,6 +27,8 @@ var _bufferFrom = intrinsic.bufferFrom;
 // question this guard asked on the caller's behalf. See guard-intrinsic for the whole set.
 var _isView = intrinsic.isView;
 var _isBuffer = intrinsic.isBuffer;
+var _asyncIterator = intrinsic.asyncIterator;
+var _NO_ARGS = intrinsic.freeze([]);
 var _create = intrinsic.create;
 var _getPrototypeOf = intrinsic.getPrototypeOf;
 var _getOwnPropertyDescriptor = intrinsic.getOwnPropertyDescriptor;
@@ -41,7 +43,7 @@ var _stringify = intrinsic.stringify;
 var _forEach = intrinsic.forEach;
 var _map = intrinsic.map;
 var _filter = intrinsic.filter;
-var _reTest = intrinsic.uncurry(RegExp.prototype.test);
+var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _setForEach = intrinsic.uncurry(Set.prototype.forEach);
 var _mapForEach = intrinsic.uncurry(Map.prototype.forEach);
 var _String = intrinsic.String;
@@ -80,6 +82,35 @@ function isByteSource(x) {
   return _isBuffer(x) || _isView(x) || _isArrayBuffer(x);
 }
 
+// asyncStreamOf(x) -> a LAZY single-use async iterable of x's byte chunks, or null when x is not a
+// byte stream.
+//
+// A door offering both a byte source and a streamed content (an async iterable of byte chunks) asks
+// this ONE module which it has, instead of re-inlining the `for await` protocol test and drifting on
+// what counts. It reads x's Symbol.asyncIterator EXACTLY ONCE, captures that method, and returns a
+// thin iterable that CALLS it only when the consumer drives the stream. Deferring the call matters
+// twice: the underlying iterator is acquired once, in the digest engine, so reading the protocol
+// property a second time downstream cannot fire a one-shot or stateful accessor and refuse a stream a
+// direct `for await` accepts; AND a caller whose iterator factory opens a file or socket has that
+// resource opened only on a path that will actually consume it, never on a pre-hash rejection (a
+// missing detached option, an empty signer list, a message needing no streamed digest) that would
+// otherwise acquire and leak it. A byte source is bytes, never a stream, EVEN when a caller attached a
+// Symbol.asyncIterator to it: the byte-source classification wins and is checked FIRST, so a Buffer /
+// typed array / DataView goes down the byte path every time and its own accessors are never invoked
+// here. A callable carrying the method is a valid async iterable that `for await` consumes, so it too
+// yields a stream.
+// @enforced-by behavioral -- a lazy stream wrapper has no rename-proof code shape; the RED vectors (a
+// stream produced where a byte source is not, a one-shot-accessor stream still consumed, and the
+// factory NOT invoked until the stream is driven) are the guard.
+function asyncStreamOf(x) {
+  if (isByteSource(x) || x == null || (typeof x !== "object" && typeof x !== "function")) return null;
+  var acquire = x[_asyncIterator];
+  if (typeof acquire !== "function") return null;
+  var stream = {};
+  stream[_asyncIterator] = function () { return _apply(acquire, x, _NO_ARGS); };
+  return stream;
+}
+
 // Is this value a byte store, asked of the internal slot rather than the prototype?
 //
 // `v instanceof ArrayBuffer` answers what a value inherits from, which is a different question
@@ -151,10 +182,26 @@ function _reView(v) {
 // The two string operations in this table run AT LOAD, in the same statement that reads
 // `util.types` once and for the same reason. Nothing a caller can replace has run yet, so there is
 // no live read to remove; capturing them would only move the question one line earlier.
+// A util.types predicate that names a concrete typed-array kind: "is" + one-or-more alphanumerics +
+// "Array" (e.g. "isUint8Array"), decided character by character so no regex match protocol -- which
+// re-dispatches through a replaceable `exec` -- stands between this table and the runtime it reads.
+function _isTypedArrayPredName(name) {
+  var n = name.length;
+  if (n < 8) return false; // "is" + >=1 middle char + "Array"
+  if (_charCodeAt(name, 0) !== 105 || _charCodeAt(name, 1) !== 115) return false; // "is"
+  var tail = "Array";
+  for (var k = 0; k < 5; k++) { if (_charCodeAt(name, n - 5 + k) !== _charCodeAt(tail, k)) return false; }
+  for (var i = 2; i < n - 5; i++) {
+    var c = _charCodeAt(name, i);
+    if (!((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122))) return false;
+  }
+  return true;
+}
+
 var _CONCRETE_KINDS = _filter(
   _map(
     // allow:guard-reads-runtime-live -- module-init, see above
-    _filter(_objectKeys(util.types), function (name) { return _reTest(/^is[A-Za-z0-9]+Array$/, name); }),
+    _filter(_objectKeys(util.types), function (name) { return _isTypedArrayPredName(name); }),
     // allow:guard-reads-runtime-live -- module-init, see above
     function (name) { return [util.types[name], globalThis[name.slice(2)]]; }
   ),
@@ -188,7 +235,12 @@ function _kindName(v) {
   return typeof v === "function" ? "function" : "value";
 }
 
-function _article(name) { return _reTest(/^[AEIOU]/i, name) ? "an" : "a"; }
+function _article(name) {
+  var c = name.length > 0 ? _charCodeAt(name, 0) : 0;
+  var vowel = c === 65 || c === 69 || c === 73 || c === 79 || c === 85 ||
+              c === 97 || c === 101 || c === 105 || c === 111 || c === 117; // A E I O U, either case
+  return vowel ? "an" : "a";
+}
 
 // outputView(input, ErrorClass, code, label) -> a Buffer aliasing a caller's view, for WRITING.
 //
@@ -1036,6 +1088,6 @@ function fixedCall(ErrorClass, code, args, body) {
 // call, so a writable export would let a caller replace the check rather than pass it.
 module.exports = intrinsic.freeze({
   view: view, source: source, snapshot: snapshot, snapshotSource: snapshotSource,
-  isByteSource: isByteSource, lengthOf: lengthOf, outputView: outputView,
+  isByteSource: isByteSource, asyncStreamOf: asyncStreamOf, lengthOf: lengthOf, outputView: outputView,
   snapshotDeep: snapshotDeep, fixArguments: fixArguments, fixedCall: fixedCall,
 });

package/lib/guard-intrinsic.js

@@ -59,6 +59,10 @@ var _bufferCompare = Buffer.compare;
 // response is about this issuer, a responder ID says this key signed it. Dispatched live, one
 // answering true makes a response about a DIFFERENT certificate match the one being asked about.
 var _bufferEquals = uncurry(Buffer.prototype.equals);
+// Buffer#toString, uncurried at load. Used to build dedup keys (a hex string) from bytes the toolkit
+// owns; dispatched live, a replaced toString could make two distinct values key alike or one value key
+// differently on two reads, so a dedup over untrusted-adjacent bytes would merge or split wrongly.
+var _bufferToString = uncurry(Buffer.prototype.toString);
 
 // The rest of what a guard reads from the runtime while it is deciding something. These are
 // grouped here rather than captured file by file so the set is enumerable in one place and a guard
@@ -94,6 +98,13 @@ var _mathMax = Math.max;
 var _parseInt = parseInt;
 var _promiseResolve = Promise.resolve;
 var _promiseReject = Promise.reject;
+// The well-known async-iteration symbol, captured at load. `for await` uses this symbol at the
+// language level regardless of the global `Symbol` object, so a classifier that reads
+// `Symbol.asyncIterator` live would disagree with the loop the moment a co-resident replaced the
+// writable `Symbol` global: a real async iterable would be looked up under the wrong key, judged not
+// iterable, and refused where the engine would have consumed it. Reading the captured symbol keeps
+// the door's answer and the loop's behavior the same.
+var _asyncIterator = Symbol.asyncIterator;
 
 // The array operations, uncurried at load. These run on arrays the TOOLKIT owns -- an `ownKeys`
 // result, a local accumulator -- so the receiver is never a caller's object; what is caller-
@@ -274,6 +285,7 @@ module.exports = Object.freeze({
   bufferFrom: _bufferFrom,
   bufferAlloc: _bufferAlloc,
   bufferConcat: _bufferConcat,
+  bufToString: _bufferToString,
   isBuffer: _bufferIsBuffer,
   byteLength: _bufferByteLength,
   compare: _bufferCompare,
@@ -309,6 +321,7 @@ module.exports = Object.freeze({
   bigIntToString: _bigIntToString,
   promiseResolve: _promiseResolve,
   promiseReject: _promiseReject,
+  asyncIterator: _asyncIterator,
   forEach: _arrForEach,
   map: _arrMap,
   filter: _arrFilter,

package/lib/http-digest.js

@@ -19,6 +19,10 @@ var intrinsic = require("./guard-intrinsic");
 // replaceable properties to answer one thing, and here it decides whether an auth-param repeats --
 // answering false lets the second copy of a nonce overwrite the first.
 var _hasOwn = intrinsic.hasOwn;
+var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+var _strSlice = intrinsic.uncurry(String.prototype.slice);
+var _fromCharCode = intrinsic.fromCharCode;
+var pkix = require("./schema-pkix");   // the shared JS-\s code-point predicate (pkix.isJsWhitespace)
 
 // Algorithm registry, a data row and not a switch: rank orders the RFC 7616 sec. 3.7
 // "most secure the client can use" selection (SHA-512-256 > SHA-256 > MD5); an unknown algorithm ranks 0.
@@ -41,7 +45,12 @@ var DEFAULT_CODES = {
 // is hashed over its exact bytes. KD(secret, data) = H(secret ":" data).
 function H(hash, s) { return crypto.createHash(hash).update(s, "latin1").digest("hex"); }
 function KD(hash, secret, data) { return H(hash, secret + ":" + data); }
-function _qstr(v) { return "\"" + String(v).replace(/(["\\])/g, "\\$1") + "\""; }
+// Quote a value: wrap in double quotes, backslash-escaping any " or \ (matching /(["\\])/g -> "\\$1").
+function _qstr(v) {
+  var s = String(v), out = "";
+  for (var i = 0; i < s.length; i++) { var c = _charCodeAt(s, i); if (c === 34 || c === 92) out += "\\"; out += _fromCharCode(c); }
+  return "\"" + out + "\"";
+}
 
 // Split a header at commas outside a quoted-string (a quoted comma is a literal, not a delimiter).
 function _commaSplitOutsideQuotes(s) {
@@ -69,7 +78,13 @@ function _firstEqOutsideQuotes(s) {
   }
   return -1;
 }
-function _unq(s) { return s.slice(1, -1).replace(/\\(.)/g, "$1"); }   // only ever called on a well-formed quoted-string (see _closedQuote)
+// Unquote a well-formed quoted-string (only ever called after _closedQuote): drop the surrounding
+// quotes and each escaping backslash (matching s.slice(1,-1).replace(/\\(.)/g, "$1")).
+function _unq(s) {
+  var out = "", last = 1, n = s.length;                       // skip the opening quote at 0
+  for (var i = 1; i < n - 1; i++) { if (_charCodeAt(s, i) === 92) { out += _strSlice(s, last, i); last = i + 1; i += 1; } }
+  return out + _strSlice(s, last, n - 1);                     // trailing content, excluding the closing quote
+}
 // A well-formed quoted-string: opens with ", closes with an unescaped " as the last character (nothing trails
 // it). An unterminated / trailing-garbage quoted-string is malformed (RFC 7230 sec. 3.2.6) and rejected.
 function _closedQuote(s) {
@@ -86,24 +101,62 @@ function _closedQuote(s) {
 // A control octet (RFC 7230 sec. 3.2.6 quoted-string / qdtext forbids CTL except HTAB). Scanned with charCodeAt
 // instead of a control-char regex literal (which eslint no-control-regex correctly refuses).
 function _hasCtl(s) {
-  for (var i = 0; i < s.length; i++) { var c = s.charCodeAt(i); if ((c < 0x20 && c !== 0x09) || c === 0x7f) return true; }
+  for (var i = 0; i < s.length; i++) { var c = _charCodeAt(s, i); if ((c < 0x20 && c !== 0x09) || c === 0x7f) return true; }
   return false;
 }
 
 // Split a WWW-Authenticate header into [{ scheme, paramText }]. A comma-separated segment whose pre-'='
 // text is "token WS token" (a scheme name before the first auth-param key), or a bare token with no '=',
 // STARTS a new challenge; a "key=value" segment is a param continuation of the current challenge.
+// The leading token when `pre` is "token WS more" (/^(\S+)\s+(\S[\s\S]*)$/) -- a scheme name before the
+// first auth-param -- else null. \s is the shared JS-\s predicate (RFC 7230 OWS is a subset).
+function _matchTokenRest(pre) {
+  var n = pre.length, p = 0;
+  while (p < n && !pkix.isJsWhitespace(_charCodeAt(pre, p))) p += 1;              // ^(\S+)
+  if (p === 0) return null;
+  var tokEnd = p;
+  if (p >= n || !pkix.isJsWhitespace(_charCodeAt(pre, p))) return null;          // \s+
+  while (p < n && pkix.isJsWhitespace(_charCodeAt(pre, p))) p += 1;
+  if (p >= n || pkix.isJsWhitespace(_charCodeAt(pre, p))) return null;           // (\S[\s\S]*)$ -- at least one non-\s
+  return _strSlice(pre, 0, tokEnd);
+}
+// The index past a leading "OWS token OWS" (/^\s*\S+\s+/), or 0 when the string does not begin that way.
+// The caller slices from this index (the slice that replaces the removed .replace).
+function _stripTokenIndex(seg) {
+  var n = seg.length, p = 0;
+  while (p < n && pkix.isJsWhitespace(_charCodeAt(seg, p))) p += 1;              // ^\s*
+  var ts = p;
+  while (p < n && !pkix.isJsWhitespace(_charCodeAt(seg, p))) p += 1;             // \S+
+  if (p === ts) return 0;
+  var ws = p;
+  while (p < n && pkix.isJsWhitespace(_charCodeAt(seg, p))) p += 1;              // \s+ (required)
+  return p === ws ? 0 : p;
+}
+// String.prototype.split(/\s+/): the pieces between \s runs (a leading/trailing run yields a "" element).
+function _splitWhitespace(s) {
+  var out = [], i = 0, n = s.length, ps = 0;
+  while (i < n) {
+    if (pkix.isJsWhitespace(_charCodeAt(s, i))) {
+      out[out.length] = _strSlice(s, ps, i);
+      while (i < n && pkix.isJsWhitespace(_charCodeAt(s, i))) i += 1;
+      ps = i;
+    } else i += 1;
+  }
+  out[out.length] = _strSlice(s, ps);
+  return out;
+}
+
 function _splitChallenges(s) {
   var segs = _commaSplitOutsideQuotes(s);
   var out = [], cur = null;
   for (var i = 0; i < segs.length; i++) {
-    var seg = segs[i].replace(/^\s+|\s+$/g, "");
+    var seg = segs[i].trim();
     if (seg === "") continue;
     var eq = _firstEqOutsideQuotes(seg);
-    var pre = (eq < 0 ? seg : seg.slice(0, eq)).replace(/^\s+|\s+$/g, "");
-    var ws = /^(\S+)\s+(\S[\s\S]*)$/.exec(pre);
+    var pre = (eq < 0 ? seg : _strSlice(seg, 0, eq)).trim();
+    var scheme = _matchTokenRest(pre);
     if (eq < 0) { cur = { scheme: seg, paramText: "" }; out.push(cur); }        // a bare scheme token (e.g. "Basic")
-    else if (ws) { cur = { scheme: ws[1], paramText: seg.replace(/^\s*\S+\s+/, "") }; out.push(cur); }   // "scheme firstKey=..."
+    else if (scheme !== null) { cur = { scheme: scheme, paramText: _strSlice(seg, _stripTokenIndex(seg)) }; out.push(cur); }   // "scheme firstKey=..."
     else if (cur) { cur.paramText = cur.paramText ? cur.paramText + "," + seg : seg; }                   // "key=value" continuation
   }
   return out;
@@ -112,12 +165,12 @@ function _splitChallenges(s) {
 function _parseParams(paramText, E, code) {
   var segs = _commaSplitOutsideQuotes(paramText), map = Object.create(null);
   for (var i = 0; i < segs.length; i++) {
-    var seg = segs[i].replace(/^\s+|\s+$/g, "");
+    var seg = segs[i].trim();
     if (seg === "") continue;
     var eq = _firstEqOutsideQuotes(seg);
     if (eq < 0) throw E(code, "malformed Digest auth-param (no '='): " + JSON.stringify(seg));
-    var key = seg.slice(0, eq).replace(/^\s+|\s+$/g, "").toLowerCase();
-    var rawVal = seg.slice(eq + 1).replace(/^\s+|\s+$/g, "");
+    var key = _strSlice(seg, 0, eq).trim().toLowerCase();
+    var rawVal = _strSlice(seg, eq + 1).trim();
     var quoted = rawVal.charAt(0) === "\"";
     if (quoted && !_closedQuote(rawVal)) throw E(code, "an unterminated or trailing-garbage Digest quoted-string (RFC 7230 sec. 3.2.6)");
     if (_hasOwn(map, key)) throw E(code, "repeated Digest auth-param " + JSON.stringify(key));
@@ -138,7 +191,7 @@ function _validateDigest(paramText, E, code) {
   var qop = [];
   if (p.qop) {
     if (!p.qop.quoted) throw E(code, "the Digest qop must be a quoted list (RFC 7616 sec. 3.3)");
-    qop = p.qop.value.split(",").map(function (x) { return x.replace(/^\s+|\s+$/g, "").toLowerCase(); }).filter(Boolean);
+    qop = p.qop.value.split(",").map(function (x) { return x.trim().toLowerCase(); }).filter(Boolean);
     // A qop directive that is present but lists no value (qop="" / qop=", ,") is malformed, and is not the
     // absent-qop (RFC 2069) case. Reject it instead of silently collapsing to a no-qop response the server
     // cannot accept (RFC 7616 sec. 3.3). Only an omitted qop directive selects the legacy no-qop path.
@@ -150,8 +203,8 @@ function _validateDigest(paramText, E, code) {
   // server intended. Surfaced as an array of the listed URIs, or null when omitted or quoted-empty, which per
   // the RFC means "all URIs on the responding server" (the answer may be reused for any same-origin URI, sec. 3.5).
   if (p.domain && !p.domain.quoted) throw E(code, "the Digest domain must be a quoted-string (RFC 7616 sec. 3.3)");
-  var domain = (p.domain && p.domain.value.replace(/^\s+|\s+$/g, "") !== "")
-    ? p.domain.value.replace(/^\s+|\s+$/g, "").split(/\s+/) : null;
+  var domain = (p.domain && p.domain.value.trim() !== "")
+    ? _splitWhitespace(p.domain.value.trim()) : null;
   // charset (RFC 7616 sec. 3.3): the one permitted value is the unquoted token "UTF-8". A quoted charset, or any
   // other value, is malformed, since answering it would hash the credentials in the wrong encoding, so it is
   // rejected (and thus skipped during multi-offer selection in favor of a conforming offer).
@@ -250,7 +303,7 @@ function _octets(s, charset) {
 // Does the string carry any non-ASCII code unit (> U+007F)? Such a UTF-8 username is sent via `username*`.
 function _hasNonAscii(s) {
   s = String(s == null ? "" : s);
-  for (var i = 0; i < s.length; i++) { if (s.charCodeAt(i) > 0x7F) return true; }
+  for (var i = 0; i < s.length; i++) { if (_charCodeAt(s, i) > 0x7F) return true; }
   return false;
 }
 
@@ -264,7 +317,7 @@ function _pctEncodeUtf8(s) {
     if ((b >= 0x30 && b <= 0x39) || (b >= 0x41 && b <= 0x5A) || (b >= 0x61 && b <= 0x7A) ||
         b === 0x21 || b === 0x23 || b === 0x24 || b === 0x26 || b === 0x2B || b === 0x2D ||
         b === 0x2E || b === 0x5E || b === 0x5F || b === 0x60 || b === 0x7C || b === 0x7E) {
-      out += String.fromCharCode(b);
+      out += _fromCharCode(b);
     } else {
       out += "%" + (b < 0x10 ? "0" : "") + b.toString(16).toUpperCase();
     }
@@ -323,7 +376,7 @@ function answer(challenge, params, E) {
   // (a same-origin redirect, an auth-int retry) increments nc; a fresh nonce restarts at 1. The caller supplies
   // the count for this nonce (default 1); formatted as 8 lowercase hex.
   var ncNum = (typeof params.nc === "number" && params.nc >= 1) ? Math.floor(params.nc) : 1;
-  var nc = ("0000000" + ncNum.toString(16)).slice(-8);
+  var nc = _strSlice("0000000" + ncNum.toString(16), -8);
   var response = useQop
     ? KD(alg.hash, HA1, nonce + ":" + nc + ":" + cnonce + ":" + useQop + ":" + HA2)
     : KD(alg.hash, HA1, nonce + ":" + HA2);

package/lib/http-retry-after.js

@@ -19,12 +19,32 @@ var MAX_RETRY_AFTER_SECONDS = constants.TIME.days(365) / constants.TIME.seconds(
 // rfc850-date / asctime-date a recipient must still accept. Gating Date.parse on this grammar keeps its
 // permissiveness (an ISO string like "2026-07-10") from passing as a valid Retry-After header.
 var MONTHS = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split(" ");
-var MONTH = "(?:" + MONTHS.join("|") + ")";
-var HTTP_DATE_FORMS = [
-  new RegExp("^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \\d{2} " + MONTH + " \\d{4} \\d{2}:\\d{2}:\\d{2} GMT$"),
-  new RegExp("^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \\d{2}-" + MONTH + "-\\d{2} \\d{2}:\\d{2}:\\d{2} GMT$"),
-  new RegExp("^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) " + MONTH + " [ \\d]\\d \\d{2}:\\d{2}:\\d{2} \\d{4}$"),
-];
+var DOW_SHORT = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+var DOW_LONG = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+
+// The grammar is scanned character by character (no regex): each form is a fixed layout of a
+// day-of-week name, delimiters, an all-digit field, a three-letter month name, and an HH:MM:SS time.
+function _isDigit(ch) { return ch >= "0" && ch <= "9"; }
+// The two-digit / four-digit integer at `i`, or -1 when those positions are not all digits.
+function _digits2(s, i) { return _isDigit(s.charAt(i)) && _isDigit(s.charAt(i + 1)) ? (s.charCodeAt(i) - 48) * 10 + (s.charCodeAt(i + 1) - 48) : -1; }
+function _digits4(s, i) { for (var k = 0; k < 4; k++) if (!_isDigit(s.charAt(i + k))) return -1; return parseInt(s.slice(i, i + 4), 10); }
+// The length of a name from `list` matching `s` at `i` (the day-of-week alternation), or -1.
+function _matchName(s, i, list) { for (var j = 0; j < list.length; j++) { if (s.slice(i, i + list[j].length) === list[j]) return list[j].length; } return -1; }
+// The three-letter month at `i` when it is a real month name, else null.
+function _monthAt(s, i) { return _matchName(s, i, MONTHS) === -1 ? null : s.slice(i, i + 3); }
+// An "HH:MM:SS" time at `i` -> { hh, mi, ss, next } (next = i + 8), or null.
+function _timeAt(s, i) {
+  var hh = _digits2(s, i); if (hh < 0 || s.charAt(i + 2) !== ":") return null;
+  var mi = _digits2(s, i + 3); if (mi < 0 || s.charAt(i + 5) !== ":") return null;
+  var ss = _digits2(s, i + 6); if (ss < 0) return null;
+  return { hh: hh, mi: mi, ss: ss, next: i + 8 };
+}
+// A non-empty run of ASCII digits (matching /^\d+$/, the delay-seconds form).
+function _isAllDigits(s) {
+  if (s.length === 0) return false;
+  for (var i = 0; i < s.length; i++) if (!_isDigit(s.charAt(i))) return false;
+  return true;
+}
 
 // Expand an obsolete RFC 850 two-digit year: HTTP interprets it relative to the receipt year, as the full
 // year with these two digits within [refYear-50, refYear+49] (moved to the past only when it would
@@ -40,29 +60,53 @@ function _rfc850Year(yy, refMs) {
   return full;
 }
 
+// IMF-fixdate (the required form): "Sun, 06 Nov 1994 08:49:37 GMT".
+function _scanImf(s) {
+  var p = _matchName(s, 0, DOW_SHORT);
+  if (p === -1 || s.slice(p, p + 2) !== ", ") return null; p += 2;
+  var dd = _digits2(s, p); if (dd < 0 || s.charAt(p + 2) !== " ") return null; p += 3;
+  var mo = _monthAt(s, p); if (!mo || s.charAt(p + 3) !== " ") return null; p += 4;
+  var yy = _digits4(s, p); if (yy < 0 || s.charAt(p + 4) !== " ") return null; p += 5;
+  var t = _timeAt(s, p); if (!t || s.slice(t.next, t.next + 4) !== " GMT" || t.next + 4 !== s.length) return null;
+  return { day: dd, monName: mo, year: yy, hh: t.hh, mi: t.mi, ss: t.ss };
+}
+// rfc850-date (obsolete, still accepted): "Sunday, 06-Nov-94 08:49:37 GMT" -- a two-digit year expanded
+// relative to the receipt year.
+function _scanRfc850(s, refMs) {
+  var p = _matchName(s, 0, DOW_LONG);
+  if (p === -1 || s.slice(p, p + 2) !== ", ") return null; p += 2;
+  var dd = _digits2(s, p); if (dd < 0 || s.charAt(p + 2) !== "-") return null; p += 3;
+  var mo = _monthAt(s, p); if (!mo || s.charAt(p + 3) !== "-") return null; p += 4;
+  var yy = _digits2(s, p); if (yy < 0 || s.charAt(p + 2) !== " ") return null; p += 3;
+  var t = _timeAt(s, p); if (!t || s.slice(t.next, t.next + 4) !== " GMT" || t.next + 4 !== s.length) return null;
+  return { day: dd, monName: mo, year: _rfc850Year(yy, refMs), hh: t.hh, mi: t.mi, ss: t.ss };
+}
+// asctime-date (obsolete, still accepted): "Sun Nov  6 08:49:37 1994" -- a space-padded one/two-digit day.
+function _scanAsctime(s) {
+  var p = _matchName(s, 0, DOW_SHORT);
+  if (p === -1 || s.charAt(p) !== " ") return null; p += 1;
+  var mo = _monthAt(s, p); if (!mo || s.charAt(p + 3) !== " ") return null; p += 4;
+  var c0 = s.charAt(p);
+  if (!(c0 === " " || _isDigit(c0)) || !_isDigit(s.charAt(p + 1))) return null;
+  var dd = parseInt(s.slice(p, p + 2), 10); if (s.charAt(p + 2) !== " ") return null; p += 3;
+  var t = _timeAt(s, p); if (!t || s.charAt(t.next) !== " ") return null;
+  var yy = _digits4(s, t.next + 1); if (yy < 0 || t.next + 1 + 4 !== s.length) return null;
+  return { day: dd, monName: mo, year: yy, hh: t.hh, mi: t.mi, ss: t.ss };
+}
+
 // Parse an HTTP-date to epoch ms, or NaN when its grammar, calendar, or time is invalid. Built from the
 // extracted fields via Date.UTC (never Date.parse): every HTTP-date is UTC, the asctime form carries
 // no GMT token so delegating would parse it in local time, and the round-trip check rejects an
 // impossible date / time (Date.UTC normalizes Feb 31 -> Mar 2 just as Date.parse would).
 function httpDateMs(s, refMs) {
-  if (!HTTP_DATE_FORMS.some(function (re) { return re.test(s); })) return NaN;
-  var day, monName, year;
-  var asc = /^\w{3} (\w{3}) ([ \d]\d) /.exec(s);                           // asctime: month then day
-  if (asc) { monName = asc[1]; day = parseInt(asc[2], 10); year = parseInt(/(\d{4})$/.exec(s)[1], 10); }
-  else {
-    var dmy = /(\d{2})[ -](\w{3})[ -](\d{2,4})/.exec(s);                   // IMF / rfc850: day month year
-    if (!dmy) return NaN;
-    day = parseInt(dmy[1], 10); monName = dmy[2]; year = parseInt(dmy[3], 10);
-    if (year < 100) year = _rfc850Year(year, refMs);                       // rfc850 two-digit year
-  }
-  var t = /(\d{2}):(\d{2}):(\d{2})/.exec(s);
-  var mon = MONTHS.indexOf(monName);
-  if (!t || mon < 0) return NaN;
-  var hh = parseInt(t[1], 10), mi = parseInt(t[2], 10), ss = parseInt(t[3], 10);
-  var when = Date.UTC(year, mon, day, hh, mi, ss);
+  var f = _scanImf(s) || _scanRfc850(s, refMs) || _scanAsctime(s);
+  if (!f) return NaN;
+  var mon = MONTHS.indexOf(f.monName);
+  if (mon < 0) return NaN;
+  var when = Date.UTC(f.year, mon, f.day, f.hh, f.mi, f.ss);
   var d = new Date(when);
-  if (d.getUTCDate() !== day || d.getUTCMonth() !== mon || d.getUTCFullYear() !== year ||
-      d.getUTCHours() !== hh || d.getUTCMinutes() !== mi || d.getUTCSeconds() !== ss) return NaN;
+  if (d.getUTCDate() !== f.day || d.getUTCMonth() !== mon || d.getUTCFullYear() !== f.year ||
+      d.getUTCHours() !== f.hh || d.getUTCMinutes() !== f.mi || d.getUTCSeconds() !== f.ss) return NaN;
   return when;
 }
 
@@ -78,7 +122,7 @@ function parse(value, opts) {
   opts = opts || {};
   var raStr = String(value).trim();
   var out = { retryAfterSeconds: null, retryAfterDate: null };
-  if (/^\d+$/.test(raStr)) {
+  if (_isAllDigits(raStr)) {
     var n = parseInt(raStr, 10);
     // opts.cap (seconds): a caller that will clamp anyway (e.g. an ARI poll cadence) wants a delay above its
     // ceiling reduced to the ceiling, not rejected, so a valid-but-huge value never discards the response.

package/lib/http-transport.js

@@ -69,14 +69,38 @@ function _budget(value, key, dflt, max, E, code) {
 // form (e.g. what pki.est.cacerts / parseCertsOnly return), is silently ignored there, so the
 // connection would fail server authentication despite a valid anchor. Wrap a DER anchor as PEM
 // (a Buffer already carrying PEM text, or a PEM string, passes through unchanged).
+// The JS regex \s code points representable in a latin1 string (0..255): TAB LF VT FF CR SP NBSP.
+// Built at load so the source stays pure ASCII. The armor scan runs over a latin1 prefix, where these
+// are the only \s characters that can appear, so this is exactly /^\s*/ for that input.
+var _LATIN1_WS = String.fromCharCode(0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x20, 0xa0);
+
+// PEM armor at the START after optional whitespace, decided by character scan (no regex): skip the
+// leading \s run, then require "-----BEGIN ".
+function _looksLikePemArmor(s) {
+  var i = 0;
+  while (i < s.length && _LATIN1_WS.indexOf(s.charAt(i)) !== -1) i += 1;
+  return s.slice(i, i + 11) === "-----BEGIN ";
+}
+// Base64 wrapped to <=64-column lines, each terminated by LF (matching /.{1,64}/g -> "$&\n", which
+// keeps a trailing LF on the final line).
+function _wrap64Lines(s) {
+  var out = "";
+  for (var i = 0; i < s.length; i += 64) out += s.slice(i, i + 64) + "\n";
+  return out;
+}
+// The surrounding "[" "]" of an IPv6 literal removed, else the string unchanged (matching /^\[(.*)\]$/).
+function _stripIpv6Brackets(s) {
+  return (s.length >= 2 && s.charAt(0) === "[" && s.charAt(s.length - 1) === "]") ? s.slice(1, s.length - 1) : s;
+}
+
 function _pemifyAnchor(a) {
   if (typeof a === "string") return a;
   if (Buffer.isBuffer(a)) {
     // Detect PEM by its armor at the START (after optional whitespace) only: a DER certificate begins
     // with the SEQUENCE tag 0x30 and may itself contain the bytes "-----BEGIN" in a subject / extension
     // value, so an anywhere-search would leave such a DER anchor unwrapped and unusable.
-    if (/^\s*-----BEGIN /.test(a.toString("latin1", 0, 64))) return a;
-    var b64 = a.toString("base64").replace(/.{1,64}/g, "$&\n");
+    if (_looksLikePemArmor(a.toString("latin1", 0, 64))) return a;
+    var b64 = _wrap64Lines(a.toString("base64"));
     return "-----BEGIN CERTIFICATE-----\n" + b64 + "-----END CERTIFICATE-----\n";
   }
   return a;
@@ -179,11 +203,41 @@ var _guardedLookup = _makeGuardedLookup(nodeDns.lookup);
 // certificate / identity / handshake failure is a server-authentication failure;
 // anything else is a generic transport error. Every arm threads the raw fault as
 // `.cause`, so the diagnostic survives.
+// SELF.?SIGNED : "self", an optional single non-line-terminator character, then "signed" (in a lowercased string).
+function _hasSelfSigned(l) {
+  for (var i = 0; i + 4 <= l.length; i++) {
+    if (l.charCodeAt(i) === 0x73 && l.charCodeAt(i + 1) === 0x65 && l.charCodeAt(i + 2) === 0x6c && l.charCodeAt(i + 3) === 0x66) {
+      if (l.indexOf("signed", i + 4) === i + 4) return true;
+      var mid = l.charCodeAt(i + 4);
+      if (i + 4 < l.length && mid !== 0x0a && mid !== 0x0d && mid !== 0x2028 && mid !== 0x2029 && l.indexOf("signed", i + 5) === i + 5) return true;
+    }
+  }
+  return false;
+}
+// \bWORD\b : `word` (lowercase) bounded on both sides by a non-word character ([a-z0-9_]) or a string edge.
+function _hasWordBounded(l, word) {
+  var at = l.indexOf(word);
+  while (at !== -1) {
+    var before = at === 0 || !_isLowerWordChar(l.charCodeAt(at - 1));
+    var afterI = at + word.length;
+    var after = afterI === l.length || !_isLowerWordChar(l.charCodeAt(afterI));
+    if (before && after) return true;
+    at = l.indexOf(word, at + 1);
+  }
+  return false;
+}
+function _isLowerWordChar(c) { return (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c === 95; }
 function _classifyError(e, C) {
   if (e && e.pkiBlockedAddress) return C("blocked-address");
   var s = String((e && e.code) || "") + " " + String((e && e.message) || "");
-  if (/PROTOCOL_VERSION|UNSUPPORTED_PROTOCOL|VERSION_TOO_LOW|WRONG_VERSION|NO_PROTOCOLS_AVAILABLE|INAPPROPRIATE_FALLBACK/i.test(s)) return C("tls-floor");
-  if (/CERT|SELF.?SIGNED|VERIFY|ALTNAME|HOSTNAME|DEPTH_ZERO|LOCAL_ISSUER|HANDSHAKE|\bSSL\b|\bTLS\b/i.test(s)) return C("server-auth-failed");
+  var l = s.toLowerCase();
+  // /PROTOCOL_VERSION|UNSUPPORTED_PROTOCOL|VERSION_TOO_LOW|WRONG_VERSION|NO_PROTOCOLS_AVAILABLE|INAPPROPRIATE_FALLBACK/i
+  if (l.indexOf("protocol_version") !== -1 || l.indexOf("unsupported_protocol") !== -1 || l.indexOf("version_too_low") !== -1 ||
+      l.indexOf("wrong_version") !== -1 || l.indexOf("no_protocols_available") !== -1 || l.indexOf("inappropriate_fallback") !== -1) return C("tls-floor");
+  // /CERT|SELF.?SIGNED|VERIFY|ALTNAME|HOSTNAME|DEPTH_ZERO|LOCAL_ISSUER|HANDSHAKE|\bSSL\b|\bTLS\b/i
+  if (l.indexOf("cert") !== -1 || l.indexOf("verify") !== -1 || l.indexOf("altname") !== -1 || l.indexOf("hostname") !== -1 ||
+      l.indexOf("depth_zero") !== -1 || l.indexOf("local_issuer") !== -1 || l.indexOf("handshake") !== -1 ||
+      _hasSelfSigned(l) || _hasWordBounded(l, "ssl") || _hasWordBounded(l, "tls")) return C("server-auth-failed");
   return C("transport-error");
 }
 
@@ -256,7 +310,7 @@ function httpsTransport(defaults) {
     if (minVersion !== "TLSv1.2" && minVersion !== "TLSv1.3") throw E(C("bad-input"), "tls.minVersion must be 'TLSv1.2' or 'TLSv1.3' (never below the floor), got " + minVersion);
 
     var body = request.body;
-    if (Buffer.isBuffer(body)) body = guard.bytes.view(body, E, C("bad-input"), "the request body");
+    if (guard.bytes.isByteSource(body)) body = guard.bytes.source(body, E, C("bad-input"), "the request body");
 
     // Frame a body-bearing request with a fixed Content-Length computed from the EXACT body, so it is sent
     // length-delimited rather than Transfer-Encoding: chunked (node's default when a body is written with no
@@ -273,7 +327,7 @@ function httpsTransport(defaults) {
 
     // URL.hostname keeps the square brackets on an IPv6 literal ([2001:db8::1]); node's `hostname`
     // option and its IP-detection expect the bare address, so strip the brackets once here.
-    var host = url.hostname.replace(/^\[(.*)\]$/, "$1");
+    var host = _stripIpv6Brackets(url.hostname);
     var options = {
       method: request.method || "GET",
       hostname: host,

package/lib/inspect.js

@@ -121,7 +121,7 @@ function _serial(cert, indent) {
   // anything larger renders as a colon-hex block.
   if (buf.length <= 6) {
     var n = parseInt(buf.toString("hex") || "0", 16);
-    return "Serial Number: " + n + " (0x" + (buf.toString("hex").replace(/^0+/, "") || "0") + ")";
+    return "Serial Number: " + n + " (0x" + (_stripLeadingZeros(buf.toString("hex")) || "0") + ")";
   }
   return "Serial Number:\n" + " ".repeat(indent) + _hexColon(buf, {});
 }
@@ -905,11 +905,22 @@ _CMS_SHAPE[oid.byName("compressedData")] = function (o) { return _isObj(o.compre
 // SEQUENCE is a real Certificate/CertificateList -> delegate to the full sub-report
 // (guarded; a one-line summary on any failure); a CONTEXT-tagged CHOICE alternative
 // (attribute certificate / other) renders a one-line tag+size summary, never parsed.
+// Leading "0" characters removed, and a single trailing "\n" removed -- both by character scan
+// (no regex): display helpers, matching the /^0+/ and /\n$/ replacements they succeed.
+function _stripLeadingZeros(s) {
+  var i = 0;
+  while (i < s.length && s.charAt(i) === "0") i += 1;
+  return s.slice(i);
+}
+function _stripTrailingNewline(s) {
+  return (s.length > 0 && s.charAt(s.length - 1) === "\n") ? s.slice(0, s.length - 1) : s;
+}
+
 function _cmsEmbedded(kind, el, pad) {
   if (el.tagClass === "universal") {
     try {
       var sub = (kind === "CRL") ? crlReport(el.bytes) : certificate(el.bytes);
-      return pad + kind + ":\n" + sub.replace(/\n$/, "").split("\n").map(function (l) { return pad + "    " + l; }).join("\n");
+      return pad + kind + ":\n" + _stripTrailingNewline(sub).split("\n").map(function (l) { return pad + "    " + l; }).join("\n");
     } catch (_e) { /* fall through to the summary */ }
   }
   return pad + kind + " [" + el.tagClass + " " + el.tagNumber + "] (" + el.bytes.length + " bytes)";

package/lib/key.js

@@ -441,7 +441,7 @@ function _inferAlgorithm(detected) {
 function _importUsages(name, isPublic) {
   var n = String(name == null ? "" : name).toUpperCase();
   if (n === "X25519" || n === "X448" || n === "ECDH") return isPublic ? [] : ["deriveBits", "deriveKey"];
-  if (/^ML-KEM/.test(n)) return isPublic ? ["encapsulateBits"] : ["decapsulateBits"];
+  if (n.indexOf("ML-KEM") === 0) return isPublic ? ["encapsulateBits"] : ["decapsulateBits"];
   if (n === "RSA-OAEP") return isPublic ? ["encrypt"] : ["decrypt"];
   return isPublic ? ["verify"] : ["sign"];   // signing default (Ed / ECDSA / RSA-* sign / ML-DSA / SLH-DSA)
 }
@@ -449,7 +449,7 @@ function _importUsages(name, isPublic) {
 function _generateUsages(name) {
   var n = String(name == null ? "" : name).toUpperCase();
   if (n === "X25519" || n === "X448" || n === "ECDH") return ["deriveBits", "deriveKey"];
-  if (/^ML-KEM/.test(n)) return ["encapsulateBits", "decapsulateBits"];
+  if (n.indexOf("ML-KEM") === 0) return ["encapsulateBits", "decapsulateBits"];
   if (n === "RSA-OAEP") return ["encrypt", "decrypt"];
   return ["sign", "verify"];
 }

package/lib/lint.js

@@ -97,7 +97,7 @@ function _finding(rule, detail) {
 // would be the check computed and thrown away. Never throws: _ingest's contract is to return a
 // finding for bad DATA and reserve throws for a wrong-TYPE argument.
 function _derivedCert(o) {
-  if (!o || typeof o !== "object" || Buffer.isBuffer(o) || ArrayBuffer.isView(o) || o instanceof ArrayBuffer) return null;
+  if (!o || typeof o !== "object" || guard.bytes.isByteSource(o)) return null;
   try {
     var p = guard.parsed.acceptDerived(o, "certificate", x509.parse, _cfg, "lint/bad-input", "the certificate");
     return guard.parsed.isCert(p) ? p : null;