mongoose 6.1.8 → 6.2.1

package/lib/aggregate.js

@@ -39,7 +39,7 @@ const readConcern = Query.prototype.readConcern;
  * ```javascript
  *   new Aggregate([{ $match: { _id: '00000000000000000000000a' } }]);
  *   // Do this instead to cast to an ObjectId
- *   new Aggregate([{ $match: { _id: mongoose.Types.ObjectId('00000000000000000000000a') } }]);
+ *   new Aggregate([{ $match: { _id: new mongoose.Types.ObjectId('00000000000000000000000a') } }]);
  * ```
  *
  * @see MongoDB http://docs.mongodb.org/manual/applications/aggregation/

package/lib/cast/objectid.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const ObjectId = require('../driver').get().ObjectId;
-const assert = require('assert');
 
 module.exports = function castObjectId(value) {
   if (value == null) {
@@ -25,5 +24,5 @@ module.exports = function castObjectId(value) {
     return new ObjectId(value.toString());
   }
 
-  assert.ok(false);
+  return new ObjectId(value);
 };

package/lib/cast.js

@@ -7,6 +7,7 @@
 const CastError = require('./error/cast');
 const StrictModeError = require('./error/strict');
 const Types = require('./schema/index');
+const cast$expr = require('./helpers/query/cast$expr');
 const castTextSearch = require('./schema/operators/text');
 const get = require('./helpers/get');
 const getConstructorName = require('./helpers/getConstructorName');
@@ -79,9 +80,7 @@ module.exports = function cast(schema, obj, options, context) {
 
       continue;
     } else if (path === '$expr') {
-      if (typeof val !== 'object' || val == null) {
-        throw new Error('`$expr` must be an object');
-      }
+      val = cast$expr(val, schema);
       continue;
     } else if (path === '$elemMatch') {
       val = cast(schema, val, options, context);
@@ -145,7 +144,13 @@ module.exports = function cast(schema, obj, options, context) {
             remainingConds = {};
             pathLastHalf = split.slice(j).join('.');
             remainingConds[pathLastHalf] = val;
-            obj[path] = cast(schematype.caster.schema, remainingConds, options, context)[pathLastHalf];
+
+            const ret = cast(schematype.caster.schema, remainingConds, options, context)[pathLastHalf];
+            if (ret === void 0) {
+              delete obj[path];
+            } else {
+              obj[path] = ret;
+            }
           } else {
             obj[path] = val;
           }
@@ -251,16 +256,24 @@ module.exports = function cast(schema, obj, options, context) {
         if (schema.nested[path]) {
           continue;
         }
-        if (options.upsert && options.strict) {
-          if (options.strict === 'throw') {
+
+        const strict = 'strict' in options ? options.strict : schema.options.strict;
+        const strictQuery = 'strictQuery' in options ?
+          options.strictQuery :
+          'strict' in options ?
+            options.strict :
+            'strict' in schema._userProvidedOptions ? schema._userProvidedOptions.strict :
+              schema.options.strictQuery;
+        if (options.upsert && strict) {
+          if (strict === 'throw') {
             throw new StrictModeError(path);
           }
           throw new StrictModeError(path, 'Path "' + path + '" is not in ' +
             'schema, strict mode is `true`, and upsert is `true`.');
-        } if (options.strictQuery === 'throw') {
+        } if (strictQuery === 'throw') {
           throw new StrictModeError(path, 'Path "' + path + '" is not in ' +
             'schema and strictQuery is \'throw\'.');
-        } else if (options.strictQuery) {
+        } else if (strictQuery) {
           delete obj[path];
         }
       } else if (val == null) {

package/lib/connection.js

@@ -10,6 +10,7 @@ const Schema = require('./schema');
 const Collection = require('./driver').get().Collection;
 const STATES = require('./connectionstate');
 const MongooseError = require('./error/index');
+const SyncIndexesError = require('./error/syncIndexes');
 const PromiseProvider = require('./promise_provider');
 const ServerSelectionError = require('./error/serverSelection');
 const applyPlugins = require('./helpers/schema/applyPlugins');
@@ -1380,11 +1381,40 @@ Connection.prototype.setClient = function setClient(client) {
   return this;
 };
 
-Connection.prototype.syncIndexes = async function syncIndexes() {
+/**
+ *
+ * Syncs all the indexes for the models registered with this connection.
+ *
+ * @param {Object} options
+ * @param {Boolean} options.continueOnError `false` by default. If set to `true`, mongoose will not throw an error if one model syncing failed, and will return an object where the keys are the names of the models, and the values are the results/errors for each model.
+ * @returns
+ */
+Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
   const result = {};
-  for (const model in this.models) {
-    result[model] = await this.model(model).syncIndexes();
+  const errorsMap = { };
+
+  const { continueOnError } = options;
+  delete options.continueOnError;
+
+  for (const model of Object.values(this.models)) {
+    try {
+      result[model.modelName] = await model.syncIndexes(options);
+    } catch (err) {
+      if (!continueOnError) {
+        errorsMap[model.modelName] = err;
+        break;
+      } else {
+        result[model.modelName] = err;
+      }
+    }
   }
+
+  if (!continueOnError && Object.keys(errorsMap).length) {
+    const message = Object.entries(errorsMap).map(([modelName, err]) => `${modelName}: ${err.message}`).join(', ');
+    const syncIndexesError = new SyncIndexesError(message, errorsMap);
+    throw syncIndexesError;
+  }
+
   return result;
 };
 

package/lib/document.js

@@ -90,7 +90,7 @@ function Document(obj, fields, skipId, options) {
     options = arguments[4] || {};
   }
 
-  this.$__ = new InternalCache;
+  this.$__ = new InternalCache();
   this.$isNew = 'isNew' in options ? options.isNew : true;
 
   if ('priorDoc' in options) {
@@ -479,7 +479,7 @@ function $__applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSet
           break;
         }
       } else if (exclude === false && fields && !included) {
-        if (curPath in fields) {
+        if (curPath in fields || type.$isSingleNested && hasIncludedChildren[curPath]) {
           included = true;
         } else if (!hasIncludedChildren[curPath]) {
           break;
@@ -795,11 +795,12 @@ function init(self, obj, doc, opts, prefix) {
 
   const keys = Object.keys(obj);
   const len = keys.length;
-  let schema;
+  let schemaType;
   let path;
   let i;
   let index = 0;
   const strict = self.$__.strictMode;
+  const docSchema = self.$__schema;
 
   while (index < len) {
     _init(index++);
@@ -808,25 +809,27 @@ function init(self, obj, doc, opts, prefix) {
   function _init(index) {
     i = keys[index];
     path = prefix + i;
-    schema = self.$__schema.path(path);
+    schemaType = docSchema.path(path);
 
     // Should still work if not a model-level discriminator, but should not be
     // necessary. This is *only* to catch the case where we queried using the
     // base model and the discriminated model has a projection
-    if (self.$__schema.$isRootDiscriminator && !self.$__isSelected(path)) {
+    if (docSchema.$isRootDiscriminator && !self.$__isSelected(path)) {
       return;
     }
 
-    if (!schema && utils.isPOJO(obj[i])) {
+    if (!schemaType && utils.isPOJO(obj[i])) {
       // assume nested object
       if (!doc[i]) {
         doc[i] = {};
+        if (!strict && !(i in docSchema.tree) && !(i in docSchema.methods) && !(i in docSchema.virtuals)) {
+          self[i] = doc[i];
+        }
       }
       init(self, obj[i], doc[i], opts, path + '.');
-    } else if (!schema) {
+    } else if (!schemaType) {
       doc[i] = obj[i];
-      if (!strict && !prefix) {
-        // Set top-level properties that aren't in the schema if strict is false
+      if (!strict) {
         self[i] = obj[i];
       }
     } else {
@@ -835,13 +838,13 @@ function init(self, obj, doc, opts, prefix) {
         delete doc[i];
       }
       if (obj[i] === null) {
-        doc[i] = schema._castNullish(null);
+        doc[i] = schemaType._castNullish(null);
       } else if (obj[i] !== undefined) {
         const wasPopulated = obj[i].$__ == null ? null : obj[i].$__.wasPopulated;
 
-        if (schema && !wasPopulated) {
+        if (schemaType && !wasPopulated) {
           try {
-            doc[i] = schema.cast(obj[i], self, true);
+            doc[i] = schemaType.cast(obj[i], self, true);
           } catch (e) {
             self.invalidate(e.path, new ValidatorError({
               path: e.path,
@@ -1135,7 +1138,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       // them to ensure we keep the user's key order.
       if (type === true &&
           !prefix &&
-          path[key] != null &&
+          valForKey != null &&
           pathtype === 'nested' &&
           this._doc[key] != null) {
         delete this._doc[key];
@@ -1313,7 +1316,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
   let curPath = '';
   for (i = 0; i < parts.length - 1; ++i) {
     cur = cur[parts[i]];
-    curPath += (curPath.length > 0 ? '.' : '') + parts[i];
+    curPath += (curPath.length !== 0 ? '.' : '') + parts[i];
     if (!cur) {
       this.$set(curPath, {});
       // Hack re: gh-5800. If nested field is not selected, it probably exists
@@ -1336,7 +1339,8 @@ Document.prototype.$set = function $set(path, val, type, options) {
   if (parts.length <= 1) {
     pathToMark = path;
   } else {
-    for (i = 0; i < parts.length; ++i) {
+    const len = parts.length;
+    for (i = 0; i < len; ++i) {
       const subpath = parts.slice(0, i + 1).join('.');
       if (this.$get(subpath, null, { getters: false }) === null) {
         pathToMark = subpath;
@@ -1361,7 +1365,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
     _markValidSubpaths(this, path);
   }
 
-  if (schema.$isSingleNested && val != null && merge) {
+  if (val != null && merge && schema.$isSingleNested) {
     if (val instanceof Document) {
       val = val.toObject({ virtuals: false, transform: false });
     }
@@ -1431,9 +1435,10 @@ Document.prototype.$set = function $set(path, val, type, options) {
       val = schema.applySetters(val, this, false, priorVal);
     }
 
-    if (schema.$isMongooseDocumentArray &&
-        Array.isArray(val) &&
-        val.length > 0 &&
+    if (Array.isArray(val) &&
+        !Array.isArray(schema) &&
+        schema.$isMongooseDocumentArray &&
+        val.length !== 0 &&
         val[0] != null &&
         val[0].$__ != null &&
         val[0].$__.populated != null) {
@@ -1459,7 +1464,7 @@ Document.prototype.$set = function $set(path, val, type, options) {
       delete this.$__.populated[path];
     }
 
-    if (schema.$isSingleNested && val != null) {
+    if (val != null && schema.$isSingleNested) {
       _checkImmutableSubpaths(val, schema, priorVal);
     }
 
@@ -1652,11 +1657,11 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
 
     // handle directly setting arrays (gh-1126)
     MongooseArray || (MongooseArray = require('./types/array'));
-    if (val && val.isMongooseArray) {
+    if (val && utils.isMongooseArray(val)) {
       val._registerAtomic('$set', val);
 
       // Update embedded document parent references (gh-5189)
-      if (val.isMongooseDocumentArray) {
+      if (utils.isMongooseDocumentArray(val)) {
         val.forEach(function(item) {
           item && item.__parentArray && (item.__parentArray = val);
         });
@@ -1670,10 +1675,10 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
         }
       });
     }
-  } else if (Array.isArray(val) && val.isMongooseArray && Array.isArray(priorVal) && priorVal.isMongooseArray) {
+  } else if (Array.isArray(val) && Array.isArray(priorVal) && utils.isMongooseArray(val) && utils.isMongooseArray(priorVal)) {
     val[arrayAtomicsSymbol] = priorVal[arrayAtomicsSymbol];
     val[arrayAtomicsBackupSymbol] = priorVal[arrayAtomicsBackupSymbol];
-    if (val.isMongooseDocumentArray) {
+    if (utils.isMongooseDocumentArray(val)) {
       val.forEach(doc => { doc.isNew = false; });
     }
   }
@@ -1702,7 +1707,7 @@ Document.prototype.$__set = function(pathToMark, path, options, constructing, pa
         obj = obj[parts[i]];
       } else if (obj[parts[i]] && obj[parts[i]] instanceof Embedded) {
         obj = obj[parts[i]];
-      } else if (obj[parts[i]] && obj[parts[i]].$isSingleNested) {
+      } else if (obj[parts[i]] && !Array.isArray(obj[parts[i]]) && obj[parts[i]].$isSingleNested) {
         obj = obj[parts[i]];
       } else if (obj[parts[i]] && Array.isArray(obj[parts[i]])) {
         obj = obj[parts[i]];
@@ -1963,7 +1968,7 @@ Document.prototype.$isEmpty = function(path) {
     transform: false
   };
 
-  if (arguments.length > 0) {
+  if (arguments.length !== 0) {
     const v = this.$get(path);
     if (v == null) {
       return true;
@@ -2006,51 +2011,60 @@ function _isEmpty(v) {
 
 Document.prototype.modifiedPaths = function(options) {
   options = options || {};
+
   const directModifiedPaths = Object.keys(this.$__.activePaths.states.modify);
-  const _this = this;
-  return directModifiedPaths.reduce(function(list, path) {
-    const parts = path.split('.');
-    list = list.concat(parts.reduce(function(chains, part, i) {
-      return chains.concat(parts.slice(0, i).concat(part).join('.'));
-    }, []).filter(function(chain) {
-      return (list.indexOf(chain) === -1);
-    }));
+  const result = new Set();
+
+  let i = 0;
+  let j = 0;
+  const len = directModifiedPaths.length;
+
+  for (i = 0; i < len; ++i) {
+    const path = directModifiedPaths[i];
+    const parts = parentPaths(path);
+    const pLen = parts.length;
+
+    for (j = 0; j < pLen; ++j) {
+      result.add(parts[j]);
+    }
 
     if (!options.includeChildren) {
-      return list;
+      continue;
     }
 
-    let cur = _this.$get(path);
-    if (cur != null && typeof cur === 'object') {
+    let ii = 0;
+    let cur = this.$get(path);
+    if (typeof cur === 'object' && cur !== null) {
       if (cur._doc) {
         cur = cur._doc;
       }
+      const len = cur.length;
       if (Array.isArray(cur)) {
-        const len = cur.length;
-        for (let i = 0; i < len; ++i) {
-          if (list.indexOf(path + '.' + i) === -1) {
-            list.push(path + '.' + i);
-            if (cur[i] != null && cur[i].$__) {
-              const modified = cur[i].modifiedPaths();
-              for (const childPath of modified) {
-                list.push(path + '.' + i + '.' + childPath);
+        for (ii = 0; ii < len; ++ii) {
+          const subPath = path + '.' + ii;
+          if (!result.has(subPath)) {
+            result.add(subPath);
+            if (cur[ii] != null && cur[ii].$__) {
+              const modified = cur[ii].modifiedPaths();
+              let iii = 0;
+              const iiiLen = modified.length;
+              for (iii = 0; iii < iiiLen; ++iii) {
+                result.add(subPath + '.' + modified[iii]);
               }
             }
           }
         }
       } else {
-        Object.keys(cur).
-          filter(function(key) {
-            return list.indexOf(path + '.' + key) === -1;
-          }).
-          forEach(function(key) {
-            list.push(path + '.' + key);
-          });
+        const keys = Object.keys(cur);
+        let ii = 0;
+        const len = keys.length;
+        for (ii = 0; ii < len; ++ii) {
+          result.add(path + '.' + keys[ii]);
+        }
       }
     }
-
-    return list;
-  }, []);
+  }
+  return Array.from(result);
 };
 
 Document.prototype[documentModifiedPaths] = Document.prototype.modifiedPaths;
@@ -2448,7 +2462,12 @@ Document.prototype.$validate = Document.prototype.validate;
  */
 
 function _evaluateRequiredFunctions(doc) {
-  Object.keys(doc.$__.activePaths.states.require).forEach(path => {
+  const requiredFields = Object.keys(doc.$__.activePaths.states.require);
+  let i = 0;
+  const len = requiredFields.length;
+  for (i = 0; i < len; ++i) {
+    const path = requiredFields[i];
+
     const p = doc.$__schema.path(path);
 
     if (p != null && typeof p.originalRequiredValue === 'function') {
@@ -2459,7 +2478,7 @@ function _evaluateRequiredFunctions(doc) {
         doc.invalidate(path, err);
       }
     }
-  });
+  }
 }
 
 /*!
@@ -2520,7 +2539,7 @@ function _getPathsToValidate(doc) {
         // To avoid potential performance issues, skip doc arrays whose children
         // are not required. `getPositionalPathType()` may be slow, so avoid
         // it unless we have a case of #6364
-        (_pathType.$isMongooseDocumentArray && !get(_pathType, 'schemaOptions.required'))) {
+        (!Array.isArray(_pathType) && _pathType.$isMongooseDocumentArray && !get(_pathType, 'schemaOptions.required'))) {
       continue;
     }
 
@@ -3112,7 +3131,7 @@ Document.prototype.$__reset = function reset() {
       return _this.$__getValue(i);
     })
     .filter(function(val) {
-      return val && val instanceof Array && val.isMongooseDocumentArray && val.length;
+      return val && val instanceof Array && utils.isMongooseDocumentArray(val) && val.length;
     })
     .forEach(function(array) {
       let i = array.length;
@@ -3135,7 +3154,7 @@ Document.prototype.$__reset = function reset() {
       return _this.$__getValue(i);
     }).
     filter(function(val) {
-      return val && val.$isSingleNested;
+      return val && !Array.isArray(val) && val.$isSingleNested;
     }).
     forEach(function(doc) {
       doc.$__reset();
@@ -3315,7 +3334,7 @@ Document.prototype.$__getArrayPathsToValidate = function() {
       return this.$__getValue(i);
     }.bind(this))
     .filter(function(val) {
-      return val && val instanceof Array && val.isMongooseDocumentArray && val.length;
+      return val && val instanceof Array && utils.isMongooseDocumentArray(val) && val.length;
     }).reduce(function(seed, array) {
       return seed.concat(array);
     }, [])
@@ -3357,12 +3376,12 @@ Document.prototype.$getAllSubdocs = function() {
       seed = Array.from(val.keys()).reduce(function(seed, path) {
         return docReducer(val.get(path), seed, null);
       }, seed);
-    } else if (val && val.$isSingleNested) {
+    } else if (val && !Array.isArray(val) && val.$isSingleNested) {
       seed = Object.keys(val._doc).reduce(function(seed, path) {
         return docReducer(val._doc, seed, path);
       }, seed);
       seed.push(val);
-    } else if (val && val.isMongooseDocumentArray) {
+    } else if (val && utils.isMongooseDocumentArray(val)) {
       val.forEach(function _docReduce(doc) {
         if (!doc || !doc._doc) {
           return;
@@ -3801,7 +3820,7 @@ function applyVirtuals(self, json, options, toObjectOptions) {
       if (!path.startsWith(options.path + '.')) {
         continue;
       }
-      assignPath = path.substr(options.path.length + 1);
+      assignPath = path.substring(options.path.length + 1);
     }
     const parts = assignPath.split('.');
     v = clone(self.get(path), options);
@@ -4139,7 +4158,7 @@ Document.prototype.populate = function populate() {
   const args = [...arguments];
   let fn;
 
-  if (args.length > 0) {
+  if (args.length !== 0) {
     if (typeof args[args.length - 1] === 'function') {
       fn = args.pop();
     }

package/lib/error/index.js

@@ -181,6 +181,17 @@ MongooseError.OverwriteModelError = require('./overwriteModel');
 
 MongooseError.MissingSchemaError = require('./missingSchema');
 
+/**
+ * Thrown when the MongoDB Node driver can't connect to a valid server
+ * to send an operation to.
+ *
+ * @api public
+ * @memberOf Error
+ * @static MongooseServerSelectionError
+ */
+
+MongooseError.MongooseServerSelectionError = require('./serverSelection');
+
 /**
  * An instance of this error will be returned if you used an array projection
  * and then modified the array in an unsafe way.

package/lib/error/syncIndexes.js

@@ -0,0 +1,30 @@
+'use strict';
+
+/*!
+ * Module dependencies.
+ */
+
+const MongooseError = require('./mongooseError');
+
+/**
+ * SyncIndexes Error constructor.
+ *
+ * @param {String} message
+ * @param {String} errorsMap
+ * @inherits MongooseError
+ * @api private
+ */
+
+class SyncIndexesError extends MongooseError {
+  constructor(message, errorsMap) {
+    super(message);
+    this.errors = errorsMap;
+  }
+}
+
+Object.defineProperty(SyncIndexesError.prototype, 'name', {
+  value: 'SyncIndexesError'
+});
+
+
+module.exports = SyncIndexesError;

package/lib/helpers/clone.js

@@ -1,7 +1,5 @@
 'use strict';
 
-
-const cloneRegExp = require('regexp-clone');
 const Decimal = require('../types/decimal128');
 const ObjectId = require('../types/objectid');
 const specialProperties = require('./specialProperties');
@@ -34,7 +32,7 @@ function clone(obj, options, isArrayChild) {
   }
 
   if (Array.isArray(obj)) {
-    return cloneArray(obj, options);
+    return cloneArray(utils.isMongooseArray(obj) ? obj.__array : obj, options);
   }
 
   if (isMongooseObject(obj)) {
@@ -54,12 +52,14 @@ function clone(obj, options, isArrayChild) {
     return obj.toObject(options);
   }
 
-  if (obj.constructor) {
-    switch (getFunctionName(obj.constructor)) {
+  const objConstructor = obj.constructor;
+
+  if (objConstructor) {
+    switch (getFunctionName(objConstructor)) {
       case 'Object':
         return cloneObject(obj, options, isArrayChild);
       case 'Date':
-        return new obj.constructor(+obj);
+        return new objConstructor(+obj);
       case 'RegExp':
         return cloneRegExp(obj);
       default:
@@ -79,12 +79,12 @@ function clone(obj, options, isArrayChild) {
     return Decimal.fromString(obj.toString());
   }
 
-  if (!obj.constructor && isObject(obj)) {
-    // object created with Object.create(null)
+  // object created with Object.create(null)
+  if (!objConstructor && isObject(obj)) {
     return cloneObject(obj, options, isArrayChild);
   }
 
-  if (obj[symbols.schemaTypeSymbol]) {
+  if (typeof obj === 'object' && obj[symbols.schemaTypeSymbol]) {
     return obj.clone();
   }
 
@@ -95,7 +95,7 @@ function clone(obj, options, isArrayChild) {
     return obj;
   }
 
-  if (obj.valueOf != null) {
+  if (typeof obj.valueOf === 'function') {
     return obj.valueOf();
   }
 
@@ -112,25 +112,28 @@ function cloneObject(obj, options, isArrayChild) {
   const ret = {};
   let hasKeys;
 
-  if (obj[trustedSymbol]) {
+  if (trustedSymbol in obj) {
     ret[trustedSymbol] = obj[trustedSymbol];
   }
 
-  for (const k of Object.keys(obj)) {
-    if (specialProperties.has(k)) {
+  let i = 0;
+  let key = '';
+  const keys = Object.keys(obj);
+  const len = keys.length;
+
+  for (i = 0; i < len; ++i) {
+    if (specialProperties.has(key = keys[i])) {
       continue;
     }
 
     // Don't pass `isArrayChild` down
-    const val = clone(obj[k], options);
-
-    if (!minimize || (typeof val !== 'undefined')) {
-      if (minimize === false && typeof val === 'undefined') {
-        delete ret[k];
-      } else {
-        hasKeys || (hasKeys = true);
-        ret[k] = val;
-      }
+    const val = clone(obj[key], options, false);
+
+    if (minimize === false && typeof val === 'undefined') {
+      delete ret[key];
+    } else if (minimize !== true || (typeof val !== 'undefined')) {
+      hasKeys || (hasKeys = true);
+      ret[key] = val;
     }
   }
 
@@ -138,11 +141,21 @@ function cloneObject(obj, options, isArrayChild) {
 }
 
 function cloneArray(arr, options) {
-  const ret = [];
-
-  for (const item of arr) {
-    ret.push(clone(item, options, true));
+  let i = 0;
+  const len = arr.length;
+  const ret = new Array(len);
+  for (i = 0; i < len; ++i) {
+    ret[i] = clone(arr[i], options, true);
   }
 
   return ret;
-}
+}
+
+function cloneRegExp(regexp) {
+  const ret = new RegExp(regexp.source, regexp.flags);
+
+  if (ret.lastIndex !== regexp.lastIndex) {
+    ret.lastIndex = regexp.lastIndex;
+  }
+  return ret;
+}