mongoose 6.7.1 → 6.7.3

package/lib/document.js

@@ -220,6 +220,17 @@ function Document(obj, fields, skipId, options) {
  *     const user = await User.findOne({ name: 'John Smith' });
  *     user.$isNew; // false
  *
+ * Mongoose sets `$isNew` to `false` immediately after `save()` succeeds.
+ * That means Mongoose sets `$isNew` to false **before** `post('save')` hooks run.
+ * In `post('save')` hooks, `$isNew` will be `false` if `save()` succeeded.
+ *
+ * #### Example:
+ *
+ *     userSchema.post('save', function() {
+ *       this.$isNew; // false
+ *     });
+ *     await User.create({ name: 'John Smith' });
+ *
  * For subdocuments, `$isNew` is true if either the parent has `$isNew` set,
  * or if you create a new subdocument.
  *
@@ -1468,13 +1479,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       const doc = this.$isSubdocument ? this.ownerDocument() : this;
       savedState = doc.$__.savedState;
       savedStatePath = this.$isSubdocument ? this.$__.fullPath + '.' + path : path;
-      if (savedState != null) {
-        const firstDot = savedStatePath.indexOf('.');
-        const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
-        if (!savedState.hasOwnProperty(topLevelPath)) {
-          savedState[topLevelPath] = utils.clone(doc.$__getValue(topLevelPath));
-        }
-      }
+      doc.$__saveInitialState(savedStatePath);
     }
 
     this.$__set(pathToMark, path, options, constructing, parts, schema, val, priorVal);
@@ -1583,6 +1588,10 @@ Document.prototype.$__shouldModify = function(pathToMark, path, options, constru
   if (this.$isNew) {
     return true;
   }
+  // Is path already modified? If so, always modify. We may unmark modified later.
+  if (path in this.$__.activePaths.getStatePaths('modify')) {
+    return true;
+  }
 
   // Re: the note about gh-7196, `val` is the raw value without casting or
   // setters if the full path is under a single nested subdoc because we don't
@@ -1780,11 +1789,10 @@ Document.prototype.$inc = function $inc(path, val) {
 
   const currentValue = this.$__getValue(path) || 0;
 
-  this.$__setValue(path, currentValue + val);
-
   this.$__.primitiveAtomics = this.$__.primitiveAtomics || {};
   this.$__.primitiveAtomics[path] = { $inc: val };
   this.markModified(path);
+  this.$__setValue(path, currentValue + val);
 
   return this;
 };
@@ -1927,6 +1935,8 @@ Document.prototype.$__path = function(path) {
  */
 
 Document.prototype.markModified = function(path, scope) {
+  this.$__saveInitialState(path);
+
   this.$__.activePaths.modify(path);
   if (scope != null && !this.$isSubdocument) {
     this.$__.pathsToScopes = this.$__pathsToScopes || {};
@@ -1934,6 +1944,22 @@ Document.prototype.markModified = function(path, scope) {
   }
 };
 
+/*!
+ * ignore
+ */
+
+Document.prototype.$__saveInitialState = function $__saveInitialState(path) {
+  const savedState = this.$__.savedState;
+  const savedStatePath = path;
+  if (savedState != null) {
+    const firstDot = savedStatePath.indexOf('.');
+    const topLevelPath = firstDot === -1 ? savedStatePath : savedStatePath.slice(0, firstDot);
+    if (!savedState.hasOwnProperty(topLevelPath)) {
+      savedState[topLevelPath] = utils.clone(this.$__getValue(topLevelPath));
+    }
+  }
+};
+
 /**
  * Clears the modified state on the specified path.
  *
@@ -3379,6 +3405,7 @@ Document.prototype.$__dirty = function() {
       schema: _this.$__path(path)
     };
   });
+
   // gh-2558: if we had to set a default and the value is not undefined,
   // we have to save as well
   all = all.concat(this.$__.activePaths.map('default', function(path) {

package/lib/helpers/model/discriminator.js

@@ -184,8 +184,9 @@ module.exports = function discriminator(model, name, schema, tiedValue, applyPlu
     if (mergeHooks) {
       schema.s.hooks = model.schema.s.hooks.merge(schema.s.hooks);
     }
-
-    schema.plugins = Array.prototype.slice.call(baseSchema.plugins);
+    if (applyPlugins) {
+      schema.plugins = Array.prototype.slice.call(baseSchema.plugins);
+    }
     schema.callQueue = baseSchema.callQueue.concat(schema.callQueue);
     delete schema._requiredpaths; // reset just in case Schema#requiredPaths() was called on either schema
   }

package/lib/helpers/timestamps/setupTimestamps.js

@@ -28,7 +28,7 @@ module.exports = function setupTimestamps(schema, timestamps) {
   schema.$timestamps = { createdAt: createdAt, updatedAt: updatedAt };
 
   if (createdAt && !schema.paths[createdAt]) {
-    const baseImmutableCreatedAt = schema.base.get('timestamps.createdAt.immutable');
+    const baseImmutableCreatedAt = schema.base != null ? schema.base.get('timestamps.createdAt.immutable') : null;
     const immutable = baseImmutableCreatedAt != null ? baseImmutableCreatedAt : true;
     schemaAdditions[createdAt] = { [schema.options.typeKey || 'type']: Date, immutable };
   }

package/lib/index.js

@@ -205,7 +205,6 @@ Mongoose.prototype.setDriver = function setDriver(driver) {
  * - 'returnOriginal': If `false`, changes the default `returnOriginal` option to `findOneAndUpdate()`, `findByIdAndUpdate`, and `findOneAndReplace()` to false. This is equivalent to setting the `new` option to `true` for `findOneAndX()` calls by default. Read our [`findOneAndUpdate()` tutorial](/docs/tutorials/findoneandupdate.html) for more information.
  * - 'bufferCommands': enable/disable mongoose's buffering mechanism for all connections and models
  * - 'cloneSchemas': `false` by default. Set to `true` to `clone()` all schemas before compiling into a model.
- * - 'debug': If `true`, prints the operations mongoose sends to MongoDB to the console. If a writable stream is passed, it will log to that stream, without colorization. If a callback function is passed, it will receive the collection name, the method name, then all arugments passed to the method. For example, if you wanted to replicate the default logging, you could output from the callback `Mongoose: ${collectionName}.${methodName}(${methodArgs.join(', ')})`.
  * - 'timestamps.createdAt.immutable': `true` by default. If `false`, it will change the `createdAt` field to be [`immutable: false`](https://mongoosejs.com/docs/api/schematype.html#schematype_SchemaType-immutable) which means you can update the `createdAt`
  * - 'maxTimeMS': If set, attaches [maxTimeMS](https://docs.mongodb.com/manual/reference/operator/meta/maxTimeMS/) to every query
  * - 'objectIdGetter': `true` by default. Mongoose adds a getter to MongoDB ObjectId's called `_id` that returns `this` for convenience with populate. Set this to false to remove the getter.

package/lib/model.js

@@ -1215,6 +1215,7 @@ Model.exists = function exists(filter, options, callback) {
  * @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
  * @param {Boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
  * @param {Boolean} [options.mergeHooks=true] By default, Mongoose merges the base schema's hooks with the discriminator schema's hooks. Set this option to `false` to make Mongoose use the discriminator schema's hooks instead.
+ * @param {Boolean} [options.mergePlugins=true] By default, Mongoose merges the base schema's plugins with the discriminator schema's plugins. Set this option to `false` to make Mongoose use the discriminator schema's plugins instead.
  * @return {Model} The newly created discriminator model
  * @api public
  */
@@ -1232,6 +1233,7 @@ Model.discriminator = function(name, schema, options) {
   options = options || {};
   const value = utils.isPOJO(options) ? options.value : options;
   const clone = typeof options.clone === 'boolean' ? options.clone : true;
+  const mergePlugins = typeof options.mergePlugins === 'boolean' ? options.mergePlugins : true;
 
   _checkContext(this, 'discriminator');
 
@@ -1242,7 +1244,7 @@ Model.discriminator = function(name, schema, options) {
     schema = schema.clone();
   }
 
-  schema = discriminator(this, name, schema, value, true, options.mergeHooks);
+  schema = discriminator(this, name, schema, value, mergePlugins, options.mergeHooks);
   if (this.db.models[name] && !schema.options.overwriteModels) {
     throw new OverwriteModelError(name);
   }
@@ -4554,7 +4556,7 @@ Model.validate = function validate(obj, pathsToValidate, context, callback) {
  * - match: optional query conditions to match
  * - model: optional name of the model to use for population
  * - options: optional query options like sort, limit, etc
- * - justOne: optional boolean, if true Mongoose will always set `path` to an array. Inferred from schema by default.
+ * - justOne: optional boolean, if true Mongoose will always set `path` to a document, or `null` if no document was found. If false, Mongoose will always set `path` to an array, which will be empty if no documents are found. Inferred from schema by default.
  * - strictPopulate: optional boolean, set to `false` to allow populating paths that aren't in the schema.
  *
  * #### Example:

package/lib/query.js

@@ -4574,8 +4574,11 @@ Query.prototype.updateMany = function(conditions, doc, options, callback) {
  * #### Example:
  *
  *     const res = await Person.updateOne({ name: 'Jean-Luc Picard' }, { ship: 'USS Enterprise' });
- *     res.n; // Number of documents matched
- *     res.nModified; // Number of documents modified
+ *     res.acknowledged; // Indicates if this write result was acknowledged. If not, then all other members of this result will be undefined.
+ *     res.matchedCount; // Number of documents that matched the filter
+ *     res.modifiedCount; // Number of documents that were modified
+ *     res.upsertedCount; // Number of documents that were upserted
+ *     res.upsertedId; // Identifier of the inserted document (if an upsert took place)
  *
  * This function triggers the following middleware.
  *
@@ -4638,8 +4641,11 @@ Query.prototype.updateOne = function(conditions, doc, options, callback) {
  * #### Example:
  *
  *     const res = await Person.replaceOne({ _id: 24601 }, { name: 'Jean Valjean' });
- *     res.n; // Number of documents matched
- *     res.nModified; // Number of documents modified
+ *     res.acknowledged; // Indicates if this write result was acknowledged. If not, then all other members of this result will be undefined.
+ *     res.matchedCount; // Number of documents that matched the filter
+ *     res.modifiedCount; // Number of documents that were modified
+ *     res.upsertedCount; // Number of documents that were upserted
+ *     res.upsertedId; // Identifier of the inserted document (if an upsert took place)
  *
  * This function triggers the following middleware.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongoose",
   "description": "Mongoose MongoDB ODM",
-  "version": "6.7.1",
+  "version": "6.7.3",
   "author": "Guillermo Rauch <guillermo@learnboost.com>",
   "keywords": [
     "mongodb",

package/types/document.d.ts

@@ -190,9 +190,6 @@ declare module 'mongoose' {
     /** Returns the list of paths that have been modified. */
     modifiedPaths(options?: { includeChildren?: boolean }): Array<string>;
 
-    /** The name of the model */
-    modelName: string;
-
     /**
      * Overwrite all values in this document with the values of `obj`, except
      * for immutable properties. Behaves similarly to `set()`, except for it

package/types/index.d.ts

@@ -258,8 +258,8 @@ declare module 'mongoose' {
     obj: SchemaDefinition<SchemaDefinitionType<EnforcedDocType>>;
 
     /** Gets/sets schema paths. */
+    path<ResultType extends SchemaType = SchemaType<any, HydratedDocument<DocType, TInstanceMethods>>>(path: string): ResultType;
     path<pathGeneric extends keyof EnforcedDocType>(path: pathGeneric): SchemaType<EnforcedDocType[pathGeneric]>;
-    path<ResultType extends SchemaType = SchemaType>(path: string): ResultType;
     path(path: string, constructor: any): this;
 
     /** Lists all paths and their type in the schema. */
@@ -274,19 +274,19 @@ declare module 'mongoose' {
     plugin<PFunc extends PluginFunction<DocType, M, any, any, any, any>, POptions extends Parameters<PFunc>[1] = Parameters<PFunc>[1]>(fn: PFunc, opts?: POptions): this;
 
     /** Defines a post hook for the model. */
-    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T, T>): this;
-    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
     post<T = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | RegExp, fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
     post<T = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, QueryResultType<T>>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PostMiddlewareFunction<T, T>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PostMiddlewareFunction<T, Array<AggregateExtract<T>>>): this;
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, Array<AggregateExtract<T>>>): this;
     post<T = M>(method: 'insertMany' | RegExp, fn: PostMiddlewareFunction<T, T>): this;
     post<T = M>(method: 'insertMany' | RegExp, options: SchemaPostOptions, fn: PostMiddlewareFunction<T, T>): this;
 
-    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
-    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
     post<T = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
     post<T = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
+    post<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T>): this;
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
     post<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPostOptions, fn: ErrorHandlingMiddlewareFunction<T, Array<any>>): this;
     post<T = M>(method: 'insertMany' | RegExp, fn: ErrorHandlingMiddlewareFunction<T>): this;
@@ -295,10 +295,10 @@ declare module 'mongoose' {
     /** Defines a pre hook for the model. */
     pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: 'save', fn: PreSaveMiddlewareFunction<T>): this;
     pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: 'save', options: SchemaPreOptions, fn: PreSaveMiddlewareFunction<T>): this;
-    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
-    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
     pre<T = Query<any, any>>(method: MongooseQueryMiddleware | MongooseQueryMiddleware[] | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
+    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, fn: PreMiddlewareFunction<T>): this;
+    pre<T = HydratedDocument<DocType, TInstanceMethods>>(method: MongooseDocumentMiddleware | MongooseDocumentMiddleware[] | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, fn: PreMiddlewareFunction<T>): this;
     pre<T extends Aggregate<any>>(method: 'aggregate' | RegExp, options: SchemaPreOptions, fn: PreMiddlewareFunction<T>): this;
     pre<T = M>(method: 'insertMany' | RegExp, fn: (this: T, next: (err?: CallbackError) => void, docs: any | Array<any>) => void | Promise<void>): this;
@@ -551,7 +551,6 @@ declare module 'mongoose' {
   export type SchemaDefinitionType<T> = T extends Document ? Omit<T, Exclude<keyof Document, '_id' | 'id' | '__v'>> : T;
 
   // Helpers to simplify checks
-  type IfAny<IFTYPE, THENTYPE, ELSETYPE = IFTYPE> = 0 extends (1 & IFTYPE) ? THENTYPE : ELSETYPE;
   type IfUnknown<IFTYPE, THENTYPE> = unknown extends IFTYPE ? THENTYPE : IFTYPE;
 
   // tests for these two types are located in test/types/lean.test.ts

package/types/inferschematype.d.ts

@@ -38,7 +38,7 @@ declare module 'mongoose' {
    * // result
    * type UserType = {userName?: string}
    */
-  type InferSchemaType<TSchema> = ObtainSchemaGeneric<TSchema, 'DocType'>;
+  type InferSchemaType<TSchema> = IfAny<TSchema, any, ObtainSchemaGeneric<TSchema, 'DocType'>>;
 
   /**
    * @summary Obtains schema Generic type by using generic alias.
@@ -177,11 +177,13 @@ type ResolvePathType<PathValueType, Options extends SchemaTypeOptions<PathValueT
                                 PathValueType extends 'decimal128' | 'Decimal128' | typeof Schema.Types.Decimal128 ? Types.Decimal128 :
                                   IfEquals<PathValueType, Schema.Types.Decimal128> extends true ? Types.Decimal128 :
                                     IfEquals<PathValueType, Types.Decimal128> extends true ? Types.Decimal128 :
-                                      PathValueType extends MapConstructor ? Map<string, ResolvePathType<Options['of']>> :
-                                        PathValueType extends ArrayConstructor ? any[] :
-                                          PathValueType extends typeof Schema.Types.Mixed ? any:
-                                            IfEquals<PathValueType, ObjectConstructor> extends true ? any:
-                                              IfEquals<PathValueType, {}> extends true ? any:
-                                                PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
-                                                  PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, TypeKey> :
-                                                    unknown;
+                                      PathValueType extends 'uuid' | 'UUID' | typeof Schema.Types.UUID ? Buffer :
+                                        IfEquals<PathValueType, Schema.Types.UUID> extends true ? Buffer :
+                                          PathValueType extends MapConstructor ? Map<string, ResolvePathType<Options['of']>> :
+                                            PathValueType extends ArrayConstructor ? any[] :
+                                              PathValueType extends typeof Schema.Types.Mixed ? any:
+                                                IfEquals<PathValueType, ObjectConstructor> extends true ? any:
+                                                  IfEquals<PathValueType, {}> extends true ? any:
+                                                    PathValueType extends typeof SchemaType ? PathValueType['prototype'] :
+                                                      PathValueType extends Record<string, any> ? ObtainDocumentType<PathValueType, any, TypeKey> :
+                                                        unknown;

package/types/models.d.ts

@@ -6,6 +6,7 @@ declare module 'mongoose' {
     clone?: boolean;
     overwriteModels?: boolean;
     mergeHooks?: boolean;
+    mergePlugins?: boolean;
   }
 
   export interface AcceptsDiscriminator {

package/types/pipelinestage.d.ts

@@ -213,7 +213,7 @@ declare module 'mongoose' {
 
     export interface ReplaceWith {
       /** [`$replaceWith` reference](https://docs.mongodb.com/manual/reference/operator/aggregation/replaceWith/) */
-      $replaceWith: ObjectExpressionOperator | { [field: string]: Expression };
+      $replaceWith: ObjectExpressionOperator | { [field: string]: Expression } | `$${string}`;
     }
 
     export interface Sample {

package/types/populate.d.ts

@@ -26,8 +26,9 @@ declare module 'mongoose' {
      /** deep populate */
      populate?: string | PopulateOptions | (string | PopulateOptions)[];
      /**
-     * If true Mongoose will always set `path` to an array, if false Mongoose will
-     * always set `path` to a document. Inferred from schema by default.
+     * If true Mongoose will always set `path` to a document, or `null` if no document was found.
+     * If false Mongoose will always set `path` to an array, which will be empty if no documents are found.
+     * Inferred from schema by default.
      */
      justOne?: boolean;
      /** transform function to call on every populated doc */

package/types/schematypes.d.ts

@@ -100,7 +100,7 @@ declare module 'mongoose' {
      * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose will
      * build an index on this path when the model is compiled.
      */
-    index?: boolean | IndexDirection;
+    index?: boolean | IndexDirection | IndexOptions;
 
     /**
      * If [truthy](https://masteringjs.io/tutorials/fundamentals/truthy), Mongoose
@@ -188,7 +188,11 @@ declare module 'mongoose' {
     [other: string]: any;
   }
 
-  class SchemaType<T = any> {
+  interface Validator {
+    message?: string; type?: string; validator?: Function
+  }
+
+  class SchemaType<T = any, DocType = any> {
     /** SchemaType constructor */
     constructor(path: string, options?: AnyObject, instance?: string);
 
@@ -270,10 +274,10 @@ declare module 'mongoose' {
     unique(bool: boolean): this;
 
     /** The validators that Mongoose should run to validate properties at this SchemaType's path. */
-    validators: { message?: string; type?: string; validator?: Function }[];
+    validators: Validator[];
 
     /** Adds validator(s) for this document path. */
-    validate(obj: RegExp | Function | any, errorMsg?: string, type?: string): this;
+    validate(obj: RegExp | ((this: DocType, value: any, validatorProperties?: Validator) => any), errorMsg?: string, type?: string): this;
   }
 
   namespace Schema {
@@ -422,6 +426,11 @@ declare module 'mongoose' {
         /** Adds an uppercase [setter](http://mongoosejs.com/docs/api.html#schematype_SchemaType-set). */
         uppercase(shouldApply?: boolean): this;
       }
+
+      class UUID extends SchemaType {
+        /** This schema type's name, to defend against minifiers that mangle function names. */
+        static schemaName: 'UUID';
+      }
     }
   }
 }

package/types/utility.d.ts

@@ -1,4 +1,5 @@
 declare module 'mongoose' {
+  type IfAny<IFTYPE, THENTYPE, ELSETYPE = IFTYPE> = 0 extends (1 & IFTYPE) ? THENTYPE : ELSETYPE;
 
   type Unpacked<T> = T extends (infer U)[] ?
     U :