@depup/mongoose 9.8.1-depup.0 → 9.9.0-depup.0

package/lib/helpers/document/applyDefaults.js

@@ -3,39 +3,101 @@
 const isNestedProjection = require('../projection/isNestedProjection');
 
 module.exports = function applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSetters, pathsToSkip, options) {
-  const paths = Object.keys(doc.$__schema.paths);
-  const plen = paths.length;
+  const schemaPaths = doc.$__schema.paths;
   const skipParentChangeTracking = options?.skipParentChangeTracking;
+  const skipId = doc.$__.skipId;
+  // Whether any path has a function default that must run **after** setters,
+  // so callers doing a before-setters pass can skip the after-setters pass
+  // entirely when this comes back `false`.
+  let hasPostSetterDefaults = false;
 
-  for (let i = 0; i < plen; ++i) {
+  for (const p in schemaPaths) {
     let def;
     let curPath = '';
-    const p = paths[i];
 
-    if (p === '_id' && doc.$__.skipId) {
+    if (p === '_id' && skipId) {
       continue;
     }
 
-    const type = doc.$__schema.paths[p];
+    const type = schemaPaths[p];
     // `getDefault()` returns undefined when `defaultValue` is undefined, in which
     // case this loop never modifies the doc, so skip traversing the path entirely.
     if (type.defaultValue === undefined) {
       continue;
     }
+    if (typeof type.defaultValue === 'function' && !type.defaultValue.$runBeforeSetters) {
+      hasPostSetterDefaults = true;
+    }
     const path = type.splitPath();
     const len = path.length;
     if (path[len - 1] === '$*') {
       continue;
     }
+
     let included = false;
     let doc_ = doc._doc;
+
+    if (len === 1) {
+      if (exclude === true) {
+        if (p in fields) {
+          continue;
+        }
+      } else if (exclude === false && fields) {
+        const hasSubpaths = type.$isSingleNested || type.$isMongooseDocumentArray;
+        if ((p in fields && !isNestedProjection(fields[p])) || (hasSubpaths && hasIncludedChildren != null && hasIncludedChildren[p])) {
+          included = true;
+        } else if (hasIncludedChildren != null && !hasIncludedChildren[p]) {
+          continue;
+        }
+      }
+
+      if (doc_[p] !== void 0) {
+        continue;
+      }
+
+      if (isBeforeSetters != null) {
+        if (typeof type.defaultValue === 'function') {
+          if (!type.defaultValue.$runBeforeSetters && isBeforeSetters) {
+            continue;
+          }
+          if (type.defaultValue.$runBeforeSetters && !isBeforeSetters) {
+            continue;
+          }
+        } else if (!isBeforeSetters) {
+          // Non-function defaults should always run **before** setters
+          continue;
+        }
+      }
+
+      if (pathsToSkip && pathsToSkip[p]) {
+        continue;
+      }
+
+      if (fields && exclude !== null && !(exclude === true || included)) {
+        continue;
+      }
+
+      try {
+        def = type.getDefault(doc, false);
+      } catch (err) {
+        doc.invalidate(p, err);
+        continue;
+      }
+
+      if (typeof def !== 'undefined') {
+        doc_[p] = def;
+        applyChangeTracking(doc, p, skipParentChangeTracking);
+      }
+      continue;
+    }
+
     for (let j = 0; j < len; ++j) {
       if (doc_ == null) {
         break;
       }
 
       const piece = path[j];
-      curPath += (!curPath.length ? '' : '.') + piece;
+      curPath = curPath.length ? curPath + '.' + piece : piece;
 
       if (exclude === true) {
         if (curPath in fields) {
@@ -123,6 +185,8 @@ module.exports = function applyDefaults(doc, fields, exclude, hasIncludedChildre
       }
     }
   }
+
+  return hasPostSetterDefaults;
 };
 
 /*!

package/lib/helpers/model/castBulkWrite.js

@@ -127,7 +127,7 @@ module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne,
     applyTimestampsToUpdate(now, createdAt, updatedAt, update, {
       timestamps: updateOne.timestamps,
       overwriteImmutable: updateOne.overwriteImmutable
-    });
+    }, updateOne.upsert);
   }
 
   if (doInitTimestamps) {
@@ -194,7 +194,7 @@ module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMan
     applyTimestampsToUpdate(now, createdAt, updatedAt, updateMany['update'], {
       timestamps: updateMany.timestamps,
       overwriteImmutable: updateMany.overwriteImmutable
-    });
+    }, updateMany.upsert);
   }
   if (doInitTimestamps) {
     applyTimestampsToChildren(now, updateMany['update'], model.schema);

package/lib/helpers/parallelLimit.js

@@ -3,7 +3,9 @@
 module.exports = parallelLimit;
 
 /*!
- * ignore
+ * Run `fn` over every entry of `params` with at most `limit` calls in flight at
+ * a time, resolving to the results in input order. Currently only used by
+ * `Model.insertMany()` to bound how many documents validate concurrently.
  */
 
 async function parallelLimit(params, fn, limit) {
@@ -11,27 +13,50 @@ async function parallelLimit(params, fn, limit) {
     throw new Error('Limit must be positive');
   }
 
-  if (params.length === 0) {
+  const length = params.length;
+  if (length === 0) {
     return [];
   }
 
-  const results = [];
-  const executing = new Set();
-
-  for (let index = 0; index < params.length; index++) {
-    const param = params[index];
-    const p = fn(param, index);
-    results.push(p);
-
-    executing.add(p);
+  const results = new Array(length);
+  // Fast path: there's nothing to bound, so kick everything off and wait once.
+  // Avoids the per-task `Set` + `Promise.race` bookkeeping of a sliding window.
+  if (limit >= length) {
+    for (let i = 0; i < length; ++i) {
+      results[i] = fn(params[i], i);
+    }
+    return Promise.all(results);
+  }
 
-    const clean = () => executing.delete(p);
-    p.then(clean).catch(clean);
+  let nextIndex = 0;
+  let firstError = null;
 
-    if (executing.size >= limit) {
-      await Promise.race(executing);
+  function worker() {
+    if (nextIndex >= length || firstError !== null) {
+      return undefined;
     }
+    const index = nextIndex++;
+    return Promise.resolve(fn(params[index], index)).then(
+      (val) => {
+        results[index] = val;
+        return worker();
+      },
+      (err) => {
+        if (firstError === null) {
+          firstError = err;
+        }
+      }
+    );
   }
 
-  return Promise.all(results);
+  const workers = new Array(Math.min(limit, length));
+  for (let i = 0; i < workers.length; ++i) {
+    workers[i] = worker();
+  }
+  await Promise.all(workers);
+
+  if (firstError !== null) {
+    throw firstError;
+  }
+  return results;
 }

package/lib/helpers/schema/idGetter.js

@@ -26,6 +26,9 @@ module.exports = function addIdGetter(schema) {
  */
 
 function idGetter() {
+  if (this._doc) {
+    return this._doc._id?.toString() ?? null;
+  }
   if (this._id != null) {
     return this._id.toString();
   }

package/lib/helpers/timestamps/setupTimestamps.js

@@ -123,6 +123,7 @@ function _setTimestampsOnUpdate() {
     updatedAt,
     this.getUpdate(),
     this._mongooseOptions,
+    this.options.upsert,
     replaceOps.has(this.op)
   );
   applyTimestampsToChildren(now, this.getUpdate(), this.model.schema);

package/lib/helpers/update/applyTimestampsToUpdate.js

@@ -4,7 +4,6 @@
  * ignore
  */
 
-const get = require('../get');
 const utils = require('../../utils');
 
 module.exports = applyTimestampsToUpdate;
@@ -13,10 +12,10 @@ module.exports = applyTimestampsToUpdate;
  * ignore
  */
 
-function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, options, isReplace) {
+function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, options, upsert, isReplace) {
   const updates = currentUpdate;
   let _updates = updates;
-  const timestamps = get(options, 'timestamps', true);
+  const timestamps = options?.timestamps ?? true;
 
   // Support skipping timestamps at the query level, see gh-6980
   if (!timestamps || updates == null) {
@@ -81,7 +80,7 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
   }
 
   if (!skipCreatedAt && createdAt) {
-    const overwriteImmutable = get(options, 'overwriteImmutable', false);
+    const overwriteImmutable = options?.overwriteImmutable;
     const hasUserCreatedAt = currentUpdate[createdAt] != null
       || currentUpdate.$set?.[createdAt] != null
       || currentUpdate.$setOnInsert?.[createdAt] != null;
@@ -119,7 +118,7 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
         }
       }
 
-      if (!timestampSet) {
+      if (!timestampSet && upsert) {
         updates.$setOnInsert = updates.$setOnInsert || {};
         updates.$setOnInsert[createdAt] = now;
       }

package/lib/model.js

@@ -413,8 +413,9 @@ Model.prototype.$__save = async function $__save(options) {
     const saveOptions = _createSaveOptions(this, options);
 
     if (this.$isNew) {
+      const hasOnlyPrimitiveValues = this.$__hasOnlyPrimitiveValues();
       // send entire doc
-      const obj = this.$__hasOnlyPrimitiveValues() ?
+      const obj = hasOnlyPrimitiveValues ?
         this.$__toObjectShallow() :
         this.toObject(saveToObjectOptions);
       if ((obj || {})._id === void 0) {
@@ -428,11 +429,11 @@ Model.prototype.$__save = async function $__save(options) {
 
       this.$__version(true, obj);
       this.$__reset();
-      _setIsNew(this, false);
+      _setIsNew(this, false, hasOnlyPrimitiveValues);
       // Make it possible to retry the insert
       this.$__.inserting = true;
       result = await this[modelCollectionSymbol].insertOne(obj, saveOptions).catch(err => {
-        _setIsNew(this, true);
+        _setIsNew(this, true, hasOnlyPrimitiveValues);
         throw err;
       });
     } else {
@@ -3044,23 +3045,26 @@ Model.insertMany = async function insertMany(arr, options) {
 
 async function _insertMany(arr, options) {
   options = options || {};
-  const preFilter = buildMiddlewareFilter(options, 'pre');
-  const postFilter = buildMiddlewareFilter(options, 'post');
+  const hasInsertManyHooks = this._middleware.hasHooks('insertMany');
+  const preFilter = hasInsertManyHooks ? buildMiddlewareFilter(options, 'pre') : null;
+  const postFilter = hasInsertManyHooks ? buildMiddlewareFilter(options, 'post') : null;
 
-  try {
-    [arr] = await this._middleware.execPre('insertMany', this, [arr], { filter: preFilter });
-  } catch (error) {
-    await this._middleware.execPost('insertMany', this, [arr], { error, filter: postFilter });
+  if (hasInsertManyHooks) {
+    try {
+      [arr] = await this._middleware.execPre('insertMany', this, [arr], { filter: preFilter });
+    } catch (error) {
+      await this._middleware.execPost('insertMany', this, [arr], { error, filter: postFilter });
+    }
   }
   const ThisModel = this;
   const limit = options.limit || 1000;
   const rawResult = !!options.rawResult;
-  const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
-  const throwOnValidationError = typeof options.throwOnValidationError === 'boolean' ? options.throwOnValidationError : false;
+  const ordered = options.ordered == null ? true : !!options.ordered;
+  const throwOnValidationError = !!options.throwOnValidationError;
   const lean = !!options.lean;
 
   const asyncLocalStorage = this.db.base.transactionAsyncLocalStorage?.getStore();
-  if ((!options || !Object.hasOwn(options, 'session')) && asyncLocalStorage?.session != null) {
+  if (!Object.hasOwn(options, 'session') && asyncLocalStorage?.session != null) {
     options = { ...options, session: asyncLocalStorage.session };
   }
 
@@ -3069,9 +3073,9 @@ async function _insertMany(arr, options) {
   }
 
   const validationErrors = [];
-  const validationErrorsToOriginalOrder = new Map();
   const results = ordered ? null : new Array(arr.length);
-  async function validateDoc(doc, index) {
+  const session = options.session;
+  function validateDoc(doc, index) {
     // If option `lean` is set to true bypass validation and hydration
     if (lean) {
       return doc;
@@ -3079,14 +3083,14 @@ async function _insertMany(arr, options) {
     let createdNewDoc = false;
     if (!(doc instanceof ThisModel)) {
       if (doc != null && typeof doc !== 'object') {
-        throw new ObjectParameterError(doc, 'arr.' + index, 'insertMany');
+        return Promise.reject(new ObjectParameterError(doc, 'arr.' + index, 'insertMany'));
       }
       doc = new ThisModel(doc);
       createdNewDoc = true;
     }
 
-    if (options.session != null) {
-      doc.$session(options.session);
+    if (session != null) {
+      doc.$session(session);
     }
     return doc.$validate(createdNewDoc ? { _skipParallelValidateCheck: true } : null)
       .then(() => doc)
@@ -3094,7 +3098,6 @@ async function _insertMany(arr, options) {
         if (ordered === false) {
           error.index = index;
           validationErrors.push(error);
-          validationErrorsToOriginalOrder.set(error, index);
           results[index] = error;
           return;
         }
@@ -3104,27 +3107,42 @@ async function _insertMany(arr, options) {
 
   const docs = await parallelLimit(arr, validateDoc, limit);
 
-  const originalDocIndex = new Map();
-  const validDocIndexToOriginalIndex = new Map();
+  const validDocIndexToOriginalIndex = {};
+  const docAttributes = [];
+  const docObjects = lean ? docAttributes : [];
+  const versionKeyPath = ThisModel.schema.options.versionKey
+    ? ThisModel.schema.paths[ThisModel.schema.options.versionKey]?.splitPath()
+    : null;
+  const timestamps = options.timestamps;
   for (let i = 0; i < docs.length; ++i) {
-    originalDocIndex.set(docs[i], i);
-  }
+    const doc = docs[i];
+    if (doc == null) {
+      continue;
+    }
+    validDocIndexToOriginalIndex[docAttributes.length] = i;
+    docAttributes.push(doc);
 
-  // We filter all failed pre-validations by removing nulls
-  const docAttributes = docs.filter(function(doc) {
-    return doc != null;
-  });
-  for (let i = 0; i < docAttributes.length; ++i) {
-    validDocIndexToOriginalIndex.set(i, originalDocIndex.get(docAttributes[i]));
+    // In lean mode `docObjects === docAttributes`, so the push above is enough.
+    if (lean) {
+      continue;
+    }
+    if (versionKeyPath) {
+      doc.$__setValue(versionKeyPath, 0);
+    }
+    const shouldSetTimestamps = timestamps !== false && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
+    if (shouldSetTimestamps) {
+      doc.initializeTimestamps(timestamps);
+    }
+    docObjects.push(doc.$__hasOnlyPrimitiveValues() ? doc.$__toObjectShallow() : doc.toObject(internalToObjectOptions));
   }
 
   // Make sure validation errors are in the same order as the
   // original documents, so if both doc1 and doc2 both fail validation,
   // `Model.insertMany([doc1, doc2])` will always have doc1's validation
   // error before doc2's. Re: gh-12791.
-  if (validationErrors.length > 0) {
+  if (validationErrors.length > 0 && ordered === false) {
     validationErrors.sort((err1, err2) => {
-      return validationErrorsToOriginalOrder.get(err1) - validationErrorsToOriginalOrder.get(err2);
+      return err1.index - err2.index;
     });
   }
 
@@ -3149,19 +3167,6 @@ async function _insertMany(arr, options) {
     }
     return [];
   }
-  const docObjects = lean ? docAttributes : docAttributes.map(function(doc) {
-    if (doc.$__schema.options.versionKey) {
-      doc[doc.$__schema.options.versionKey] = 0;
-    }
-    const shouldSetTimestamps = options?.timestamps !== false && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
-    if (shouldSetTimestamps) {
-      doc.initializeTimestamps(options?.timestamps);
-    }
-    if (doc.$__hasOnlyPrimitiveValues()) {
-      return doc.$__toObjectShallow();
-    }
-    return doc.toObject(internalToObjectOptions);
-  });
 
   let res;
   try {
@@ -3180,7 +3185,7 @@ async function _insertMany(arr, options) {
 
     if (error.writeErrors != null) {
       for (let i = 0; i < error.writeErrors.length; ++i) {
-        const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
+        const originalIndex = validDocIndexToOriginalIndex[error.writeErrors[i].index];
         error.writeErrors[i] = { ...error.writeErrors[i], index: originalIndex };
         if (!ordered) {
           results[originalIndex] = error.writeErrors[i];
@@ -3219,7 +3224,7 @@ async function _insertMany(arr, options) {
         if (lean) {
           return doc;
         }
-        doc.$__reset();
+        doc.$__reset(true);
         _setIsNew(doc, false);
         return doc;
       });
@@ -3228,13 +3233,18 @@ async function _insertMany(arr, options) {
       decorateBulkWriteResult(error, validationErrors, results);
     }
 
-    await this._middleware.execPost('insertMany', this, [arr], { error, filter: postFilter });
+    if (hasInsertManyHooks) {
+      await this._middleware.execPost('insertMany', this, [arr], { error, filter: postFilter });
+    } else {
+      throw error;
+    }
   }
 
   if (!lean) {
     for (const attribute of docAttributes) {
-      attribute.$__reset();
-      _setIsNew(attribute, false);
+      const hasOnlyPrimitiveValues = attribute.$__hasOnlyPrimitiveValues();
+      attribute.$__reset(true, hasOnlyPrimitiveValues);
+      _setIsNew(attribute, false, hasOnlyPrimitiveValues);
     }
   }
 
@@ -3276,19 +3286,28 @@ async function _insertMany(arr, options) {
     });
   }
 
-  const [result] = await this._middleware.execPost('insertMany', this, [docAttributes], { filter: postFilter });
-  return result;
+  if (hasInsertManyHooks) {
+    const [result] = await this._middleware.execPost('insertMany', this, [docAttributes], { filter: postFilter });
+    return result;
+  }
+  return docAttributes;
 }
 
 /*!
- * ignore
+ * @param {Document} doc The document to set `$isNew` on.
+ * @param {boolean} val The value to set `$isNew` to.
+ * @param {boolean} [hasOnlyPrimitiveValues] Skip getting subdocs for performance if we know there are none.
+ * @api private
  */
 
-function _setIsNew(doc, val) {
+function _setIsNew(doc, val, hasOnlyPrimitiveValues) {
   doc.$isNew = val;
   doc.$emit('isNew', val);
   doc.constructor.emit('isNew', val);
 
+  if (hasOnlyPrimitiveValues) {
+    return;
+  }
   const subdocs = doc.$getAllSubdocs({ useCache: true });
   for (const subdoc of subdocs) {
     subdoc.$isNew = val;

package/lib/schema.js

@@ -727,7 +727,7 @@ Schema.prototype._getDocumentMiddleware = function _getDocumentMiddleware() {
 
 Schema.prototype._defaultToObjectOptions = function(json) {
   const path = json ? 'toJSON' : 'toObject';
-  if (this._defaultToObjectOptionsMap && this._defaultToObjectOptionsMap[path]) {
+  if (this._defaultToObjectOptionsMap && path in this._defaultToObjectOptionsMap) {
     return this._defaultToObjectOptionsMap[path];
   }
 
@@ -738,7 +738,7 @@ Schema.prototype._defaultToObjectOptions = function(json) {
   const defaultOptions = Object.assign({}, baseOptions, schemaOptions);
 
   this._defaultToObjectOptionsMap = this._defaultToObjectOptionsMap || {};
-  this._defaultToObjectOptionsMap[path] = defaultOptions;
+  this._defaultToObjectOptionsMap[path] = utils.hasOwnKeys(defaultOptions) ? defaultOptions : null;
   return defaultOptions;
 };
 
@@ -1870,6 +1870,46 @@ Schema.prototype.requiredPaths = function requiredPaths(invalidate) {
   return this._requiredpaths;
 };
 
+/**
+ * Returns an Array of path strings that have a `transform` option, either on the
+ * path itself or on the path's `embeddedSchemaType` for arrays.
+ *
+ * #### Example:
+ *
+ *     const s = new Schema({
+ *       name: { type: String, transform: v => v.toLowerCase() },
+ *       tags: [{ type: String, transform: v => v.trim() }],
+ *       age: { type: Number, required: true },
+ *       notes: String
+ *     });
+ *     s.pathsWithTransforms(); // [ 'name', 'tags' ]
+ *
+ * @api private
+ * @param {boolean} invalidate Refresh the cache
+ * @return {Array|null}
+ */
+
+Schema.prototype.pathsWithTransforms = function pathsWithTransforms(invalidate) {
+  if (this._pathsWithTransforms !== undefined && !invalidate) {
+    return this._pathsWithTransforms;
+  }
+
+  const paths = Object.keys(this.paths);
+  const ret = [];
+
+  for (const path of paths) {
+    const schematype = this.paths[path];
+    const topLevelTransformFunction = schematype.options.transform ?? schematype.constructor?.defaultOptions?.transform;
+    const embeddedSchemaTypeTransformFunction = schematype.embeddedSchemaType?.options?.transform
+      ?? schematype.embeddedSchemaType?.constructor?.defaultOptions?.transform;
+    if (topLevelTransformFunction || embeddedSchemaTypeTransformFunction) {
+      ret.push(path);
+    }
+  }
+  this._pathsWithTransforms = ret.length ? ret : null;
+  return this._pathsWithTransforms;
+};
+
 /**
  * Returns indexes from fields and schema-level indexes (cached).
  *
@@ -3097,6 +3137,8 @@ function isArrayFilter(piece) {
 Schema.prototype._preCompile = function _preCompile() {
   this.plugin(idGetter, { deduplicate: true });
   _precomputeOptimisticConcurrency(this);
+  // Cache paths that have transforms
+  this.pathsWithTransforms();
 };
 
 /*!

package/lib/schemaType.js

@@ -1158,7 +1158,7 @@ SchemaType.prototype.required = function(required, message) {
       return true;
     }
 
-    // `$cachedRequired` gets set in `_evaluateRequiredFunctions()` so we
+    // `$cachedRequired` gets set in `_getPathsToValidate()` so we
     // don't call required functions multiple times in one validate call
     // See gh-6801
     if (cachedRequired != null && _this.path in cachedRequired) {
@@ -1292,7 +1292,8 @@ SchemaType.prototype.getDefault = function getDefault(parentDoc, init, options)
     if (
       this.defaultValue === Date.now ||
       this.defaultValue === Array ||
-      this.defaultValue.name.toLowerCase() === 'objectid'
+      this.defaultValue.name === 'ObjectId' ||
+      this.defaultValue.name === 'ObjectID'
     ) {
       ret = this.defaultValue.call(context);
     } else {
@@ -1303,7 +1304,7 @@ SchemaType.prototype.getDefault = function getDefault(parentDoc, init, options)
   }
 
   if (ret != null) {
-    if (typeof ret === 'object' && !this.options?.shared) {
+    if (typeof ret === 'object' && ret != null && ret._bsontype !== 'ObjectId' && !this.options?.shared) {
       ret = clone(ret);
     }
 

package/lib/stateMachine.js

@@ -34,7 +34,6 @@ StateMachine.ctor = function() {
   const states = [...arguments];
 
   const ctor = function() {
-    StateMachine.apply(this, arguments);
     this.paths = {};
     this.states = {};
   };
@@ -79,6 +78,28 @@ StateMachine.prototype._changeState = function _changeState(path, nextState) {
   this.states[nextState][path] = true;
 };
 
+/*!
+ * ignore
+ */
+
+StateMachine.prototype.clearAllExcept = function clearAllExcept(state) {
+  // State buckets are created lazily, so `states[state]` may not exist yet.
+  const bucket = this.states[state];
+  const keys = bucket == null ? [] : Object.keys(bucket);
+  if (keys.length === 0) {
+    this.paths = {};
+    this.states = {};
+    return;
+  }
+  this.paths = {};
+  for (const path of keys) {
+    this.paths[path] = state;
+  }
+  this.states = {
+    [state]: this.states[state]
+  };
+};
+
 /*!
  * ignore
  */
@@ -91,8 +112,6 @@ StateMachine.prototype.clear = function clear(state) {
   if (keys.length === 0) {
     return;
   }
-  // Replace the bucket rather than deleting each key: repeated `delete` puts
-  // the object in dictionary mode, which is significantly slower.
   this.states[state] = {};
   let i = keys.length;