@blamejs/pki 0.8.59 → 0.8.60

package/lib/schema-engine.js

@@ -98,7 +98,7 @@ function isResourceRefusal(e) {
 function withResources(ns, source) {
   if (!source || (source.caps == null && source.budget == null)) return ns;
   var out = Object.create(null);
-  var keys = Object.keys(ns);
+  var keys = intrinsic.keys(ns);
   for (var i = 0; i < keys.length; i++) out[keys[i]] = ns[keys[i]];
   out.caps = source.caps;
   out.budget = source.budget;
@@ -146,11 +146,11 @@ function integerLeaf()    { return { kind: "leaf", read: asn1.read.integer, writ
 function boolean()        { return { kind: "leaf", read: asn1.read.boolean, write: function (v) { return asn1.build.boolean(v); } }; }
 function octetString()    { return { kind: "leaf", read: asn1.read.octetString, write: function (v) { return asn1.build.octetString(v); } }; }
 function bitString()      { return { kind: "leaf", read: function (n) { var b = asn1.read.bitString(n); return { unusedBits: b.unusedBits, bytes: b.bytes }; }, write: function (v) { return asn1.build.bitString(v.bytes, v.unusedBits); } }; }
-function implicitBitString(tag) { return { kind: "leaf", read: function (n) { var b = asn1.read.bitStringImplicit(n, tag); return { unusedBits: b.unusedBits, bytes: b.bytes }; }, write: function (v) { return asn1.build.contextPrimitive(tag, Buffer.concat([Buffer.from([v.unusedBits]), v.bytes])); } }; }
+function implicitBitString(tag) { return { kind: "leaf", read: function (n) { var b = asn1.read.bitStringImplicit(n, tag); return { unusedBits: b.unusedBits, bytes: b.bytes }; }, write: function (v) { return asn1.build.contextPrimitive(tag, intrinsic.bufferConcat([intrinsic.bufferFrom([v.unusedBits]), v.bytes])); } }; }
 function implicitOctetString(tag) { return { kind: "leaf", read: function (n) { return asn1.read.octetStringImplicit(n, tag); }, write: function (v) { return asn1.build.contextPrimitive(tag, v); } }; }
-function implicitNull(tag) { return { kind: "leaf", read: function (n) { return asn1.read.nullImplicit(n, tag); }, write: function () { return asn1.build.contextPrimitive(tag, Buffer.alloc(0)); } }; }
+function implicitNull(tag) { return { kind: "leaf", read: function (n) { return asn1.read.nullImplicit(n, tag); }, write: function () { return asn1.build.contextPrimitive(tag, intrinsic.bufferAlloc(0)); } }; }
 function implicitInteger(tag) { return { kind: "leaf", read: function (n) { return asn1.read.integerImplicit(n, tag); }, write: function (v) { return asn1.build.contextPrimitive(tag, _implicitIntContent(v)); } }; }
-function implicitBoolean(tag) { return { kind: "leaf", read: function (n) { return asn1.read.booleanImplicit(n, tag); }, write: function (v) { return asn1.build.contextPrimitive(tag, Buffer.from([v ? 0xff : 0x00])); } }; }
+function implicitBoolean(tag) { return { kind: "leaf", read: function (n) { return asn1.read.booleanImplicit(n, tag); }, write: function (v) { return asn1.build.contextPrimitive(tag, intrinsic.bufferFrom([v ? 0xff : 0x00])); } }; }
 function any()            { return { kind: "any" }; }
 function decode(fn, write) { return { kind: "decode", fn: fn, write: write }; }
 
@@ -328,7 +328,14 @@ function _walkRepeat(schema, node, ctx) {
       if (seen.has(key)) _fail(ctx, schema.dupCode || schema.code, "duplicate element " + key);
       seen.add(key);
     }
-    items.push(item);
+    /** @internal The element is APPENDED by defining its index. `push` stores, and a store walks the
+     *  prototype chain for a setter, so an accessor at an array index received each element as the
+     *  repeat was walked and left the list a hole that reads back whatever its getter answers.
+     *  `m.items` is what every build() reads its elements out of, and a DN is a SEQUENCE OF RDN:
+     *  measured, a certificate whose subject is `C=US, ST=California, O=blamejs pki, OU=Test,
+     *  CN=pkijs.com` parsed with the accessor's value in place of its first RDN, and the parse threw
+     *  a bare TypeError rather than a typed refusal. */
+    intrinsic.append(items, item);
   }
   var match = { kind: "repeat", node: node, items: items };
   if (schema.build) match.result = schema.build(match, ctx);
@@ -336,7 +343,7 @@ function _walkRepeat(schema, node, ctx) {
 }
 
 function _equalsDefault(value, def) {
-  if (Buffer.isBuffer(value) && Buffer.isBuffer(def)) return value.equals(def);
+  if (intrinsic.isBuffer(value) && intrinsic.isBuffer(def)) return intrinsic.bufferEquals(value, def);
   return value === def;
 }
 
@@ -439,7 +446,7 @@ function _encFail(message) { throw new Error("schema.encode: " + message); }
 function encode(schema, value, ctx) {
   switch (schema.kind) {
     case "leaf":     return schema.write(value);
-    case "any":      return Buffer.isBuffer(value) ? value : value.bytes;
+    case "any":      return intrinsic.isBuffer(value) ? value : value.bytes;
     case "decode":
       if (typeof schema.write !== "function") _encFail("this decode leaf has no paired encoder (decode(fn, write))");
       return schema.write(value, ctx);
@@ -453,7 +460,7 @@ function encode(schema, value, ctx) {
 }
 
 function _wrapConstructed(schema, parts) {
-  if (schema.implicitTag != null) return asn1.build.contextConstructed(schema.implicitTag, Buffer.concat(parts));
+  if (schema.implicitTag != null) return asn1.build.contextConstructed(schema.implicitTag, intrinsic.bufferConcat(parts));
   var mode = schema.assert || "sequence";
   if (mode === "set") return asn1.build.set(parts);
   if (mode === "sequence" || mode === "constructed") return asn1.build.sequence(parts);
@@ -469,13 +476,17 @@ function _encodeSeq(schema, value, ctx) {
   for (var f = 0; f < schema.fields.length; f++) {
     var fld = schema.fields[f];
     if (fld.fkind === "required") {
-      parts.push(encode(fld.schema, value[fld.name], ctx));
+      /** @internal Each field is APPENDED by defining its index, for the reason the repeat walk is:
+       *  `push` stores, a store consults a setter inherited at the index, and these parts are
+       *  concatenated in order into the structure this encoder emits. Measured, an accessor at
+       *  index 0 put its own TLV where the first field belongs. */
+      intrinsic.append(parts, encode(fld.schema, value[fld.name], ctx));
     } else if (fld.fkind === "optional") {
       if (_present(value[fld.name])) {
         var enc = encode(fld.schema, value[fld.name], ctx);
         var isDefault = fld.hasDefault && fld.def !== undefined &&
-          enc.equals(encode(fld.schema, fld.def, ctx));
-        if (!isDefault) parts.push(fld.explicit ? asn1.build.explicit(fld.tag, enc) : enc);
+          intrinsic.bufferEquals(enc, encode(fld.schema, fld.def, ctx));
+        if (!isDefault) intrinsic.append(parts, fld.explicit ? asn1.build.explicit(fld.tag, enc) : enc);
       }
     } else if (fld.fkind === "trailing") {
       var members = guardList.sortedCopy(fld.members, function (a, b) { return a.tag - b.tag; });
@@ -483,7 +494,7 @@ function _encodeSeq(schema, value, ctx) {
         var mm = members[i];
         if (_present(value[mm.name])) {
           var menc = encode(mm.schema, value[mm.name], ctx);
-          parts.push(mm.explicit ? asn1.build.explicit(mm.tag, menc) : menc);
+          intrinsic.append(parts, mm.explicit ? asn1.build.explicit(mm.tag, menc) : menc);
         }
       }
     } else {
@@ -494,17 +505,21 @@ function _encodeSeq(schema, value, ctx) {
 }
 
 function _encodeRepeat(schema, items, ctx) {
-  if (!Array.isArray(items)) _encFail("a repeat value must be an array");
+  if (!intrinsic.isArray(items)) _encFail("a repeat value must be an array");
   if (schema.min != null && items.length < schema.min) {
     _encFail("this repeat requires at least " + schema.min + " element(s) but got " + items.length);
   }
   if (schema.max != null && items.length > schema.max) {
     _encFail("this repeat caps at " + schema.max + " element(s) but got " + items.length);
   }
-  var parts = items.map(function (it) { return encode(schema.item, it, ctx); });
+  /** @internal The elements are mapped through the captured operation, which builds its result by
+   *  defining each index on a plain array. `Array.prototype.map` is replaceable and reads the
+   *  receiver's `Symbol.species` to construct what it returns, so a caller's array could both
+   *  choose the encoded elements and hand this encoder a result object of its own class. */
+  var parts = intrinsic.mapList(items, function (it) { return encode(schema.item, it, ctx); });
   if (schema.unique) {
     var seen = new Set();
-    parts.forEach(function (tlv) {
+    intrinsic.forEach(parts, function (tlv) {
       // allow:bare-decode a round trip through the codec on a TLV this encoder just produced.
       var item = { node: asn1.decode(tlv) };
       item.value = walk(schema.item, item.node, ctx);
@@ -517,7 +532,7 @@ function _encodeRepeat(schema, items, ctx) {
    *  is the engine's own SET OF emission, so whatever decides "before" decides the bytes every schema
    *  built on it emits. */
   if (schema.derSetOrder) parts = guardList.sortedCopy(parts, intrinsic.compare);
-  if (schema.implicitTag != null) return asn1.build.contextConstructed(schema.implicitTag, Buffer.concat(parts));
+  if (schema.implicitTag != null) return asn1.build.contextConstructed(schema.implicitTag, intrinsic.bufferConcat(parts));
   return schema.assert === "set" ? asn1.build.set(parts) : asn1.build.sequence(parts);
 }
 
@@ -586,11 +601,14 @@ function isUniversal(node, tagNumber) {
 function isContext(node, tagNumber) {
   return !!node && node.tagClass === "context" && node.tagNumber === tagNumber;
 }
+/** @internal Both read the OWN elements of the tag list. `indexOf` is specified in terms of
+ *  HasProperty, so a list with a hole at an index answers from the array prototype, and the list
+ *  here is an allow-list deciding whether a node's tag is one a schema accepts. */
 function isUniversalOneOf(node, tagNumbers) {
-  return !!node && node.tagClass === "universal" && tagNumbers.indexOf(node.tagNumber) !== -1;
+  return !!node && node.tagClass === "universal" && intrinsic.ownIndexOf(tagNumbers, node.tagNumber) !== -1;
 }
 function isContextOneOf(node, tagNumbers) {
-  return !!node && node.tagClass === "context" && tagNumbers.indexOf(node.tagNumber) !== -1;
+  return !!node && node.tagClass === "context" && intrinsic.ownIndexOf(tagNumbers, node.tagNumber) !== -1;
 }
 function isContextInRange(node, min, max) {
   return !!node && node.tagClass === "context" && node.tagNumber >= min && node.tagNumber <= max;

package/lib/schema-pkcs1.js

@@ -264,11 +264,15 @@ function encode(key) {
   var infos = key.otherPrimeInfos;
   if (intrinsic.isArray(infos) && infos.length > 0) {
     var rows = [];
+    /** @internal Both appends define the index. A store at an index a list has no own property at
+     *  walks the prototype chain for a setter, so an accessor there took the element and the list
+     *  read back whatever its getter answers; `kids` holds nine own slots here, so index nine is
+     *  such a store. These are the bytes a private key encodes to. */
     for (var i = 0; i < infos.length; i++) {
-      rows[i] = asn1.build.sequence([asn1.build.integer(infos[i].prime),
-        asn1.build.integer(infos[i].exponent), asn1.build.integer(infos[i].coefficient)]);
+      intrinsic.append(rows, asn1.build.sequence([asn1.build.integer(infos[i].prime),
+        asn1.build.integer(infos[i].exponent), asn1.build.integer(infos[i].coefficient)]));
     }
-    kids[9] = asn1.build.sequence(rows);
+    intrinsic.append(kids, asn1.build.sequence(rows));
   }
   return asn1.build.sequence(kids);
 }

package/lib/schema-pkcs12.js

@@ -47,6 +47,9 @@ var cms = require("./schema-cms.js");
 var pkcs8 = require("./schema-pkcs8.js");
 var frameworkError = require("./framework-error.js");
 var guard = require("./guard-all.js");
+/** @internal The append this module's lists are built with: `push` stores at the index and a store
+ *  consults a setter inherited there, which takes the element being appended. */
+var _push = guard.list.append;
 
 var Pkcs12Error = frameworkError.Pkcs12Error;
 var PemError = frameworkError.PemError;
@@ -181,7 +184,7 @@ var SAFE_BAG = schema.seq([
       var items = m.fields.bagAttributes.value.items;
       for (var i = 0; i < items.length; i++) {
         var a = items[i].value.result;
-        attributes.push(a);
+        _push(attributes, a);
         if (a.type === OID_FRIENDLY_NAME) {
           if (seen[a.type] || a.values.length !== 1) throw ctx.E("pkcs12/bad-friendly-name", "friendlyName carries exactly one BMPString value (PKCS#9 SINGLE VALUE)");
           friendlyName = _bmpValue(a.values[0], ctx);
@@ -319,7 +322,7 @@ function walkSafeContents(der, ctx) {
   var walked = schema.walk(SAFE_CONTENTS, pkix.decodeNested(der, ns, "a SafeContents", { ber: true }), ns);
   var state = { budget: { remaining: C.LIMITS.PKCS12_MAX_REDECODES }, bagDepth: 0 };
   var bags = [];
-  for (var i = 0; i < walked.items.length; i++) bags.push(_buildBag(walked.items[i].value.result, state, ns));
+  for (var i = 0; i < walked.items.length; i++) _push(bags, _buildBag(walked.items[i].value.result, state, ns));
   return bags;
 }
 
@@ -334,12 +337,12 @@ function _dispatchSafes(asMatch, state, ctx) {
         budget: state.budget, budgetCode: "pkcs12/too-deep",
       });
       for (var j = 0; j < contents.items.length; j++) {
-        safeBags.push(_buildBag(contents.items[j].value.result, state, ctx));
+        _push(safeBags, _buildBag(contents.items[j].value.result, state, ctx));
       }
     } else if (el.contentType === OID_ENCRYPTED_DATA) {
-      encryptedSafes.push({ type: "encryptedData", content: _privacySafe(cms.walkEncryptedData(el.innerNode, ctx), ctx) });
+      _push(encryptedSafes, { type: "encryptedData", content: _privacySafe(cms.walkEncryptedData(el.innerNode, ctx), ctx) });
     } else if (el.contentType === OID_ENVELOPED_DATA) {
-      encryptedSafes.push({ type: "envelopedData", content: _privacySafe(cms.walkEnvelopedData(el.innerNode, ctx), ctx), envelopedDataDer: el.innerNode.bytes });
+      _push(encryptedSafes, { type: "envelopedData", content: _privacySafe(cms.walkEnvelopedData(el.innerNode, ctx), ctx), envelopedDataDer: el.innerNode.bytes });
     } else {
       throw ctx.E("pkcs12/bad-safe-contentinfo-type", "an AuthenticatedSafe element must be id-data, id-encryptedData, or id-envelopedData (RFC 7292 sec. 4.1), got " +
         (ctx.oid.name(el.contentType) || el.contentType));
@@ -391,7 +394,7 @@ function _buildBag(rec, state, ctx) {
     bag.nested = [];
     var nestedMatch = schema.walk(SAFE_CONTENTS, rec.valueNode, ctx);
     for (var i = 0; i < nestedMatch.items.length; i++) {
-      bag.nested.push(_buildBag(nestedMatch.items[i].value.result, nestedState, ctx));
+      _push(bag.nested, _buildBag(nestedMatch.items[i].value.result, nestedState, ctx));
     }
     return bag;
   }

package/lib/schema-pkix.js

@@ -11,8 +11,17 @@ var intrinsic = require("./guard-intrinsic");
 var frameworkError = require("./framework-error");
 var _hasOwn = intrinsic.hasOwn;
 var _forEach = intrinsic.forEach;
-var _map = intrinsic.map;
-var _push = intrinsic.push;
+/** @internal `mapList`, not the captured `map`. `Array.prototype.map` is specified to build its
+ *  result through `ArraySpeciesCreate`, which reads the receiver's `constructor` and then that
+ *  constructor's `Symbol.species`, so a getter installed on `Array.prototype.constructor` runs
+ *  caller code with the list being mapped as its `this` on every call. Capturing the method closes
+ *  which function runs, not the protocol it consults. Measured on a certificate parse: the
+ *  extension-list build was reached that way. `mapList` defines each index on a plain array. */
+var _map = intrinsic.mapList;
+/** @internal `append`, not a captured `push`: a store at an index walks the prototype chain for a
+ *  setter, so an accessor there takes the element being appended. The lists built here are the parsed
+ *  members every format module reads its fields from. `append` defines the index. */
+var _push = intrinsic.append;
 var _join = intrinsic.join;
 var _stringify = intrinsic.stringify;
 var _String = intrinsic.String;
@@ -51,7 +60,14 @@ function _hasNonWhitespace(s) {
   for (var i = 0; i < s.length; i++) { if (!_isJsWhitespace(_charCodeAt(s, i))) return true; }
   return false;
 }
-function _charTable(chars) { var t = []; for (var i = 0; i < chars.length; i++) t[_charCodeAt(chars, i)] = true; return t; }
+/** @internal The table has NO PROTOTYPE, because it is deliberately sparse: it holds an entry for
+ *  each character it allows and nothing at the codes it does not, and `_allCharsIn` below reads it at
+ *  the code of each character it is asked about. Built as an array literal, every code outside the
+ *  allowed set was a hole, so a value installed at that index on `Array.prototype` answered the
+ *  check: measured, `Array.prototype[47] = true` made `pki.acme.keyAuthorization` accept a challenge
+ *  token containing `/`, which the base64url set does not allow, instead of refusing it with
+ *  `acme/bad-token`. The same helper in lib/guard-name.js has always been written this way. */
+function _charTable(chars) { var t = _create(null); for (var i = 0; i < chars.length; i++) t[_charCodeAt(chars, i)] = true; return t; }
 function _allCharsIn(s, table) {
   if (s.length === 0) return false;
   for (var i = 0; i < s.length; i++) { if (!table[_charCodeAt(s, i)]) return false; }

package/lib/schema-sec1.js

@@ -210,7 +210,10 @@ function encode(key) {
     asn1.build.octetString(key.privateKey),
     asn1.build.explicit(0, asn1.build.oid(curveOid))];
   if (key.publicKey !== undefined && key.publicKey !== null) {
-    kids[3] = asn1.build.explicit(1, asn1.build.bitString(key.publicKey, 0));
+    /** @internal Appended by defining the index. `kids` holds three own slots above, so assigning at
+     *  index three is a store, and a store walks the prototype chain for a setter: an accessor there
+     *  would take the public key out of the structure this encodes. */
+    intrinsic.append(kids, asn1.build.explicit(1, asn1.build.bitString(key.publicKey, 0)));
   }
   return asn1.build.sequence(kids);
 }

package/lib/schema-tsp.js

@@ -43,6 +43,9 @@ var smime = require("./schema-smime");
 var cms = require("./schema-cms");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+/** @internal The append this module's lists are built with: `push` stores at the index and a store
+ *  consults a setter inherited there, which takes the element being appended. */
+var _push = guard.list.append;
 
 var TspError = frameworkError.TspError;
 var PemError = frameworkError.PemError;
@@ -196,7 +199,7 @@ function _namedBits(bytes) {
     if ((bytes[i >> 3] >> (7 - (i & 7))) & 1) {
       var nm = FAILURE_BITS[i];
       if (!nm) throw NS.E("tsp/bad-failinfo", "unsupported PKIFailureInfo bit " + i + " (RFC 3161 sec. 2.4.2)");
-      out.push(nm);
+      _push(out, nm);
     }
   }
   return out;

package/lib/shbs.js

@@ -24,6 +24,10 @@
 var nodeCrypto = require("crypto");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+/** @internal The append every list here is built with: `push` stores at the index and a store
+ *  consults a setter inherited there, and these lists are the authentication path and the one-time
+ *  values a hash-based signature is formed from. */
+var _push = guard.list.append;
 var constants = require("./constants");
 
 var ShbsError = frameworkError.ShbsError;
@@ -124,7 +128,7 @@ function _lmotsKc(otsSet, I, q, C, y, message) {
     var a = _coef(Qc, i, w);
     var tmp = y[i];
     for (var j = a; j < (1 << w) - 1; j++) tmp = _hash(f, n, [I, qb, u16(i), u8(j), tmp]);
-    z.push(tmp);
+    _push(z,tmp);
   }
   return _hash(f, n, z);
 }
@@ -148,11 +152,11 @@ function _lmsVerify(pubBytes, message, sigBytes) {
   var n = otsSet.n, p = otsSet.p;
   var C = sr.take(n);
   var y = [];
-  for (var yi = 0; yi < p; yi++) y.push(sr.take(n));
+  for (var yi = 0; yi < p; yi++) _push(y,sr.take(n));
   var sigLmsType = sr.u32();
   if (sigLmsType !== lmsSet.code) return false;
   var path = [];
-  for (var pi = 0; pi < h; pi++) path.push(sr.take(m));
+  for (var pi = 0; pi < h; pi++) _push(path,sr.take(m));
   if (!sr.atEnd()) throw _err("shbs/bad-signature", "LMS signature has " + sr.remaining() + " trailing byte(s)");
   if (q >= Math.pow(2, h)) return false;
 

package/lib/smime.js

@@ -41,6 +41,10 @@ var schemaX509 = require("./schema-x509.js");
 var pkix = require("./schema-pkix.js");
 var oid = require("./oid.js");
 var guard = require("./guard-all.js");
+/** @internal The append every list here is built with: `push` stores at the index and a store
+ *  consults a setter inherited there, and these lists become the headers and parts a signed or
+ *  encrypted message carries. */
+var _push = guard.list.append;
 var pkiBuild = require("./pki-build.js");
 var C = require("./constants.js");
 var nodeUtil = require("util");
@@ -118,13 +122,13 @@ function _hpHeaderList(headers) {
       if (!h || typeof h !== "object") throw _err("smime/bad-input", "each opts.headers entry must be { name, value }");
       var name = h.name, v = h.value;
       if (typeof name !== "string") throw _err("smime/bad-input", "each opts.headers entry must be { name, value }");
-      out.push({ name: name, value: v == null ? "" : String(v) });
+      _push(out,{ name: name, value: v == null ? "" : String(v) });
     });
   } else if (typeof headers === "object") {
     var hn = guard.identifier.optionNames(headers);
     for (var hi = 0; hi < hn.length; hi++) {
       var hv = headers[hn[hi]];
-      out.push({ name: hn[hi], value: hv == null ? "" : String(hv) });
+      _push(out,{ name: hn[hi], value: hv == null ? "" : String(hv) });
     }
   } else {
     throw _err("smime/bad-input", "opts.headers must be an object or an array of { name, value }");
@@ -155,9 +159,9 @@ function _outerHeaderList(list, mode, hcp) {
   list.forEach(function (h) {
     if (mode === "cipher") {
       var v = _applyHcp(h.name, h.value, policy);
-      if (v !== null) out.push({ name: h.name, value: v });
+      if (v !== null) _push(out,{ name: h.name, value: v });
     } else {
-      out.push({ name: h.name, value: h.value });
+      _push(out,{ name: h.name, value: h.value });
     }
   });
   return out;
@@ -171,9 +175,9 @@ function _protectedInnerEntity(content, opts, mode, hpList, outerList) {
   if (cty != null && mime.hasParam(cty, "hp")) throw _err("smime/bad-input", "opts.contentType must not set the hp parameter -- header protection sets it (hp=" + guard.text.showValue(mode) + ")");
   var ct = (cty || "text/plain; charset=utf-8") + "; hp=\"" + mode + "\"";
   var fields = [{ name: "Content-Type", value: ct }, { name: "Content-Transfer-Encoding", value: _is7bit(raw) ? "7bit" : "8bit" }];
-  hpList.forEach(function (h) { fields.push(h); });
+  hpList.forEach(function (h) { _push(fields,h); });
   if (mode === "cipher") {
-    outerList.forEach(function (h) { fields.push({ name: "HP-Outer", value: h.name + ": " + h.value }); });
+    outerList.forEach(function (h) { _push(fields,{ name: "HP-Outer", value: h.name + ": " + h.value }); });
   }
   return mime.buildEntity(fields, raw, SmimeError, "smime/bad-header");
 }
@@ -227,7 +231,7 @@ function _contentTypeLines(s) {
   var lines = [], lineStart = 0;
   while (lineStart <= s.length) {
     var line = _contentTypeLineAt(s, lineStart);
-    if (line !== null) lines.push(line);
+    if (line !== null) _push(lines,line);
     var nl = s.indexOf("\n", lineStart);
     if (nl === -1) break;
     lineStart = nl + 1;
@@ -274,11 +278,11 @@ function _extractProtected(headerList) {
     if (_isStructural(h.lname)) return;
     if (h.lname === "hp-outer") {
       var ci = h.rawValue.indexOf(":");
-      if (ci >= 0) refouter.push({ name: h.rawValue.slice(0, ci).trim().toLowerCase(), value: h.rawValue.slice(ci + 1).trim() });
+      if (ci >= 0) _push(refouter,{ name: h.rawValue.slice(0, ci).trim().toLowerCase(), value: h.rawValue.slice(ci + 1).trim() });
       return;
     }
     var val = _utf8Header(h.rawValue);
-    entries.push({ name: h.name, value: val, raw: h.rawValue });
+    _push(entries,{ name: h.name, value: val, raw: h.rawValue });
     if (seen[h.lname]) { dup = h.name; if (RFC5322_SINGLETON.has(h.lname)) dupSingleton = h.name; }
     seen[h.lname] = 1;
     protectedHeaders[h.name] = val;
@@ -297,7 +301,7 @@ function _computeConfidential(entries, refouter) {
   entries.forEach(function (e) {
     var m = byName.get(e.name.toLowerCase()), val = e.raw.trim(), n = (m && m.get(val)) || 0;
     if (n > 0) { m.set(val, n - 1); return; }
-    if (!seen[e.name]) { seen[e.name] = 1; confidential.push(e.name); }
+    if (!seen[e.name]) { seen[e.name] = 1; _push(confidential,e.name); }
   });
   return confidential;
 }
@@ -305,7 +309,7 @@ function _computeConfidential(entries, refouter) {
 function _computeFromMismatch(innerFrom, outerEnt) {
   if (innerFrom == null) return null;
   var outerFroms = [];
-  outerEnt.headers.forEach(function (h) { if (h.lname === "from") outerFroms.push(h.value.trim()); });
+  outerEnt.headers.forEach(function (h) { if (h.lname === "from") _push(outerFroms,h.value.trim()); });
   return outerFroms.length !== 1 || outerFroms[0] !== innerFrom.trim();
 }
 
@@ -315,7 +319,7 @@ function _isCryptoLayer(type) {
 
 function _outerRefouter(outerEnt) {
   var r = [];
-  outerEnt.headers.forEach(function (h) { if (!_isStructural(h.lname) && h.lname !== "hp-outer") r.push({ name: h.lname, value: h.rawValue.trim() }); });
+  outerEnt.headers.forEach(function (h) { if (!_isStructural(h.lname) && h.lname !== "hp-outer") _push(r,{ name: h.lname, value: h.rawValue.trim() }); });
   return r;
 }
 
@@ -572,7 +576,7 @@ function _cmsSignOpts(opts, detached) {
 function _micName(name) { return name ? (MICALG[name] || name) : null; }
 function _micalgSet(value) {
   var seen = [];
-  String(value).split(",").forEach(function (m) { var t = m.trim().toLowerCase(); if (t && seen.indexOf(t) < 0) seen.push(t); });
+  String(value).split(",").forEach(function (m) { var t = m.trim().toLowerCase(); if (t && seen.indexOf(t) < 0) _push(seen,t); });
   return seen.sort().join(",");
 }
 function _micalgOf(p7Der) {
@@ -582,7 +586,7 @@ function _micalgOf(p7Der) {
   var out = [];
   (parsed.signerInfos || []).forEach(function (si) {
     var mic = _micName(si.digestAlgorithm && si.digestAlgorithm.name);
-    if (mic && out.indexOf(mic) < 0) out.push(mic);
+    if (mic && out.indexOf(mic) < 0) _push(out,mic);
   });
   return out.length ? out.sort().join(",") : null;
 }

package/lib/tlog.js

@@ -69,9 +69,10 @@ var _strSlice = intrinsic.uncurry(String.prototype.slice);
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _arrSlice = intrinsic.arraySlice;
 var _join = intrinsic.join;
-var _push = intrinsic.push;
+/** @internal `append`, not a captured `push`: a store at an index walks the prototype chain for a
+ *  setter, so an accessor there takes the element being appended. `append` defines it. */
+var _push = intrinsic.append;
 var _pop = intrinsic.pop;
-var _unshift = intrinsic.unshift;
 var _bufToString = intrinsic.bufToString;
 var _bufferFrom = intrinsic.bufferFrom;
 var _byteLength = intrinsic.byteLength;
@@ -798,20 +799,25 @@ var MAX_INDEX_SEGMENTS = (function () {
   return count;
 })();
 
+/** @internal The segments are counted and then APPENDED most-significant first, by defining each
+ *  index. Prepending STORES at an index, and a store walks the prototype chain for a setter, so an
+ *  accessor inherited at an array index took each segment and left the list reading back its getter's
+ *  value; the `x` prefix was then applied by a read-modify-write through the same hole. These
+ *  segments are the path a tile is requested from, so the list decides which bytes a verification
+ *  reads. */
 function _indexPath(index) {
   var n = guard.range.uint64(index, _err, "tlog/bad-tile", "a tile index");
-  var segments = [];
-  var rest = n;
   var thousand = 1000n;
-  for (;;) {
-    var part = rest % thousand;
-    var text = _stringOf(part);
+  var count = 1;
+  for (var probe = n / thousand; probe > 0n; probe = probe / thousand) count++;
+  var segments = [];
+  for (var k = count - 1; k >= 0; k--) {
+    var scale = 1n;
+    for (var p = 0; p < k; p++) scale = scale * thousand;
+    var text = _stringOf((n / scale) % thousand);
     while (text.length < TILE_SEGMENT_DIGITS) text = "0" + text;
-    _unshift(segments, text);
-    rest = rest / thousand;
-    if (rest === 0n) break;
+    _push(segments, k === 0 ? text : "x" + text);
   }
-  for (var i = 0; i < segments.length - 1; i++) segments[i] = "x" + segments[i];
   return _join(segments, "/");
 }
 

package/lib/tuf.js

@@ -57,7 +57,9 @@ var _hasOwn = intrinsic.hasOwn;
 var _bufferFrom = intrinsic.bufferFrom;
 var _bufferConcat = intrinsic.bufferConcat;
 var _bufToString = intrinsic.bufToString;
-var _push = intrinsic.push;
+/** @internal `append`, not a captured `push`: a store at an index walks the prototype chain for a
+ *  setter, so an accessor there takes the element being appended. `append` defines it. */
+var _push = intrinsic.append;
 var _strSlice = intrinsic.uncurry(String.prototype.slice);
 var _codePointAt = intrinsic.uncurry(String.prototype.codePointAt);
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);

package/lib/validator-keydesc.js

@@ -4,6 +4,9 @@
 // @internal
 
 var asn1 = require("./asn1-der");
+/** @internal The append this module's list is built with: `push` stores at the index and a store
+ *  consults a setter inherited there, which takes the element being appended. */
+var _push = require("./guard-list").append;
 
 function _alGet(seqNode, tag) {
   if (!seqNode || !seqNode.children) return null;
@@ -23,7 +26,7 @@ function _purposeUnion(a, b, E, code) {
   var out = [];
   [a, b].forEach(function (list) {
     var p = _alGet(list, 1);
-    if (p && p.children) p.children.forEach(function (c) { var v = _alInt(c, E, code); if (out.indexOf(v) === -1) out.push(v); });
+    if (p && p.children) p.children.forEach(function (c) { var v = _alInt(c, E, code); if (out.indexOf(v) === -1) _push(out,v); });
   });
   return out;
 }

package/lib/validator-tls.js

@@ -5,6 +5,11 @@
 
 var C = require("./constants");
 var ByteReader = require("./byte-reader");
+/** @internal The append every list here is built with. `push` STORES at the index and a store walks
+ *  the prototype chain for a setter, so an accessor inherited at an array index takes the element
+ *  being appended. Taken from `guard-list` rather than `guard-intrinsic`, since this module needs the
+ *  one primitive and not the captures. */
+var _push = require("./guard-list").append;
 
 var MAX_VECTOR_24 = 0xffffff;
 var MAX_VECTOR_16 = 0xffff;
@@ -36,7 +41,7 @@ function _extensionRecords(view, E, codes) {
         type + " (RFC 8446 sec. 4.2)");
     }
     seen[type] = true;
-    out.push({ type: type, data: Buffer.from(data) });
+    _push(out,{ type: type, data: Buffer.from(data) });
   }
   return out;
 }
@@ -68,7 +73,7 @@ function certificateMessage(view, E, codes, certificateType) {
     };
     if (certificateType === "RawPublicKey") entry.spki = Buffer.from(data);
     else entry.certData = Buffer.from(data);
-    entries.push(entry);
+    _push(entries,entry);
   }
   return { certificateRequestContext: Buffer.from(context), entries: entries };
 }

package/lib/webcrypto.js

@@ -89,7 +89,9 @@ var _subarray = intrinsic.subarray;
 var _arrayBufferSlice = intrinsic.arrayBufferSlice;
 var _numberToString = intrinsic.numberToString;
 var _bigIntToString = intrinsic.bigIntToString;
-var _push = intrinsic.push;
+/** @internal `append`, not a captured `push`: a store at an index walks the prototype chain for a
+ *  setter, so an accessor there takes the element being appended. `append` defines it. */
+var _push = intrinsic.append;
 var _concat = intrinsic.concat;
 var _resolve = intrinsic.uncurry(intrinsic.promiseResolve);
 /** @internal The promise constructor, captured at load. `promiseResolve` builds its promise from the
@@ -222,7 +224,11 @@ function CryptoKey(type, extractable, algorithm, usages, handle) {
   if (usages != null && !_isArray(usages)) {
     throw new WebCryptoError("webcrypto/syntax", "usages must be an array of key-usage strings");
   }
-  this.usages = usages ? _arraySlice(usages) : [];
+  /** @internal `copyList`, not the captured `slice`. `Array.prototype.slice` builds its result
+   *  through `ArraySpeciesCreate`, which reads the receiver's `constructor` and then its
+   *  `Symbol.species`, so the copy of a caller's usage list ran a lookup the caller could answer.
+   *  `copyList` defines each index on a plain array. */
+  this.usages = usages ? intrinsic.copyList(usages) : [];
   _defineProperty(this, "_handle", { value: handle, enumerable: false });
 }
 
@@ -647,7 +653,7 @@ function _pbkdf2Async(pw, salt, iterations, keylen, digest) {
       try { nodeCrypto.pbkdf2(pw, salt, iterations, keylen, digest, done); }
       catch (e) { done(e); }
     }
-    if (_pbkdf2InFlight < _PBKDF2_MAX_CONCURRENT) start(); else _pbkdf2Waiters.push(start);
+    if (_pbkdf2InFlight < _PBKDF2_MAX_CONCURRENT) start(); else _push(_pbkdf2Waiters,start);
   });
 }