{"version":3,"sources":["meteor://💻app/packages/minimongo/minimongo_server.js","meteor://💻app/packages/minimongo/common.js","meteor://💻app/packages/minimongo/cursor.js","meteor://💻app/packages/minimongo/local_collection.js","meteor://💻app/packages/minimongo/matcher.js","meteor://💻app/packages/minimongo/minimongo_common.js","meteor://💻app/packages/minimongo/observe_handle.js","meteor://💻app/packages/minimongo/sorter.js"],"names":["module","link","hasOwn","isNumericKey","isOperatorObject","pathsToTree","projectionDetails","v","Minimongo","_pathsElidingNumericKeys","paths","map","path","split","filter","part","join","Matcher","prototype","affectedByModifier","modifier","Object","assign","$set","$unset","meaningfulPaths","_getPaths","modifiedPaths","concat","keys","some","mod","meaningfulPath","sel","i","j","length","canBecomeTrueByModifier","isSimple","modifierPaths","pathHasNumericKeys","expectedScalarIsObject","_selector","modifierPath","startsWith","matchingDocument","EJSON","clone","LocalCollection","_modify","error","name","setPropertyError","documentMatches","result","combineIntoProjection","projection","selectorPaths","includes","combineImportantPathsIntoProjection","_matchingDocument","undefined","fallback","valueSelector","$eq","$in","matcher","placeholder","find","onlyContainsKeys","lowerBound","Infinity","upperBound","forEach","op","call","middle","x","Sorter","_selectorForAffectedByModifier","details","tree","node","fullPath","mergedProjection","treeToPaths","including","mergedExclProjection","getPaths","selector","_paths","obj","every","k","prefix","key","value","export","ELEMENT_OPERATORS","compileDocumentSelector","equalityElementMatcher","expandArraysInBranches","isIndexable","makeLookupFunction","nothingMatcher","populateDocumentWithQueryFields","regexpElementMatcher","default","hasOwnProperty","$lt","makeInequality","cmpValue","$gt","$lte","$gte","$mod","compileElementSelector","operand","Array","isArray","Error","divisor","remainder","elementMatchers","option","RegExp","$size","dontExpandLeafArrays","$type","dontIncludeLeafArrays","operandAliasMap","_f","_type","$bitsAllSet","mask","getOperandBitmask","bitmask","getValueBitmask","byte","$bitsAnySet","$bitsAllClear","$bitsAnyClear","$regex","regexp","$options","test","source","$elemMatch","_isPlainObject","isDocMatcher","LOGICAL_OPERATORS","reduce","a","b","subMatcher","inElemMatch","compileValueSelector","arrayElement","arg","dontIterate","$and","subSelector","andDocumentMatchers","compileArrayOfDocumentSelectors","$or","matchers","doc","fn","$nor","$where","selectorValue","_recordPathUsed","_hasWhere","Function","$comment","VALUE_OPERATORS","convertElementMatcherToBranchedMatcher","$not","invertBranchedMatcher","$ne","$nin","$exists","exists","everythingMatcher","$maxDistance","$near","$all","branchedMatchers","criterion","andBranchedMatchers","isRoot","_hasGeoQuery","maxDistance","point","distance","$geometry","type","GeoJSON","pointDistance","coordinates","pointToArray","geometryWithinRadius","distanceCoordinatePairs","branchedValues","branch","curDistance","_isUpdate","arrayIndices","andSomeMatchers","subMatchers","docOrBranches","match","subResult","selectors","docSelector","options","docMatchers","substr","_isSimple","lookUpByIndex","valueMatcher","Boolean","operatorBranchedMatcher","elementMatcher","branches","expanded","element","matched","pointA","pointB","Math","hypot","elementSelector","_equal","docOrBranchedValues","skipTheArrays","branchesOut","thisIsArray","push","Number","isInteger","Uint8Array","Int32Array","buffer","isBinary","ArrayBuffer","max","view","isSafeInteger","Uint32Array","BYTES_PER_ELEMENT","insertIntoDocument","document","existingKey","indexOf","branchedMatcher","branchValues","s","inconsistentOK","theseAreOperators","selKey","thisIsOperator","JSON","stringify","cmpValueComparator","operandType","_cmp","parts","firstPart","lookupRest","slice","omitUnnecessaryFields","firstLevel","appendToResult","more","forSort","arrayIndex","MinimongoTest","MinimongoError","message","field","operatorMatchers","operator","simpleRange","simpleEquality","simpleInclusion","newLeafFn","conflictFn","root","pathArray","success","lastKey","y","populateDocumentWithKeyValue","getPrototypeOf","populateDocumentWithObject","unprefixedKeys","validateObject","object","query","_selectorIsId","fields","fieldsKeys","sort","_id","keyPath","rule","projectionRulesTree","currentPath","anotherPath","toString","lastIndex","validateKeyInPath","Cursor","constructor","collection","sorter","_selectorIsIdPerhapsAsObject","_selectorId","hasGeoQuery","skip","limit","_projectionFn","_compileProjection","_transform","wrapTransform","transform","Tracker","reactive","count","applySkipLimit","_depend","added","removed","_getRawObjects","ordered","fetch","Symbol","iterator","addedBefore","changed","movedBefore","index","objects","next","done","callback","thisArg","getTransform","observe","_observeFromObserveChanges","observeChanges","_observeChangesCallbacksAreOrdered","_allow_unordered","distances","_IdMap","cursor","dirty","projectionFn","resultsSnapshot","qid","next_qid","queries","results","paused","wrapCallback","self","args","arguments","_observeQueue","queueTask","apply","_suppress_initial","handle","ObserveHandle","stop","active","onInvalidate","drain","rewind","changers","dependency","Dependency","notify","bind","depend","_getCollectionName","selectedDoc","_docs","get","set","clear","id","matchResult","getComparator","_publishCursor","subscription","Package","mongo","Mongo","Collection","Meteor","_SynchronousQueue","create","_savedOriginals","findOne","insert","assertHasValidFieldNames","_useOID","MongoID","ObjectID","Random","has","_saveOriginal","queriesToRecompute","_insertInResults","_recomputeResults","defer","pauseObservers","remove","equals","size","_eachPossiblyMatchingDoc","queryRemove","removeId","removeDoc","_removeFromResults","resumeObservers","_diffQueryChanges","retrieveOriginals","originals","saveOriginals","update","qidToOriginalResults","docMap","idsMatched","_idsMatchedBySelector","memoizedCloneIfNeeded","docToMemoize","recomputeQids","updateCount","queryResult","_modifyAndNotify","multi","insertedId","upsert","_createUpsertDocument","_returnObject","numberAffected","specificIds","matched_before","old_doc","afterMatch","after","before","_updateInResults","oldResults","_CachingChangeObserver","orderedFromCallbacks","callbacks","docs","OrderedDict","idStringify","applyChange","putBefore","moveBefore","DiffSequence","applyChanges","IdMap","idParse","__wrappedTransform__","wrapped","transformed","nonreactive","_binarySearch","cmp","array","first","range","halfRange","floor","_checkSupportedProjection","_idProjection","ruleTree","subdoc","selectorDocument","isModify","_isModificationMod","newDoc","isInsert","replacement","_diffObjects","left","right","diffObjects","newResults","observer","diffQueryChanges","_diffQueryOrderedChanges","diffQueryOrderedChanges","_diffQueryUnorderedChanges","diffQueryUnorderedChanges","_findInOrderedResults","subIds","_insertInSortedList","splice","isReplace","isModifier","setOnInsert","modFunc","MODIFIERS","keypath","keyparts","target","findModTarget","forbidArray","noCreate","NO_CREATE_MODIFIERS","pop","observeCallbacks","suppressed","observeChangesCallbacks","_observeCallbacksAreOrdered","indices","_no_indices","addedAt","changedAt","oldDoc","movedTo","from","to","removedAt","changeObserver","changedFields","makeChangedFields","old_idx","new_idx","$currentDate","Date","$min","$max","$inc","$setOnInsert","$push","$each","toPush","position","$position","$slice","sortFunction","$sort","spliceArguments","$pushAll","$addToSet","isEach","values","toAdd","$pop","toPop","$pull","toPull","out","$pullAll","$rename","target2","$bit","$v","invalidCharMsg","$","assertIsValidFieldName","usedArrayIndex","last","keypart","parseInt","isUpdate","_docMatcher","_compileSelector","hasWhere","keyOrderSensitive","_typeorder","t","ta","tb","oa","ob","toHexString","getTime","toArray","LocalCollection_","spec","_sortSpecParts","_sortFunction","addSpecPart","ascending","charAt","lookup","_keyComparator","composeComparators","_keyFieldComparator","_getBaseComparator","_compareKeys","key1","key2","_generateKeysFromDoc","cb","pathFromIndices","knownPaths","valuesByIndexAndPath","usedPaths","soleKey","doc1","doc2","_getMinKeyFromDoc","minKey","invert","compare","comparatorArray"],"mappings":"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","file":"/packages/minimongo.js","sourcesContent":["import './minimongo_common.js';\nimport {\n  hasOwn,\n  isNumericKey,\n  isOperatorObject,\n  pathsToTree,\n  projectionDetails,\n} from './common.js';\n\nMinimongo._pathsElidingNumericKeys = paths => paths.map(path =>\n  path.split('.').filter(part => !isNumericKey(part)).join('.')\n);\n\n// Returns true if the modifier applied to some document may change the result\n// of matching the document by selector\n// The modifier is always in a form of Object:\n//  - $set\n//    - 'a.b.22.z': value\n//    - 'foo.bar': 42\n//  - $unset\n//    - 'abc.d': 1\nMinimongo.Matcher.prototype.affectedByModifier = function(modifier) {\n  // safe check for $set/$unset being objects\n  modifier = Object.assign({$set: {}, $unset: {}}, modifier);\n\n  const meaningfulPaths = this._getPaths();\n  const modifiedPaths = [].concat(\n    Object.keys(modifier.$set),\n    Object.keys(modifier.$unset)\n  );\n\n  return modifiedPaths.some(path => {\n    const mod = path.split('.');\n\n    return meaningfulPaths.some(meaningfulPath => {\n      const sel = meaningfulPath.split('.');\n\n      let i = 0, j = 0;\n\n      while (i < sel.length && j < mod.length) {\n        if (isNumericKey(sel[i]) && isNumericKey(mod[j])) {\n          // foo.4.bar selector affected by foo.4 modifier\n          // foo.3.bar selector unaffected by foo.4 modifier\n          if (sel[i] === mod[j]) {\n            i++;\n            j++;\n          } else {\n            return false;\n          }\n        } else if (isNumericKey(sel[i])) {\n          // foo.4.bar selector unaffected by foo.bar modifier\n          return false;\n        } else if (isNumericKey(mod[j])) {\n          j++;\n        } else if (sel[i] === mod[j]) {\n          i++;\n          j++;\n        } else {\n          return false;\n        }\n      }\n\n      // One is a prefix of another, taking numeric fields into account\n      return true;\n    });\n  });\n};\n\n// @param modifier - Object: MongoDB-styled modifier with `$set`s and `$unsets`\n//                           only. (assumed to come from oplog)\n// @returns - Boolean: if after applying the modifier, selector can start\n//                     accepting the modified value.\n// NOTE: assumes that document affected by modifier didn't match this Matcher\n// before, so if modifier can't convince selector in a positive change it would\n// stay 'false'.\n// Currently doesn't support $-operators and numeric indices precisely.\nMinimongo.Matcher.prototype.canBecomeTrueByModifier = function(modifier) {\n  if (!this.affectedByModifier(modifier)) {\n    return false;\n  }\n\n  if (!this.isSimple()) {\n    return true;\n  }\n\n  modifier = Object.assign({$set: {}, $unset: {}}, modifier);\n\n  const modifierPaths = [].concat(\n    Object.keys(modifier.$set),\n    Object.keys(modifier.$unset)\n  );\n\n  if (this._getPaths().some(pathHasNumericKeys) ||\n      modifierPaths.some(pathHasNumericKeys)) {\n    return true;\n  }\n\n  // check if there is a $set or $unset that indicates something is an\n  // object rather than a scalar in the actual object where we saw $-operator\n  // NOTE: it is correct since we allow only scalars in $-operators\n  // Example: for selector {'a.b': {$gt: 5}} the modifier {'a.b.c':7} would\n  // definitely set the result to false as 'a.b' appears to be an object.\n  const expectedScalarIsObject = Object.keys(this._selector).some(path => {\n    if (!isOperatorObject(this._selector[path])) {\n      return false;\n    }\n\n    return modifierPaths.some(modifierPath =>\n      modifierPath.startsWith(`${path}.`)\n    );\n  });\n\n  if (expectedScalarIsObject) {\n    return false;\n  }\n\n  // See if we can apply the modifier on the ideally matching object. If it\n  // still matches the selector, then the modifier could have turned the real\n  // object in the database into something matching.\n  const matchingDocument = EJSON.clone(this.matchingDocument());\n\n  // The selector is too complex, anything can happen.\n  if (matchingDocument === null) {\n    return true;\n  }\n\n  try {\n    LocalCollection._modify(matchingDocument, modifier);\n  } catch (error) {\n    // Couldn't set a property on a field which is a scalar or null in the\n    // selector.\n    // Example:\n    // real document: { 'a.b': 3 }\n    // selector: { 'a': 12 }\n    // converted selector (ideal document): { 'a': 12 }\n    // modifier: { $set: { 'a.b': 4 } }\n    // We don't know what real document was like but from the error raised by\n    // $set on a scalar field we can reason that the structure of real document\n    // is completely different.\n    if (error.name === 'MinimongoError' && error.setPropertyError) {\n      return false;\n    }\n\n    throw error;\n  }\n\n  return this.documentMatches(matchingDocument).result;\n};\n\n// Knows how to combine a mongo selector and a fields projection to a new fields\n// projection taking into account active fields from the passed selector.\n// @returns Object - projection object (same as fields option of mongo cursor)\nMinimongo.Matcher.prototype.combineIntoProjection = function(projection) {\n  const selectorPaths = Minimongo._pathsElidingNumericKeys(this._getPaths());\n\n  // Special case for $where operator in the selector - projection should depend\n  // on all fields of the document. getSelectorPaths returns a list of paths\n  // selector depends on. If one of the paths is '' (empty string) representing\n  // the root or the whole document, complete projection should be returned.\n  if (selectorPaths.includes('')) {\n    return {};\n  }\n\n  return combineImportantPathsIntoProjection(selectorPaths, projection);\n};\n\n// Returns an object that would match the selector if possible or null if the\n// selector is too complex for us to analyze\n// { 'a.b': { ans: 42 }, 'foo.bar': null, 'foo.baz': \"something\" }\n// => { a: { b: { ans: 42 } }, foo: { bar: null, baz: \"something\" } }\nMinimongo.Matcher.prototype.matchingDocument = function() {\n  // check if it was computed before\n  if (this._matchingDocument !== undefined) {\n    return this._matchingDocument;\n  }\n\n  // If the analysis of this selector is too hard for our implementation\n  // fallback to \"YES\"\n  let fallback = false;\n\n  this._matchingDocument = pathsToTree(\n    this._getPaths(),\n    path => {\n      const valueSelector = this._selector[path];\n\n      if (isOperatorObject(valueSelector)) {\n        // if there is a strict equality, there is a good\n        // chance we can use one of those as \"matching\"\n        // dummy value\n        if (valueSelector.$eq) {\n          return valueSelector.$eq;\n        }\n\n        if (valueSelector.$in) {\n          const matcher = new Minimongo.Matcher({placeholder: valueSelector});\n\n          // Return anything from $in that matches the whole selector for this\n          // path. If nothing matches, returns `undefined` as nothing can make\n          // this selector into `true`.\n          return valueSelector.$in.find(placeholder =>\n            matcher.documentMatches({placeholder}).result\n          );\n        }\n\n        if (onlyContainsKeys(valueSelector, ['$gt', '$gte', '$lt', '$lte'])) {\n          let lowerBound = -Infinity;\n          let upperBound = Infinity;\n\n          ['$lte', '$lt'].forEach(op => {\n            if (hasOwn.call(valueSelector, op) &&\n                valueSelector[op] < upperBound) {\n              upperBound = valueSelector[op];\n            }\n          });\n\n          ['$gte', '$gt'].forEach(op => {\n            if (hasOwn.call(valueSelector, op) &&\n                valueSelector[op] > lowerBound) {\n              lowerBound = valueSelector[op];\n            }\n          });\n\n          const middle = (lowerBound + upperBound) / 2;\n          const matcher = new Minimongo.Matcher({placeholder: valueSelector});\n\n          if (!matcher.documentMatches({placeholder: middle}).result &&\n              (middle === lowerBound || middle === upperBound)) {\n            fallback = true;\n          }\n\n          return middle;\n        }\n\n        if (onlyContainsKeys(valueSelector, ['$nin', '$ne'])) {\n          // Since this._isSimple makes sure $nin and $ne are not combined with\n          // objects or arrays, we can confidently return an empty object as it\n          // never matches any scalar.\n          return {};\n        }\n\n        fallback = true;\n      }\n\n      return this._selector[path];\n    },\n    x => x);\n\n  if (fallback) {\n    this._matchingDocument = null;\n  }\n\n  return this._matchingDocument;\n};\n\n// Minimongo.Sorter gets a similar method, which delegates to a Matcher it made\n// for this exact purpose.\nMinimongo.Sorter.prototype.affectedByModifier = function(modifier) {\n  return this._selectorForAffectedByModifier.affectedByModifier(modifier);\n};\n\nMinimongo.Sorter.prototype.combineIntoProjection = function(projection) {\n  return combineImportantPathsIntoProjection(\n    Minimongo._pathsElidingNumericKeys(this._getPaths()),\n    projection\n  );\n};\n\nfunction combineImportantPathsIntoProjection(paths, projection) {\n  const details = projectionDetails(projection);\n\n  // merge the paths to include\n  const tree = pathsToTree(\n    paths,\n    path => true,\n    (node, path, fullPath) => true,\n    details.tree\n  );\n  const mergedProjection = treeToPaths(tree);\n\n  if (details.including) {\n    // both selector and projection are pointing on fields to include\n    // so we can just return the merged tree\n    return mergedProjection;\n  }\n\n  // selector is pointing at fields to include\n  // projection is pointing at fields to exclude\n  // make sure we don't exclude important paths\n  const mergedExclProjection = {};\n\n  Object.keys(mergedProjection).forEach(path => {\n    if (!mergedProjection[path]) {\n      mergedExclProjection[path] = false;\n    }\n  });\n\n  return mergedExclProjection;\n}\n\nfunction getPaths(selector) {\n  return Object.keys(new Minimongo.Matcher(selector)._paths);\n\n  // XXX remove it?\n  // return Object.keys(selector).map(k => {\n  //   // we don't know how to handle $where because it can be anything\n  //   if (k === '$where') {\n  //     return ''; // matches everything\n  //   }\n\n  //   // we branch from $or/$and/$nor operator\n  //   if (['$or', '$and', '$nor'].includes(k)) {\n  //     return selector[k].map(getPaths);\n  //   }\n\n  //   // the value is a literal or some comparison operator\n  //   return k;\n  // })\n  //   .reduce((a, b) => a.concat(b), [])\n  //   .filter((a, b, c) => c.indexOf(a) === b);\n}\n\n// A helper to ensure object has only certain keys\nfunction onlyContainsKeys(obj, keys) {\n  return Object.keys(obj).every(k => keys.includes(k));\n}\n\nfunction pathHasNumericKeys(path) {\n  return path.split('.').some(isNumericKey);\n}\n\n// Returns a set of key paths similar to\n// { 'foo.bar': 1, 'a.b.c': 1 }\nfunction treeToPaths(tree, prefix = '') {\n  const result = {};\n\n  Object.keys(tree).forEach(key => {\n    const value = tree[key];\n    if (value === Object(value)) {\n      Object.assign(result, treeToPaths(value, `${prefix + key}.`));\n    } else {\n      result[prefix + key] = value;\n    }\n  });\n\n  return result;\n}\n","import LocalCollection from './local_collection.js';\n\nexport const hasOwn = Object.prototype.hasOwnProperty;\n\n// Each element selector contains:\n//  - compileElementSelector, a function with args:\n//    - operand - the \"right hand side\" of the operator\n//    - valueSelector - the \"context\" for the operator (so that $regex can find\n//      $options)\n//    - matcher - the Matcher this is going into (so that $elemMatch can compile\n//      more things)\n//    returning a function mapping a single value to bool.\n//  - dontExpandLeafArrays, a bool which prevents expandArraysInBranches from\n//    being called\n//  - dontIncludeLeafArrays, a bool which causes an argument to be passed to\n//    expandArraysInBranches if it is called\nexport const ELEMENT_OPERATORS = {\n  $lt: makeInequality(cmpValue => cmpValue < 0),\n  $gt: makeInequality(cmpValue => cmpValue > 0),\n  $lte: makeInequality(cmpValue => cmpValue <= 0),\n  $gte: makeInequality(cmpValue => cmpValue >= 0),\n  $mod: {\n    compileElementSelector(operand) {\n      if (!(Array.isArray(operand) && operand.length === 2\n            && typeof operand[0] === 'number'\n            && typeof operand[1] === 'number')) {\n        throw Error('argument to $mod must be an array of two numbers');\n      }\n\n      // XXX could require to be ints or round or something\n      const divisor = operand[0];\n      const remainder = operand[1];\n      return value => (\n        typeof value === 'number' && value % divisor === remainder\n      );\n    },\n  },\n  $in: {\n    compileElementSelector(operand) {\n      if (!Array.isArray(operand)) {\n        throw Error('$in needs an array');\n      }\n\n      const elementMatchers = operand.map(option => {\n        if (option instanceof RegExp) {\n          return regexpElementMatcher(option);\n        }\n\n        if (isOperatorObject(option)) {\n          throw Error('cannot nest $ under $in');\n        }\n\n        return equalityElementMatcher(option);\n      });\n\n      return value => {\n        // Allow {a: {$in: [null]}} to match when 'a' does not exist.\n        if (value === undefined) {\n          value = null;\n        }\n\n        return elementMatchers.some(matcher => matcher(value));\n      };\n    },\n  },\n  $size: {\n    // {a: [[5, 5]]} must match {a: {$size: 1}} but not {a: {$size: 2}}, so we\n    // don't want to consider the element [5,5] in the leaf array [[5,5]] as a\n    // possible value.\n    dontExpandLeafArrays: true,\n    compileElementSelector(operand) {\n      if (typeof operand === 'string') {\n        // Don't ask me why, but by experimentation, this seems to be what Mongo\n        // does.\n        operand = 0;\n      } else if (typeof operand !== 'number') {\n        throw Error('$size needs a number');\n      }\n\n      return value => Array.isArray(value) && value.length === operand;\n    },\n  },\n  $type: {\n    // {a: [5]} must not match {a: {$type: 4}} (4 means array), but it should\n    // match {a: {$type: 1}} (1 means number), and {a: [[5]]} must match {$a:\n    // {$type: 4}}. Thus, when we see a leaf array, we *should* expand it but\n    // should *not* include it itself.\n    dontIncludeLeafArrays: true,\n    compileElementSelector(operand) {\n      if (typeof operand === 'string') {\n        const operandAliasMap = {\n          'double': 1,\n          'string': 2,\n          'object': 3,\n          'array': 4,\n          'binData': 5,\n          'undefined': 6,\n          'objectId': 7,\n          'bool': 8,\n          'date': 9,\n          'null': 10,\n          'regex': 11,\n          'dbPointer': 12,\n          'javascript': 13,\n          'symbol': 14,\n          'javascriptWithScope': 15,\n          'int': 16,\n          'timestamp': 17,\n          'long': 18,\n          'decimal': 19,\n          'minKey': -1,\n          'maxKey': 127,\n        };\n        if (!hasOwn.call(operandAliasMap, operand)) {\n          throw Error(`unknown string alias for $type: ${operand}`);\n        }\n        operand = operandAliasMap[operand];\n      } else if (typeof operand === 'number') {\n        if (operand === 0 || operand < -1\n          || (operand > 19 && operand !== 127)) {\n          throw Error(`Invalid numerical $type code: ${operand}`);\n        }\n      } else {\n        throw Error('argument to $type is not a number or a string');\n      }\n\n      return value => (\n        value !== undefined && LocalCollection._f._type(value) === operand\n      );\n    },\n  },\n  $bitsAllSet: {\n    compileElementSelector(operand) {\n      const mask = getOperandBitmask(operand, '$bitsAllSet');\n      return value => {\n        const bitmask = getValueBitmask(value, mask.length);\n        return bitmask && mask.every((byte, i) => (bitmask[i] & byte) === byte);\n      };\n    },\n  },\n  $bitsAnySet: {\n    compileElementSelector(operand) {\n      const mask = getOperandBitmask(operand, '$bitsAnySet');\n      return value => {\n        const bitmask = getValueBitmask(value, mask.length);\n        return bitmask && mask.some((byte, i) => (~bitmask[i] & byte) !== byte);\n      };\n    },\n  },\n  $bitsAllClear: {\n    compileElementSelector(operand) {\n      const mask = getOperandBitmask(operand, '$bitsAllClear');\n      return value => {\n        const bitmask = getValueBitmask(value, mask.length);\n        return bitmask && mask.every((byte, i) => !(bitmask[i] & byte));\n      };\n    },\n  },\n  $bitsAnyClear: {\n    compileElementSelector(operand) {\n      const mask = getOperandBitmask(operand, '$bitsAnyClear');\n      return value => {\n        const bitmask = getValueBitmask(value, mask.length);\n        return bitmask && mask.some((byte, i) => (bitmask[i] & byte) !== byte);\n      };\n    },\n  },\n  $regex: {\n    compileElementSelector(operand, valueSelector) {\n      if (!(typeof operand === 'string' || operand instanceof RegExp)) {\n        throw Error('$regex has to be a string or RegExp');\n      }\n\n      let regexp;\n      if (valueSelector.$options !== undefined) {\n        // Options passed in $options (even the empty string) always overrides\n        // options in the RegExp object itself.\n\n        // Be clear that we only support the JS-supported options, not extended\n        // ones (eg, Mongo supports x and s). Ideally we would implement x and s\n        // by transforming the regexp, but not today...\n        if (/[^gim]/.test(valueSelector.$options)) {\n          throw new Error('Only the i, m, and g regexp options are supported');\n        }\n\n        const source = operand instanceof RegExp ? operand.source : operand;\n        regexp = new RegExp(source, valueSelector.$options);\n      } else if (operand instanceof RegExp) {\n        regexp = operand;\n      } else {\n        regexp = new RegExp(operand);\n      }\n\n      return regexpElementMatcher(regexp);\n    },\n  },\n  $elemMatch: {\n    dontExpandLeafArrays: true,\n    compileElementSelector(operand, valueSelector, matcher) {\n      if (!LocalCollection._isPlainObject(operand)) {\n        throw Error('$elemMatch need an object');\n      }\n\n      const isDocMatcher = !isOperatorObject(\n        Object.keys(operand)\n          .filter(key => !hasOwn.call(LOGICAL_OPERATORS, key))\n          .reduce((a, b) => Object.assign(a, {[b]: operand[b]}), {}),\n        true);\n\n      let subMatcher;\n      if (isDocMatcher) {\n        // This is NOT the same as compileValueSelector(operand), and not just\n        // because of the slightly different calling convention.\n        // {$elemMatch: {x: 3}} means \"an element has a field x:3\", not\n        // \"consists only of a field x:3\". Also, regexps and sub-$ are allowed.\n        subMatcher =\n          compileDocumentSelector(operand, matcher, {inElemMatch: true});\n      } else {\n        subMatcher = compileValueSelector(operand, matcher);\n      }\n\n      return value => {\n        if (!Array.isArray(value)) {\n          return false;\n        }\n\n        for (let i = 0; i < value.length; ++i) {\n          const arrayElement = value[i];\n          let arg;\n          if (isDocMatcher) {\n            // We can only match {$elemMatch: {b: 3}} against objects.\n            // (We can also match against arrays, if there's numeric indices,\n            // eg {$elemMatch: {'0.b': 3}} or {$elemMatch: {0: 3}}.)\n            if (!isIndexable(arrayElement)) {\n              return false;\n            }\n\n            arg = arrayElement;\n          } else {\n            // dontIterate ensures that {a: {$elemMatch: {$gt: 5}}} matches\n            // {a: [8]} but not {a: [[8]]}\n            arg = [{value: arrayElement, dontIterate: true}];\n          }\n          // XXX support $near in $elemMatch by propagating $distance?\n          if (subMatcher(arg).result) {\n            return i; // specially understood to mean \"use as arrayIndices\"\n          }\n        }\n\n        return false;\n      };\n    },\n  },\n};\n\n// Operators that appear at the top level of a document selector.\nconst LOGICAL_OPERATORS = {\n  $and(subSelector, matcher, inElemMatch) {\n    return andDocumentMatchers(\n      compileArrayOfDocumentSelectors(subSelector, matcher, inElemMatch)\n    );\n  },\n\n  $or(subSelector, matcher, inElemMatch) {\n    const matchers = compileArrayOfDocumentSelectors(\n      subSelector,\n      matcher,\n      inElemMatch\n    );\n\n    // Special case: if there is only one matcher, use it directly, *preserving*\n    // any arrayIndices it returns.\n    if (matchers.length === 1) {\n      return matchers[0];\n    }\n\n    return doc => {\n      const result = matchers.some(fn => fn(doc).result);\n      // $or does NOT set arrayIndices when it has multiple\n      // sub-expressions. (Tested against MongoDB.)\n      return {result};\n    };\n  },\n\n  $nor(subSelector, matcher, inElemMatch) {\n    const matchers = compileArrayOfDocumentSelectors(\n      subSelector,\n      matcher,\n      inElemMatch\n    );\n    return doc => {\n      const result = matchers.every(fn => !fn(doc).result);\n      // Never set arrayIndices, because we only match if nothing in particular\n      // 'matched' (and because this is consistent with MongoDB).\n      return {result};\n    };\n  },\n\n  $where(selectorValue, matcher) {\n    // Record that *any* path may be used.\n    matcher._recordPathUsed('');\n    matcher._hasWhere = true;\n\n    if (!(selectorValue instanceof Function)) {\n      // XXX MongoDB seems to have more complex logic to decide where or or not\n      // to add 'return'; not sure exactly what it is.\n      selectorValue = Function('obj', `return ${selectorValue}`);\n    }\n\n    // We make the document available as both `this` and `obj`.\n    // // XXX not sure what we should do if this throws\n    return doc => ({result: selectorValue.call(doc, doc)});\n  },\n\n  // This is just used as a comment in the query (in MongoDB, it also ends up in\n  // query logs); it has no effect on the actual selection.\n  $comment() {\n    return () => ({result: true});\n  },\n};\n\n// Operators that (unlike LOGICAL_OPERATORS) pertain to individual paths in a\n// document, but (unlike ELEMENT_OPERATORS) do not have a simple definition as\n// \"match each branched value independently and combine with\n// convertElementMatcherToBranchedMatcher\".\nconst VALUE_OPERATORS = {\n  $eq(operand) {\n    return convertElementMatcherToBranchedMatcher(\n      equalityElementMatcher(operand)\n    );\n  },\n  $not(operand, valueSelector, matcher) {\n    return invertBranchedMatcher(compileValueSelector(operand, matcher));\n  },\n  $ne(operand) {\n    return invertBranchedMatcher(\n      convertElementMatcherToBranchedMatcher(equalityElementMatcher(operand))\n    );\n  },\n  $nin(operand) {\n    return invertBranchedMatcher(\n      convertElementMatcherToBranchedMatcher(\n        ELEMENT_OPERATORS.$in.compileElementSelector(operand)\n      )\n    );\n  },\n  $exists(operand) {\n    const exists = convertElementMatcherToBranchedMatcher(\n      value => value !== undefined\n    );\n    return operand ? exists : invertBranchedMatcher(exists);\n  },\n  // $options just provides options for $regex; its logic is inside $regex\n  $options(operand, valueSelector) {\n    if (!hasOwn.call(valueSelector, '$regex')) {\n      throw Error('$options needs a $regex');\n    }\n\n    return everythingMatcher;\n  },\n  // $maxDistance is basically an argument to $near\n  $maxDistance(operand, valueSelector) {\n    if (!valueSelector.$near) {\n      throw Error('$maxDistance needs a $near');\n    }\n\n    return everythingMatcher;\n  },\n  $all(operand, valueSelector, matcher) {\n    if (!Array.isArray(operand)) {\n      throw Error('$all requires array');\n    }\n\n    // Not sure why, but this seems to be what MongoDB does.\n    if (operand.length === 0) {\n      return nothingMatcher;\n    }\n\n    const branchedMatchers = operand.map(criterion => {\n      // XXX handle $all/$elemMatch combination\n      if (isOperatorObject(criterion)) {\n        throw Error('no $ expressions in $all');\n      }\n\n      // This is always a regexp or equality selector.\n      return compileValueSelector(criterion, matcher);\n    });\n\n    // andBranchedMatchers does NOT require all selectors to return true on the\n    // SAME branch.\n    return andBranchedMatchers(branchedMatchers);\n  },\n  $near(operand, valueSelector, matcher, isRoot) {\n    if (!isRoot) {\n      throw Error('$near can\\'t be inside another $ operator');\n    }\n\n    matcher._hasGeoQuery = true;\n\n    // There are two kinds of geodata in MongoDB: legacy coordinate pairs and\n    // GeoJSON. They use different distance metrics, too. GeoJSON queries are\n    // marked with a $geometry property, though legacy coordinates can be\n    // matched using $geometry.\n    let maxDistance, point, distance;\n    if (LocalCollection._isPlainObject(operand) && hasOwn.call(operand, '$geometry')) {\n      // GeoJSON \"2dsphere\" mode.\n      maxDistance = operand.$maxDistance;\n      point = operand.$geometry;\n      distance = value => {\n        // XXX: for now, we don't calculate the actual distance between, say,\n        // polygon and circle. If people care about this use-case it will get\n        // a priority.\n        if (!value) {\n          return null;\n        }\n\n        if (!value.type) {\n          return GeoJSON.pointDistance(\n            point,\n            {type: 'Point', coordinates: pointToArray(value)}\n          );\n        }\n\n        if (value.type === 'Point') {\n          return GeoJSON.pointDistance(point, value);\n        }\n\n        return GeoJSON.geometryWithinRadius(value, point, maxDistance)\n          ? 0\n          : maxDistance + 1;\n      };\n    } else {\n      maxDistance = valueSelector.$maxDistance;\n\n      if (!isIndexable(operand)) {\n        throw Error('$near argument must be coordinate pair or GeoJSON');\n      }\n\n      point = pointToArray(operand);\n\n      distance = value => {\n        if (!isIndexable(value)) {\n          return null;\n        }\n\n        return distanceCoordinatePairs(point, value);\n      };\n    }\n\n    return branchedValues => {\n      // There might be multiple points in the document that match the given\n      // field. Only one of them needs to be within $maxDistance, but we need to\n      // evaluate all of them and use the nearest one for the implicit sort\n      // specifier. (That's why we can't just use ELEMENT_OPERATORS here.)\n      //\n      // Note: This differs from MongoDB's implementation, where a document will\n      // actually show up *multiple times* in the result set, with one entry for\n      // each within-$maxDistance branching point.\n      const result = {result: false};\n      expandArraysInBranches(branchedValues).every(branch => {\n        // if operation is an update, don't skip branches, just return the first\n        // one (#3599)\n        let curDistance;\n        if (!matcher._isUpdate) {\n          if (!(typeof branch.value === 'object')) {\n            return true;\n          }\n\n          curDistance = distance(branch.value);\n\n          // Skip branches that aren't real points or are too far away.\n          if (curDistance === null || curDistance > maxDistance) {\n            return true;\n          }\n\n          // Skip anything that's a tie.\n          if (result.distance !== undefined && result.distance <= curDistance) {\n            return true;\n          }\n        }\n\n        result.result = true;\n        result.distance = curDistance;\n\n        if (branch.arrayIndices) {\n          result.arrayIndices = branch.arrayIndices;\n        } else {\n          delete result.arrayIndices;\n        }\n\n        return !matcher._isUpdate;\n      });\n\n      return result;\n    };\n  },\n};\n\n// NB: We are cheating and using this function to implement 'AND' for both\n// 'document matchers' and 'branched matchers'. They both return result objects\n// but the argument is different: for the former it's a whole doc, whereas for\n// the latter it's an array of 'branched values'.\nfunction andSomeMatchers(subMatchers) {\n  if (subMatchers.length === 0) {\n    return everythingMatcher;\n  }\n\n  if (subMatchers.length === 1) {\n    return subMatchers[0];\n  }\n\n  return docOrBranches => {\n    const match = {};\n    match.result = subMatchers.every(fn => {\n      const subResult = fn(docOrBranches);\n\n      // Copy a 'distance' number out of the first sub-matcher that has\n      // one. Yes, this means that if there are multiple $near fields in a\n      // query, something arbitrary happens; this appears to be consistent with\n      // Mongo.\n      if (subResult.result &&\n          subResult.distance !== undefined &&\n          match.distance === undefined) {\n        match.distance = subResult.distance;\n      }\n\n      // Similarly, propagate arrayIndices from sub-matchers... but to match\n      // MongoDB behavior, this time the *last* sub-matcher with arrayIndices\n      // wins.\n      if (subResult.result && subResult.arrayIndices) {\n        match.arrayIndices = subResult.arrayIndices;\n      }\n\n      return subResult.result;\n    });\n\n    // If we didn't actually match, forget any extra metadata we came up with.\n    if (!match.result) {\n      delete match.distance;\n      delete match.arrayIndices;\n    }\n\n    return match;\n  };\n}\n\nconst andDocumentMatchers = andSomeMatchers;\nconst andBranchedMatchers = andSomeMatchers;\n\nfunction compileArrayOfDocumentSelectors(selectors, matcher, inElemMatch) {\n  if (!Array.isArray(selectors) || selectors.length === 0) {\n    throw Error('$and/$or/$nor must be nonempty array');\n  }\n\n  return selectors.map(subSelector => {\n    if (!LocalCollection._isPlainObject(subSelector)) {\n      throw Error('$or/$and/$nor entries need to be full objects');\n    }\n\n    return compileDocumentSelector(subSelector, matcher, {inElemMatch});\n  });\n}\n\n// Takes in a selector that could match a full document (eg, the original\n// selector). Returns a function mapping document->result object.\n//\n// matcher is the Matcher object we are compiling.\n//\n// If this is the root document selector (ie, not wrapped in $and or the like),\n// then isRoot is true. (This is used by $near.)\nexport function compileDocumentSelector(docSelector, matcher, options = {}) {\n  const docMatchers = Object.keys(docSelector).map(key => {\n    const subSelector = docSelector[key];\n\n    if (key.substr(0, 1) === '$') {\n      // Outer operators are either logical operators (they recurse back into\n      // this function), or $where.\n      if (!hasOwn.call(LOGICAL_OPERATORS, key)) {\n        throw new Error(`Unrecognized logical operator: ${key}`);\n      }\n\n      matcher._isSimple = false;\n      return LOGICAL_OPERATORS[key](subSelector, matcher, options.inElemMatch);\n    }\n\n    // Record this path, but only if we aren't in an elemMatcher, since in an\n    // elemMatch this is a path inside an object in an array, not in the doc\n    // root.\n    if (!options.inElemMatch) {\n      matcher._recordPathUsed(key);\n    }\n\n    // Don't add a matcher if subSelector is a function -- this is to match\n    // the behavior of Meteor on the server (inherited from the node mongodb\n    // driver), which is to ignore any part of a selector which is a function.\n    if (typeof subSelector === 'function') {\n      return undefined;\n    }\n\n    const lookUpByIndex = makeLookupFunction(key);\n    const valueMatcher = compileValueSelector(\n      subSelector,\n      matcher,\n      options.isRoot\n    );\n\n    return doc => valueMatcher(lookUpByIndex(doc));\n  }).filter(Boolean);\n\n  return andDocumentMatchers(docMatchers);\n}\n\n// Takes in a selector that could match a key-indexed value in a document; eg,\n// {$gt: 5, $lt: 9}, or a regular expression, or any non-expression object (to\n// indicate equality).  Returns a branched matcher: a function mapping\n// [branched value]->result object.\nfunction compileValueSelector(valueSelector, matcher, isRoot) {\n  if (valueSelector instanceof RegExp) {\n    matcher._isSimple = false;\n    return convertElementMatcherToBranchedMatcher(\n      regexpElementMatcher(valueSelector)\n    );\n  }\n\n  if (isOperatorObject(valueSelector)) {\n    return operatorBranchedMatcher(valueSelector, matcher, isRoot);\n  }\n\n  return convertElementMatcherToBranchedMatcher(\n    equalityElementMatcher(valueSelector)\n  );\n}\n\n// Given an element matcher (which evaluates a single value), returns a branched\n// value (which evaluates the element matcher on all the branches and returns a\n// more structured return value possibly including arrayIndices).\nfunction convertElementMatcherToBranchedMatcher(elementMatcher, options = {}) {\n  return branches => {\n    const expanded = options.dontExpandLeafArrays\n      ? branches\n      : expandArraysInBranches(branches, options.dontIncludeLeafArrays);\n\n    const match = {};\n    match.result = expanded.some(element => {\n      let matched = elementMatcher(element.value);\n\n      // Special case for $elemMatch: it means \"true, and use this as an array\n      // index if I didn't already have one\".\n      if (typeof matched === 'number') {\n        // XXX This code dates from when we only stored a single array index\n        // (for the outermost array). Should we be also including deeper array\n        // indices from the $elemMatch match?\n        if (!element.arrayIndices) {\n          element.arrayIndices = [matched];\n        }\n\n        matched = true;\n      }\n\n      // If some element matched, and it's tagged with array indices, include\n      // those indices in our result object.\n      if (matched && element.arrayIndices) {\n        match.arrayIndices = element.arrayIndices;\n      }\n\n      return matched;\n    });\n\n    return match;\n  };\n}\n\n// Helpers for $near.\nfunction distanceCoordinatePairs(a, b) {\n  const pointA = pointToArray(a);\n  const pointB = pointToArray(b);\n\n  return Math.hypot(pointA[0] - pointB[0], pointA[1] - pointB[1]);\n}\n\n// Takes something that is not an operator object and returns an element matcher\n// for equality with that thing.\nexport function equalityElementMatcher(elementSelector) {\n  if (isOperatorObject(elementSelector)) {\n    throw Error('Can\\'t create equalityValueSelector for operator object');\n  }\n\n  // Special-case: null and undefined are equal (if you got undefined in there\n  // somewhere, or if you got it due to some branch being non-existent in the\n  // weird special case), even though they aren't with EJSON.equals.\n  // undefined or null\n  if (elementSelector == null) {\n    return value => value == null;\n  }\n\n  return value => LocalCollection._f._equal(elementSelector, value);\n}\n\nfunction everythingMatcher(docOrBranchedValues) {\n  return {result: true};\n}\n\nexport function expandArraysInBranches(branches, skipTheArrays) {\n  const branchesOut = [];\n\n  branches.forEach(branch => {\n    const thisIsArray = Array.isArray(branch.value);\n\n    // We include the branch itself, *UNLESS* we it's an array that we're going\n    // to iterate and we're told to skip arrays.  (That's right, we include some\n    // arrays even skipTheArrays is true: these are arrays that were found via\n    // explicit numerical indices.)\n    if (!(skipTheArrays && thisIsArray && !branch.dontIterate)) {\n      branchesOut.push({arrayIndices: branch.arrayIndices, value: branch.value});\n    }\n\n    if (thisIsArray && !branch.dontIterate) {\n      branch.value.forEach((value, i) => {\n        branchesOut.push({\n          arrayIndices: (branch.arrayIndices || []).concat(i),\n          value\n        });\n      });\n    }\n  });\n\n  return branchesOut;\n}\n\n// Helpers for $bitsAllSet/$bitsAnySet/$bitsAllClear/$bitsAnyClear.\nfunction getOperandBitmask(operand, selector) {\n  // numeric bitmask\n  // You can provide a numeric bitmask to be matched against the operand field.\n  // It must be representable as a non-negative 32-bit signed integer.\n  // Otherwise, $bitsAllSet will return an error.\n  if (Number.isInteger(operand) && operand >= 0) {\n    return new Uint8Array(new Int32Array([operand]).buffer);\n  }\n\n  // bindata bitmask\n  // You can also use an arbitrarily large BinData instance as a bitmask.\n  if (EJSON.isBinary(operand)) {\n    return new Uint8Array(operand.buffer);\n  }\n\n  // position list\n  // If querying a list of bit positions, each <position> must be a non-negative\n  // integer. Bit positions start at 0 from the least significant bit.\n  if (Array.isArray(operand) &&\n      operand.every(x => Number.isInteger(x) && x >= 0)) {\n    const buffer = new ArrayBuffer((Math.max(...operand) >> 3) + 1);\n    const view = new Uint8Array(buffer);\n\n    operand.forEach(x => {\n      view[x >> 3] |= 1 << (x & 0x7);\n    });\n\n    return view;\n  }\n\n  // bad operand\n  throw Error(\n    `operand to ${selector} must be a numeric bitmask (representable as a ` +\n    'non-negative 32-bit signed integer), a bindata bitmask or an array with ' +\n    'bit positions (non-negative integers)'\n  );\n}\n\nfunction getValueBitmask(value, length) {\n  // The field value must be either numerical or a BinData instance. Otherwise,\n  // $bits... will not match the current document.\n\n  // numerical\n  if (Number.isSafeInteger(value)) {\n    // $bits... will not match numerical values that cannot be represented as a\n    // signed 64-bit integer. This can be the case if a value is either too\n    // large or small to fit in a signed 64-bit integer, or if it has a\n    // fractional component.\n    const buffer = new ArrayBuffer(\n      Math.max(length, 2 * Uint32Array.BYTES_PER_ELEMENT)\n    );\n\n    let view = new Uint32Array(buffer, 0, 2);\n    view[0] = value % ((1 << 16) * (1 << 16)) | 0;\n    view[1] = value / ((1 << 16) * (1 << 16)) | 0;\n\n    // sign extension\n    if (value < 0) {\n      view = new Uint8Array(buffer, 2);\n      view.forEach((byte, i) => {\n        view[i] = 0xff;\n      });\n    }\n\n    return new Uint8Array(buffer);\n  }\n\n  // bindata\n  if (EJSON.isBinary(value)) {\n    return new Uint8Array(value.buffer);\n  }\n\n  // no match\n  return false;\n}\n\n// Actually inserts a key value into the selector document\n// However, this checks there is no ambiguity in setting\n// the value for the given key, throws otherwise\nfunction insertIntoDocument(document, key, value) {\n  Object.keys(document).forEach(existingKey => {\n    if (\n      (existingKey.length > key.length && existingKey.indexOf(`${key}.`) === 0) ||\n      (key.length > existingKey.length && key.indexOf(`${existingKey}.`) === 0)\n    ) {\n      throw new Error(\n        `cannot infer query fields to set, both paths '${existingKey}' and ` +\n        `'${key}' are matched`\n      );\n    } else if (existingKey === key) {\n      throw new Error(\n        `cannot infer query fields to set, path '${key}' is matched twice`\n      );\n    }\n  });\n\n  document[key] = value;\n}\n\n// Returns a branched matcher that matches iff the given matcher does not.\n// Note that this implicitly \"deMorganizes\" the wrapped function.  ie, it\n// means that ALL branch values need to fail to match innerBranchedMatcher.\nfunction invertBranchedMatcher(branchedMatcher) {\n  return branchValues => {\n    // We explicitly choose to strip arrayIndices here: it doesn't make sense to\n    // say \"update the array element that does not match something\", at least\n    // in mongo-land.\n    return {result: !branchedMatcher(branchValues).result};\n  };\n}\n\nexport function isIndexable(obj) {\n  return Array.isArray(obj) || LocalCollection._isPlainObject(obj);\n}\n\nexport function isNumericKey(s) {\n  return /^[0-9]+$/.test(s);\n}\n\n// Returns true if this is an object with at least one key and all keys begin\n// with $.  Unless inconsistentOK is set, throws if some keys begin with $ and\n// others don't.\nexport function isOperatorObject(valueSelector, inconsistentOK) {\n  if (!LocalCollection._isPlainObject(valueSelector)) {\n    return false;\n  }\n\n  let theseAreOperators = undefined;\n  Object.keys(valueSelector).forEach(selKey => {\n    const thisIsOperator = selKey.substr(0, 1) === '$';\n\n    if (theseAreOperators === undefined) {\n      theseAreOperators = thisIsOperator;\n    } else if (theseAreOperators !== thisIsOperator) {\n      if (!inconsistentOK) {\n        throw new Error(\n          `Inconsistent operator: ${JSON.stringify(valueSelector)}`\n        );\n      }\n\n      theseAreOperators = false;\n    }\n  });\n\n  return !!theseAreOperators; // {} has no operators\n}\n\n// Helper for $lt/$gt/$lte/$gte.\nfunction makeInequality(cmpValueComparator) {\n  return {\n    compileElementSelector(operand) {\n      // Arrays never compare false with non-arrays for any inequality.\n      // XXX This was behavior we observed in pre-release MongoDB 2.5, but\n      //     it seems to have been reverted.\n      //     See https://jira.mongodb.org/browse/SERVER-11444\n      if (Array.isArray(operand)) {\n        return () => false;\n      }\n\n      // Special case: consider undefined and null the same (so true with\n      // $gte/$lte).\n      if (operand === undefined) {\n        operand = null;\n      }\n\n      const operandType = LocalCollection._f._type(operand);\n\n      return value => {\n        if (value === undefined) {\n          value = null;\n        }\n\n        // Comparisons are never true among things of different type (except\n        // null vs undefined).\n        if (LocalCollection._f._type(value) !== operandType) {\n          return false;\n        }\n\n        return cmpValueComparator(LocalCollection._f._cmp(value, operand));\n      };\n    },\n  };\n}\n\n// makeLookupFunction(key) returns a lookup function.\n//\n// A lookup function takes in a document and returns an array of matching\n// branches.  If no arrays are found while looking up the key, this array will\n// have exactly one branches (possibly 'undefined', if some segment of the key\n// was not found).\n//\n// If arrays are found in the middle, this can have more than one element, since\n// we 'branch'. When we 'branch', if there are more key segments to look up,\n// then we only pursue branches that are plain objects (not arrays or scalars).\n// This means we can actually end up with no branches!\n//\n// We do *NOT* branch on arrays that are found at the end (ie, at the last\n// dotted member of the key). We just return that array; if you want to\n// effectively 'branch' over the array's values, post-process the lookup\n// function with expandArraysInBranches.\n//\n// Each branch is an object with keys:\n//  - value: the value at the branch\n//  - dontIterate: an optional bool; if true, it means that 'value' is an array\n//    that expandArraysInBranches should NOT expand. This specifically happens\n//    when there is a numeric index in the key, and ensures the\n//    perhaps-surprising MongoDB behavior where {'a.0': 5} does NOT\n//    match {a: [[5]]}.\n//  - arrayIndices: if any array indexing was done during lookup (either due to\n//    explicit numeric indices or implicit branching), this will be an array of\n//    the array indices used, from outermost to innermost; it is falsey or\n//    absent if no array index is used. If an explicit numeric index is used,\n//    the index will be followed in arrayIndices by the string 'x'.\n//\n//    Note: arrayIndices is used for two purposes. First, it is used to\n//    implement the '$' modifier feature, which only ever looks at its first\n//    element.\n//\n//    Second, it is used for sort key generation, which needs to be able to tell\n//    the difference between different paths. Moreover, it needs to\n//    differentiate between explicit and implicit branching, which is why\n//    there's the somewhat hacky 'x' entry: this means that explicit and\n//    implicit array lookups will have different full arrayIndices paths. (That\n//    code only requires that different paths have different arrayIndices; it\n//    doesn't actually 'parse' arrayIndices. As an alternative, arrayIndices\n//    could contain objects with flags like 'implicit', but I think that only\n//    makes the code surrounding them more complex.)\n//\n//    (By the way, this field ends up getting passed around a lot without\n//    cloning, so never mutate any arrayIndices field/var in this package!)\n//\n//\n// At the top level, you may only pass in a plain object or array.\n//\n// See the test 'minimongo - lookup' for some examples of what lookup functions\n// return.\nexport function makeLookupFunction(key, options = {}) {\n  const parts = key.split('.');\n  const firstPart = parts.length ? parts[0] : '';\n  const lookupRest = (\n    parts.length > 1 &&\n    makeLookupFunction(parts.slice(1).join('.'), options)\n  );\n\n  const omitUnnecessaryFields = result => {\n    if (!result.dontIterate) {\n      delete result.dontIterate;\n    }\n\n    if (result.arrayIndices && !result.arrayIndices.length) {\n      delete result.arrayIndices;\n    }\n\n    return result;\n  };\n\n  // Doc will always be a plain object or an array.\n  // apply an explicit numeric index, an array.\n  return (doc, arrayIndices = []) => {\n    if (Array.isArray(doc)) {\n      // If we're being asked to do an invalid lookup into an array (non-integer\n      // or out-of-bounds), return no results (which is different from returning\n      // a single undefined result, in that `null` equality checks won't match).\n      if (!(isNumericKey(firstPart) && firstPart < doc.length)) {\n        return [];\n      }\n\n      // Remember that we used this array index. Include an 'x' to indicate that\n      // the previous index came from being considered as an explicit array\n      // index (not branching).\n      arrayIndices = arrayIndices.concat(+firstPart, 'x');\n    }\n\n    // Do our first lookup.\n    const firstLevel = doc[firstPart];\n\n    // If there is no deeper to dig, return what we found.\n    //\n    // If what we found is an array, most value selectors will choose to treat\n    // the elements of the array as matchable values in their own right, but\n    // that's done outside of the lookup function. (Exceptions to this are $size\n    // and stuff relating to $elemMatch.  eg, {a: {$size: 2}} does not match {a:\n    // [[1, 2]]}.)\n    //\n    // That said, if we just did an *explicit* array lookup (on doc) to find\n    // firstLevel, and firstLevel is an array too, we do NOT want value\n    // selectors to iterate over it.  eg, {'a.0': 5} does not match {a: [[5]]}.\n    // So in that case, we mark the return value as 'don't iterate'.\n    if (!lookupRest) {\n      return [omitUnnecessaryFields({\n        arrayIndices,\n        dontIterate: Array.isArray(doc) && Array.isArray(firstLevel),\n        value: firstLevel\n      })];\n    }\n\n    // We need to dig deeper.  But if we can't, because what we've found is not\n    // an array or plain object, we're done. If we just did a numeric index into\n    // an array, we return nothing here (this is a change in Mongo 2.5 from\n    // Mongo 2.4, where {'a.0.b': null} stopped matching {a: [5]}). Otherwise,\n    // return a single `undefined` (which can, for example, match via equality\n    // with `null`).\n    if (!isIndexable(firstLevel)) {\n      if (Array.isArray(doc)) {\n        return [];\n      }\n\n      return [omitUnnecessaryFields({arrayIndices, value: undefined})];\n    }\n\n    const result = [];\n    const appendToResult = more => {\n      result.push(...more);\n    };\n\n    // Dig deeper: look up the rest of the parts on whatever we've found.\n    // (lookupRest is smart enough to not try to do invalid lookups into\n    // firstLevel if it's an array.)\n    appendToResult(lookupRest(firstLevel, arrayIndices));\n\n    // If we found an array, then in *addition* to potentially treating the next\n    // part as a literal integer lookup, we should also 'branch': try to look up\n    // the rest of the parts on each array element in parallel.\n    //\n    // In this case, we *only* dig deeper into array elements that are plain\n    // objects. (Recall that we only got this far if we have further to dig.)\n    // This makes sense: we certainly don't dig deeper into non-indexable\n    // objects. And it would be weird to dig into an array: it's simpler to have\n    // a rule that explicit integer indexes only apply to an outer array, not to\n    // an array you find after a branching search.\n    //\n    // In the special case of a numeric part in a *sort selector* (not a query\n    // selector), we skip the branching: we ONLY allow the numeric part to mean\n    // 'look up this index' in that case, not 'also look up this index in all\n    // the elements of the array'.\n    if (Array.isArray(firstLevel) &&\n        !(isNumericKey(parts[1]) && options.forSort)) {\n      firstLevel.forEach((branch, arrayIndex) => {\n        if (LocalCollection._isPlainObject(branch)) {\n          appendToResult(lookupRest(branch, arrayIndices.concat(arrayIndex)));\n        }\n      });\n    }\n\n    return result;\n  };\n}\n\n// Object exported only for unit testing.\n// Use it to export private functions to test in Tinytest.\nMinimongoTest = {makeLookupFunction};\nMinimongoError = (message, options = {}) => {\n  if (typeof message === 'string' && options.field) {\n    message += ` for field '${options.field}'`;\n  }\n\n  const error = new Error(message);\n  error.name = 'MinimongoError';\n  return error;\n};\n\nexport function nothingMatcher(docOrBranchedValues) {\n  return {result: false};\n}\n\n// Takes an operator object (an object with $ keys) and returns a branched\n// matcher for it.\nfunction operatorBranchedMatcher(valueSelector, matcher, isRoot) {\n  // Each valueSelector works separately on the various branches.  So one\n  // operator can match one branch and another can match another branch.  This\n  // is OK.\n  const operatorMatchers = Object.keys(valueSelector).map(operator => {\n    const operand = valueSelector[operator];\n\n    const simpleRange = (\n      ['$lt', '$lte', '$gt', '$gte'].includes(operator) &&\n      typeof operand === 'number'\n    );\n\n    const simpleEquality = (\n      ['$ne', '$eq'].includes(operator) &&\n      operand !== Object(operand)\n    );\n\n    const simpleInclusion = (\n      ['$in', '$nin'].includes(operator)\n      && Array.isArray(operand)\n      && !operand.some(x => x === Object(x))\n    );\n\n    if (!(simpleRange || simpleInclusion || simpleEquality)) {\n      matcher._isSimple = false;\n    }\n\n    if (hasOwn.call(VALUE_OPERATORS, operator)) {\n      return VALUE_OPERATORS[operator](operand, valueSelector, matcher, isRoot);\n    }\n\n    if (hasOwn.call(ELEMENT_OPERATORS, operator)) {\n      const options = ELEMENT_OPERATORS[operator];\n      return convertElementMatcherToBranchedMatcher(\n        options.compileElementSelector(operand, valueSelector, matcher),\n        options\n      );\n    }\n\n    throw new Error(`Unrecognized operator: ${operator}`);\n  });\n\n  return andBranchedMatchers(operatorMatchers);\n}\n\n// paths - Array: list of mongo style paths\n// newLeafFn - Function: of form function(path) should return a scalar value to\n//                       put into list created for that path\n// conflictFn - Function: of form function(node, path, fullPath) is called\n//                        when building a tree path for 'fullPath' node on\n//                        'path' was already a leaf with a value. Must return a\n//                        conflict resolution.\n// initial tree - Optional Object: starting tree.\n// @returns - Object: tree represented as a set of nested objects\nexport function pathsToTree(paths, newLeafFn, conflictFn, root = {}) {\n  paths.forEach(path => {\n    const pathArray = path.split('.');\n    let tree = root;\n\n    // use .every just for iteration with break\n    const success = pathArray.slice(0, -1).every((key, i) => {\n      if (!hasOwn.call(tree, key)) {\n        tree[key] = {};\n      } else if (tree[key] !== Object(tree[key])) {\n        tree[key] = conflictFn(\n          tree[key],\n          pathArray.slice(0, i + 1).join('.'),\n          path\n        );\n\n        // break out of loop if we are failing for this path\n        if (tree[key] !== Object(tree[key])) {\n          return false;\n        }\n      }\n\n      tree = tree[key];\n\n      return true;\n    });\n\n    if (success) {\n      const lastKey = pathArray[pathArray.length - 1];\n      if (hasOwn.call(tree, lastKey)) {\n        tree[lastKey] = conflictFn(tree[lastKey], path, path);\n      } else {\n        tree[lastKey] = newLeafFn(path);\n      }\n    }\n  });\n\n  return root;\n}\n\n// Makes sure we get 2 elements array and assume the first one to be x and\n// the second one to y no matter what user passes.\n// In case user passes { lon: x, lat: y } returns [x, y]\nfunction pointToArray(point) {\n  return Array.isArray(point) ? point.slice() : [point.x, point.y];\n}\n\n// Creating a document from an upsert is quite tricky.\n// E.g. this selector: {\"$or\": [{\"b.foo\": {\"$all\": [\"bar\"]}}]}, should result\n// in: {\"b.foo\": \"bar\"}\n// But this selector: {\"$or\": [{\"b\": {\"foo\": {\"$all\": [\"bar\"]}}}]} should throw\n// an error\n\n// Some rules (found mainly with trial & error, so there might be more):\n// - handle all childs of $and (or implicit $and)\n// - handle $or nodes with exactly 1 child\n// - ignore $or nodes with more than 1 child\n// - ignore $nor and $not nodes\n// - throw when a value can not be set unambiguously\n// - every value for $all should be dealt with as separate $eq-s\n// - threat all children of $all as $eq setters (=> set if $all.length === 1,\n//   otherwise throw error)\n// - you can not mix '$'-prefixed keys and non-'$'-prefixed keys\n// - you can only have dotted keys on a root-level\n// - you can not have '$'-prefixed keys more than one-level deep in an object\n\n// Handles one key/value pair to put in the selector document\nfunction populateDocumentWithKeyValue(document, key, value) {\n  if (value && Object.getPrototypeOf(value) === Object.prototype) {\n    populateDocumentWithObject(document, key, value);\n  } else if (!(value instanceof RegExp)) {\n    insertIntoDocument(document, key, value);\n  }\n}\n\n// Handles a key, value pair to put in the selector document\n// if the value is an object\nfunction populateDocumentWithObject(document, key, value) {\n  const keys = Object.keys(value);\n  const unprefixedKeys = keys.filter(op => op[0] !== '$');\n\n  if (unprefixedKeys.length > 0 || !keys.length) {\n    // Literal (possibly empty) object ( or empty object )\n    // Don't allow mixing '$'-prefixed with non-'$'-prefixed fields\n    if (keys.length !== unprefixedKeys.length) {\n      throw new Error(`unknown operator: ${unprefixedKeys[0]}`);\n    }\n\n    validateObject(value, key);\n    insertIntoDocument(document, key, value);\n  } else {\n    Object.keys(value).forEach(op => {\n      const object = value[op];\n\n      if (op === '$eq') {\n        populateDocumentWithKeyValue(document, key, object);\n      } else if (op === '$all') {\n        // every value for $all should be dealt with as separate $eq-s\n        object.forEach(element =>\n          populateDocumentWithKeyValue(document, key, element)\n        );\n      }\n    });\n  }\n}\n\n// Fills a document with certain fields from an upsert selector\nexport function populateDocumentWithQueryFields(query, document = {}) {\n  if (Object.getPrototypeOf(query) === Object.prototype) {\n    // handle implicit $and\n    Object.keys(query).forEach(key => {\n      const value = query[key];\n\n      if (key === '$and') {\n        // handle explicit $and\n        value.forEach(element =>\n          populateDocumentWithQueryFields(element, document)\n        );\n      } else if (key === '$or') {\n        // handle $or nodes with exactly 1 child\n        if (value.length === 1) {\n          populateDocumentWithQueryFields(value[0], document);\n        }\n      } else if (key[0] !== '$') {\n        // Ignore other '$'-prefixed logical selectors\n        populateDocumentWithKeyValue(document, key, value);\n      }\n    });\n  } else {\n    // Handle meteor-specific shortcut for selecting _id\n    if (LocalCollection._selectorIsId(query)) {\n      insertIntoDocument(document, '_id', query);\n    }\n  }\n\n  return document;\n}\n\n// Traverses the keys of passed projection and constructs a tree where all\n// leaves are either all True or all False\n// @returns Object:\n//  - tree - Object - tree representation of keys involved in projection\n//  (exception for '_id' as it is a special case handled separately)\n//  - including - Boolean - \"take only certain fields\" type of projection\nexport function projectionDetails(fields) {\n  // Find the non-_id keys (_id is handled specially because it is included\n  // unless explicitly excluded). Sort the keys, so that our code to detect\n  // overlaps like 'foo' and 'foo.bar' can assume that 'foo' comes first.\n  let fieldsKeys = Object.keys(fields).sort();\n\n  // If _id is the only field in the projection, do not remove it, since it is\n  // required to determine if this is an exclusion or exclusion. Also keep an\n  // inclusive _id, since inclusive _id follows the normal rules about mixing\n  // inclusive and exclusive fields. If _id is not the only field in the\n  // projection and is exclusive, remove it so it can be handled later by a\n  // special case, since exclusive _id is always allowed.\n  if (!(fieldsKeys.length === 1 && fieldsKeys[0] === '_id') &&\n      !(fieldsKeys.includes('_id') && fields._id)) {\n    fieldsKeys = fieldsKeys.filter(key => key !== '_id');\n  }\n\n  let including = null; // Unknown\n\n  fieldsKeys.forEach(keyPath => {\n    const rule = !!fields[keyPath];\n\n    if (including === null) {\n      including = rule;\n    }\n\n    // This error message is copied from MongoDB shell\n    if (including !== rule) {\n      throw MinimongoError(\n        'You cannot currently mix including and excluding fields.'\n      );\n    }\n  });\n\n  const projectionRulesTree = pathsToTree(\n    fieldsKeys,\n    path => including,\n    (node, path, fullPath) => {\n      // Check passed projection fields' keys: If you have two rules such as\n      // 'foo.bar' and 'foo.bar.baz', then the result becomes ambiguous. If\n      // that happens, there is a probability you are doing something wrong,\n      // framework should notify you about such mistake earlier on cursor\n      // compilation step than later during runtime.  Note, that real mongo\n      // doesn't do anything about it and the later rule appears in projection\n      // project, more priority it takes.\n      //\n      // Example, assume following in mongo shell:\n      // > db.coll.insert({ a: { b: 23, c: 44 } })\n      // > db.coll.find({}, { 'a': 1, 'a.b': 1 })\n      // {\"_id\": ObjectId(\"520bfe456024608e8ef24af3\"), \"a\": {\"b\": 23}}\n      // > db.coll.find({}, { 'a.b': 1, 'a': 1 })\n      // {\"_id\": ObjectId(\"520bfe456024608e8ef24af3\"), \"a\": {\"b\": 23, \"c\": 44}}\n      //\n      // Note, how second time the return set of keys is different.\n      const currentPath = fullPath;\n      const anotherPath = path;\n      throw MinimongoError(\n        `both ${currentPath} and ${anotherPath} found in fields option, ` +\n        'using both of them may trigger unexpected behavior. Did you mean to ' +\n        'use only one of them?'\n      );\n    });\n\n  return {including, tree: projectionRulesTree};\n}\n\n// Takes a RegExp object and returns an element matcher.\nexport function regexpElementMatcher(regexp) {\n  return value => {\n    if (value instanceof RegExp) {\n      return value.toString() === regexp.toString();\n    }\n\n    // Regexps only work against strings.\n    if (typeof value !== 'string') {\n      return false;\n    }\n\n    // Reset regexp's state to avoid inconsistent matching for objects with the\n    // same value on consecutive calls of regexp.test. This happens only if the\n    // regexp has the 'g' flag. Also note that ES6 introduces a new flag 'y' for\n    // which we should *not* change the lastIndex but MongoDB doesn't support\n    // either of these flags.\n    regexp.lastIndex = 0;\n\n    return regexp.test(value);\n  };\n}\n\n// Validates the key in a path.\n// Objects that are nested more then 1 level cannot have dotted fields\n// or fields starting with '$'\nfunction validateKeyInPath(key, path) {\n  if (key.includes('.')) {\n    throw new Error(\n      `The dotted field '${key}' in '${path}.${key} is not valid for storage.`\n    );\n  }\n\n  if (key[0] === '$') {\n    throw new Error(\n      `The dollar ($) prefixed field  '${path}.${key} is not valid for storage.`\n    );\n  }\n}\n\n// Recursively validates an object that is nested more than one level deep\nfunction validateObject(object, path) {\n  if (object && Object.getPrototypeOf(object) === Object.prototype) {\n    Object.keys(object).forEach(key => {\n      validateKeyInPath(key, path);\n      validateObject(object[key], path + '.' + key);\n    });\n  }\n}\n","import LocalCollection from './local_collection.js';\nimport { hasOwn } from './common.js';\n\n// Cursor: a specification for a particular subset of documents, w/ a defined\n// order, limit, and offset.  creating a Cursor with LocalCollection.find(),\nexport default class Cursor {\n  // don't call this ctor directly.  use LocalCollection.find().\n  constructor(collection, selector, options = {}) {\n    this.collection = collection;\n    this.sorter = null;\n    this.matcher = new Minimongo.Matcher(selector);\n\n    if (LocalCollection._selectorIsIdPerhapsAsObject(selector)) {\n      // stash for fast _id and { _id }\n      this._selectorId = hasOwn.call(selector, '_id')\n        ? selector._id\n        : selector;\n    } else {\n      this._selectorId = undefined;\n\n      if (this.matcher.hasGeoQuery() || options.sort) {\n        this.sorter = new Minimongo.Sorter(options.sort || []);\n      }\n    }\n\n    this.skip = options.skip || 0;\n    this.limit = options.limit;\n    this.fields = options.fields;\n\n    this._projectionFn = LocalCollection._compileProjection(this.fields || {});\n\n    this._transform = LocalCollection.wrapTransform(options.transform);\n\n    // by default, queries register w/ Tracker when it is available.\n    if (typeof Tracker !== 'undefined') {\n      this.reactive = options.reactive === undefined ? true : options.reactive;\n    }\n  }\n\n  /**\n   * @summary Returns the number of documents that match a query.\n   * @memberOf Mongo.Cursor\n   * @method  count\n   * @param {boolean} [applySkipLimit=true] If set to `false`, the value\n   *                                         returned will reflect the total\n   *                                         number of matching documents,\n   *                                         ignoring any value supplied for\n   *                                         limit\n   * @instance\n   * @locus Anywhere\n   * @returns {Number}\n   */\n  count(applySkipLimit = true) {\n    if (this.reactive) {\n      // allow the observe to be unordered\n      this._depend({added: true, removed: true}, true);\n    }\n\n    return this._getRawObjects({\n      ordered: true,\n      applySkipLimit\n    }).length;\n  }\n\n  /**\n   * @summary Return all matching documents as an Array.\n   * @memberOf Mongo.Cursor\n   * @method  fetch\n   * @instance\n   * @locus Anywhere\n   * @returns {Object[]}\n   */\n  fetch() {\n    const result = [];\n\n    this.forEach(doc => {\n      result.push(doc);\n    });\n\n    return result;\n  }\n\n  [Symbol.iterator]() {\n    if (this.reactive) {\n      this._depend({\n        addedBefore: true,\n        removed: true,\n        changed: true,\n        movedBefore: true});\n    }\n\n    let index = 0;\n    const objects = this._getRawObjects({ordered: true});\n\n    return {\n      next: () => {\n        if (index < objects.length) {\n          // This doubles as a clone operation.\n          let element = this._projectionFn(objects[index++]);\n\n          if (this._transform)\n            element = this._transform(element);\n\n          return {value: element};\n        }\n\n        return {done: true};\n      }\n    };\n  }\n\n  /**\n   * @callback IterationCallback\n   * @param {Object} doc\n   * @param {Number} index\n   */\n  /**\n   * @summary Call `callback` once for each matching document, sequentially and\n   *          synchronously.\n   * @locus Anywhere\n   * @method  forEach\n   * @instance\n   * @memberOf Mongo.Cursor\n   * @param {IterationCallback} callback Function to call. It will be called\n   *                                     with three arguments: the document, a\n   *                                     0-based index, and <em>cursor</em>\n   *                                     itself.\n   * @param {Any} [thisArg] An object which will be the value of `this` inside\n   *                        `callback`.\n   */\n  forEach(callback, thisArg) {\n    if (this.reactive) {\n      this._depend({\n        addedBefore: true,\n        removed: true,\n        changed: true,\n        movedBefore: true});\n    }\n\n    this._getRawObjects({ordered: true}).forEach((element, i) => {\n      // This doubles as a clone operation.\n      element = this._projectionFn(element);\n\n      if (this._transform) {\n        element = this._transform(element);\n      }\n\n      callback.call(thisArg, element, i, this);\n    });\n  }\n\n  getTransform() {\n    return this._transform;\n  }\n\n  /**\n   * @summary Map callback over all matching documents.  Returns an Array.\n   * @locus Anywhere\n   * @method map\n   * @instance\n   * @memberOf Mongo.Cursor\n   * @param {IterationCallback} callback Function to call. It will be called\n   *                                     with three arguments: the document, a\n   *                                     0-based index, and <em>cursor</em>\n   *                                     itself.\n   * @param {Any} [thisArg] An object which will be the value of `this` inside\n   *                        `callback`.\n   */\n  map(callback, thisArg) {\n    const result = [];\n\n    this.forEach((doc, i) => {\n      result.push(callback.call(thisArg, doc, i, this));\n    });\n\n    return result;\n  }\n\n  // options to contain:\n  //  * callbacks for observe():\n  //    - addedAt (document, atIndex)\n  //    - added (document)\n  //    - changedAt (newDocument, oldDocument, atIndex)\n  //    - changed (newDocument, oldDocument)\n  //    - removedAt (document, atIndex)\n  //    - removed (document)\n  //    - movedTo (document, oldIndex, newIndex)\n  //\n  // attributes available on returned query handle:\n  //  * stop(): end updates\n  //  * collection: the collection this query is querying\n  //\n  // iff x is a returned query handle, (x instanceof\n  // LocalCollection.ObserveHandle) is true\n  //\n  // initial results delivered through added callback\n  // XXX maybe callbacks should take a list of objects, to expose transactions?\n  // XXX maybe support field limiting (to limit what you're notified on)\n\n  /**\n   * @summary Watch a query.  Receive callbacks as the result set changes.\n   * @locus Anywhere\n   * @memberOf Mongo.Cursor\n   * @instance\n   * @param {Object} callbacks Functions to call to deliver the result set as it\n   *                           changes\n   */\n  observe(options) {\n    return LocalCollection._observeFromObserveChanges(this, options);\n  }\n\n  /**\n   * @summary Watch a query. Receive callbacks as the result set changes. Only\n   *          the differences between the old and new documents are passed to\n   *          the callbacks.\n   * @locus Anywhere\n   * @memberOf Mongo.Cursor\n   * @instance\n   * @param {Object} callbacks Functions to call to deliver the result set as it\n   *                           changes\n   */\n  observeChanges(options) {\n    const ordered = LocalCollection._observeChangesCallbacksAreOrdered(options);\n\n    // there are several places that assume you aren't combining skip/limit with\n    // unordered observe.  eg, update's EJSON.clone, and the \"there are several\"\n    // comment in _modifyAndNotify\n    // XXX allow skip/limit with unordered observe\n    if (!options._allow_unordered && !ordered && (this.skip || this.limit)) {\n      throw new Error(\n        \"Must use an ordered observe with skip or limit (i.e. 'addedBefore' \" +\n        \"for observeChanges or 'addedAt' for observe, instead of 'added').\"\n      );\n    }\n\n    if (this.fields && (this.fields._id === 0 || this.fields._id === false)) {\n      throw Error('You may not observe a cursor with {fields: {_id: 0}}');\n    }\n\n    const distances = (\n      this.matcher.hasGeoQuery() &&\n      ordered &&\n      new LocalCollection._IdMap\n    );\n\n    const query = {\n      cursor: this,\n      dirty: false,\n      distances,\n      matcher: this.matcher, // not fast pathed\n      ordered,\n      projectionFn: this._projectionFn,\n      resultsSnapshot: null,\n      sorter: ordered && this.sorter\n    };\n\n    let qid;\n\n    // Non-reactive queries call added[Before] and then never call anything\n    // else.\n    if (this.reactive) {\n      qid = this.collection.next_qid++;\n      this.collection.queries[qid] = query;\n    }\n\n    query.results = this._getRawObjects({ordered, distances: query.distances});\n\n    if (this.collection.paused) {\n      query.resultsSnapshot = ordered ? [] : new LocalCollection._IdMap;\n    }\n\n    // wrap callbacks we were passed. callbacks only fire when not paused and\n    // are never undefined\n    // Filters out blacklisted fields according to cursor's projection.\n    // XXX wrong place for this?\n\n    // furthermore, callbacks enqueue until the operation we're working on is\n    // done.\n    const wrapCallback = fn => {\n      if (!fn) {\n        return () => {};\n      }\n\n      const self = this;\n      return function(/* args*/) {\n        if (self.collection.paused) {\n          return;\n        }\n\n        const args = arguments;\n\n        self.collection._observeQueue.queueTask(() => {\n          fn.apply(this, args);\n        });\n      };\n    };\n\n    query.added = wrapCallback(options.added);\n    query.changed = wrapCallback(options.changed);\n    query.removed = wrapCallback(options.removed);\n\n    if (ordered) {\n      query.addedBefore = wrapCallback(options.addedBefore);\n      query.movedBefore = wrapCallback(options.movedBefore);\n    }\n\n    if (!options._suppress_initial && !this.collection.paused) {\n      query.results.forEach(doc => {\n        const fields = EJSON.clone(doc);\n\n        delete fields._id;\n\n        if (ordered) {\n          query.addedBefore(doc._id, this._projectionFn(fields), null);\n        }\n\n        query.added(doc._id, this._projectionFn(fields));\n      });\n    }\n\n    const handle = Object.assign(new LocalCollection.ObserveHandle, {\n      collection: this.collection,\n      stop: () => {\n        if (this.reactive) {\n          delete this.collection.queries[qid];\n        }\n      }\n    });\n\n    if (this.reactive && Tracker.active) {\n      // XXX in many cases, the same observe will be recreated when\n      // the current autorun is rerun.  we could save work by\n      // letting it linger across rerun and potentially get\n      // repurposed if the same observe is performed, using logic\n      // similar to that of Meteor.subscribe.\n      Tracker.onInvalidate(() => {\n        handle.stop();\n      });\n    }\n\n    // run the observe callbacks resulting from the initial contents\n    // before we leave the observe.\n    this.collection._observeQueue.drain();\n\n    return handle;\n  }\n\n  // Since we don't actually have a \"nextObject\" interface, there's really no\n  // reason to have a \"rewind\" interface.  All it did was make multiple calls\n  // to fetch/map/forEach return nothing the second time.\n  // XXX COMPAT WITH 0.8.1\n  rewind() {}\n\n  // XXX Maybe we need a version of observe that just calls a callback if\n  // anything changed.\n  _depend(changers, _allow_unordered) {\n    if (Tracker.active) {\n      const dependency = new Tracker.Dependency;\n      const notify = dependency.changed.bind(dependency);\n\n      dependency.depend();\n\n      const options = {_allow_unordered, _suppress_initial: true};\n\n      ['added', 'addedBefore', 'changed', 'movedBefore', 'removed']\n        .forEach(fn => {\n          if (changers[fn]) {\n            options[fn] = notify;\n          }\n        });\n\n      // observeChanges will stop() when this computation is invalidated\n      this.observeChanges(options);\n    }\n  }\n\n  _getCollectionName() {\n    return this.collection.name;\n  }\n\n  // Returns a collection of matching objects, but doesn't deep copy them.\n  //\n  // If ordered is set, returns a sorted array, respecting sorter, skip, and\n  // limit properties of the query provided that options.applySkipLimit is\n  // not set to false (#1201). If sorter is falsey, no sort -- you get the\n  // natural order.\n  //\n  // If ordered is not set, returns an object mapping from ID to doc (sorter,\n  // skip and limit should not be set).\n  //\n  // If ordered is set and this cursor is a $near geoquery, then this function\n  // will use an _IdMap to track each distance from the $near argument point in\n  // order to use it as a sort key. If an _IdMap is passed in the 'distances'\n  // argument, this function will clear it and use it for this purpose\n  // (otherwise it will just create its own _IdMap). The observeChanges\n  // implementation uses this to remember the distances after this function\n  // returns.\n  _getRawObjects(options = {}) {\n    // By default this method will respect skip and limit because .fetch(),\n    // .forEach() etc... expect this behaviour. It can be forced to ignore\n    // skip and limit by setting applySkipLimit to false (.count() does this,\n    // for example)\n    const applySkipLimit = options.applySkipLimit !== false;\n\n    // XXX use OrderedDict instead of array, and make IdMap and OrderedDict\n    // compatible\n    const results = options.ordered ? [] : new LocalCollection._IdMap;\n\n    // fast path for single ID value\n    if (this._selectorId !== undefined) {\n      // If you have non-zero skip and ask for a single id, you get nothing.\n      // This is so it matches the behavior of the '{_id: foo}' path.\n      if (applySkipLimit && this.skip) {\n        return results;\n      }\n\n      const selectedDoc = this.collection._docs.get(this._selectorId);\n\n      if (selectedDoc) {\n        if (options.ordered) {\n          results.push(selectedDoc);\n        } else {\n          results.set(this._selectorId, selectedDoc);\n        }\n      }\n\n      return results;\n    }\n\n    // slow path for arbitrary selector, sort, skip, limit\n\n    // in the observeChanges case, distances is actually part of the \"query\"\n    // (ie, live results set) object.  in other cases, distances is only used\n    // inside this function.\n    let distances;\n    if (this.matcher.hasGeoQuery() && options.ordered) {\n      if (options.distances) {\n        distances = options.distances;\n        distances.clear();\n      } else {\n        distances = new LocalCollection._IdMap();\n      }\n    }\n\n    this.collection._docs.forEach((doc, id) => {\n      const matchResult = this.matcher.documentMatches(doc);\n\n      if (matchResult.result) {\n        if (options.ordered) {\n          results.push(doc);\n\n          if (distances && matchResult.distance !== undefined) {\n            distances.set(id, matchResult.distance);\n          }\n        } else {\n          results.set(id, doc);\n        }\n      }\n\n      // Override to ensure all docs are matched if ignoring skip & limit\n      if (!applySkipLimit) {\n        return true;\n      }\n\n      // Fast path for limited unsorted queries.\n      // XXX 'length' check here seems wrong for ordered\n      return (\n        !this.limit ||\n        this.skip ||\n        this.sorter ||\n        results.length !== this.limit\n      );\n    });\n\n    if (!options.ordered) {\n      return results;\n    }\n\n    if (this.sorter) {\n      results.sort(this.sorter.getComparator({distances}));\n    }\n\n    // Return the full set of results if there is no skip or limit or if we're\n    // ignoring them\n    if (!applySkipLimit || (!this.limit && !this.skip)) {\n      return results;\n    }\n\n    return results.slice(\n      this.skip,\n      this.limit ? this.limit + this.skip : results.length\n    );\n  }\n\n  _publishCursor(subscription) {\n    // XXX minimongo should not depend on mongo-livedata!\n    if (!Package.mongo) {\n      throw new Error(\n        'Can\\'t publish from Minimongo without the `mongo` package.'\n      );\n    }\n\n    if (!this.collection.name) {\n      throw new Error(\n        'Can\\'t publish a cursor from a collection without a name.'\n      );\n    }\n\n    return Package.mongo.Mongo.Collection._publishCursor(\n      this,\n      subscription,\n      this.collection.name\n    );\n  }\n}\n","import Cursor from './cursor.js';\nimport ObserveHandle from './observe_handle.js';\nimport {\n  hasOwn,\n  isIndexable,\n  isNumericKey,\n  isOperatorObject,\n  populateDocumentWithQueryFields,\n  projectionDetails,\n} from './common.js';\n\n// XXX type checking on selectors (graceful error if malformed)\n\n// LocalCollection: a set of documents that supports queries and modifiers.\nexport default class LocalCollection {\n  constructor(name) {\n    this.name = name;\n    // _id -> document (also containing id)\n    this._docs = new LocalCollection._IdMap;\n\n    this._observeQueue = new Meteor._SynchronousQueue();\n\n    this.next_qid = 1; // live query id generator\n\n    // qid -> live query object. keys:\n    //  ordered: bool. ordered queries have addedBefore/movedBefore callbacks.\n    //  results: array (ordered) or object (unordered) of current results\n    //    (aliased with this._docs!)\n    //  resultsSnapshot: snapshot of results. null if not paused.\n    //  cursor: Cursor object for the query.\n    //  selector, sorter, (callbacks): functions\n    this.queries = Object.create(null);\n\n    // null if not saving originals; an IdMap from id to original document value\n    // if saving originals. See comments before saveOriginals().\n    this._savedOriginals = null;\n\n    // True when observers are paused and we should not send callbacks.\n    this.paused = false;\n  }\n\n  // options may include sort, skip, limit, reactive\n  // sort may be any of these forms:\n  //     {a: 1, b: -1}\n  //     [[\"a\", \"asc\"], [\"b\", \"desc\"]]\n  //     [\"a\", [\"b\", \"desc\"]]\n  //   (in the first form you're beholden to key enumeration order in\n  //   your javascript VM)\n  //\n  // reactive: if given, and false, don't register with Tracker (default\n  // is true)\n  //\n  // XXX possibly should support retrieving a subset of fields? and\n  // have it be a hint (ignored on the client, when not copying the\n  // doc?)\n  //\n  // XXX sort does not yet support subkeys ('a.b') .. fix that!\n  // XXX add one more sort form: \"key\"\n  // XXX tests\n  find(selector, options) {\n    // default syntax for everything is to omit the selector argument.\n    // but if selector is explicitly passed in as false or undefined, we\n    // want a selector that matches nothing.\n    if (arguments.length === 0) {\n      selector = {};\n    }\n\n    return new LocalCollection.Cursor(this, selector, options);\n  }\n\n  findOne(selector, options = {}) {\n    if (arguments.length === 0) {\n      selector = {};\n    }\n\n    // NOTE: by setting limit 1 here, we end up using very inefficient\n    // code that recomputes the whole query on each update. The upside is\n    // that when you reactively depend on a findOne you only get\n    // invalidated when the found object changes, not any object in the\n    // collection. Most findOne will be by id, which has a fast path, so\n    // this might not be a big deal. In most cases, invalidation causes\n    // the called to re-query anyway, so this should be a net performance\n    // improvement.\n    options.limit = 1;\n\n    return this.find(selector, options).fetch()[0];\n  }\n\n  // XXX possibly enforce that 'undefined' does not appear (we assume\n  // this in our handling of null and $exists)\n  insert(doc, callback) {\n    doc = EJSON.clone(doc);\n\n    assertHasValidFieldNames(doc);\n\n    // if you really want to use ObjectIDs, set this global.\n    // Mongo.Collection specifies its own ids and does not use this code.\n    if (!hasOwn.call(doc, '_id')) {\n      doc._id = LocalCollection._useOID ? new MongoID.ObjectID() : Random.id();\n    }\n\n    const id = doc._id;\n\n    if (this._docs.has(id)) {\n      throw MinimongoError(`Duplicate _id '${id}'`);\n    }\n\n    this._saveOriginal(id, undefined);\n    this._docs.set(id, doc);\n\n    const queriesToRecompute = [];\n\n    // trigger live queries that match\n    Object.keys(this.queries).forEach(qid => {\n      const query = this.queries[qid];\n\n      if (query.dirty) {\n        return;\n      }\n\n      const matchResult = query.matcher.documentMatches(doc);\n\n      if (matchResult.result) {\n        if (query.distances && matchResult.distance !== undefined) {\n          query.distances.set(id, matchResult.distance);\n        }\n\n        if (query.cursor.skip || query.cursor.limit) {\n          queriesToRecompute.push(qid);\n        } else {\n          LocalCollection._insertInResults(query, doc);\n        }\n      }\n    });\n\n    queriesToRecompute.forEach(qid => {\n      if (this.queries[qid]) {\n        this._recomputeResults(this.queries[qid]);\n      }\n    });\n\n    this._observeQueue.drain();\n\n    // Defer because the caller likely doesn't expect the callback to be run\n    // immediately.\n    if (callback) {\n      Meteor.defer(() => {\n        callback(null, id);\n      });\n    }\n\n    return id;\n  }\n\n  // Pause the observers. No callbacks from observers will fire until\n  // 'resumeObservers' is called.\n  pauseObservers() {\n    // No-op if already paused.\n    if (this.paused) {\n      return;\n    }\n\n    // Set the 'paused' flag such that new observer messages don't fire.\n    this.paused = true;\n\n    // Take a snapshot of the query results for each query.\n    Object.keys(this.queries).forEach(qid => {\n      const query = this.queries[qid];\n      query.resultsSnapshot = EJSON.clone(query.results);\n    });\n  }\n\n  remove(selector, callback) {\n    // Easy special case: if we're not calling observeChanges callbacks and\n    // we're not saving originals and we got asked to remove everything, then\n    // just empty everything directly.\n    if (this.paused && !this._savedOriginals && EJSON.equals(selector, {})) {\n      const result = this._docs.size();\n\n      this._docs.clear();\n\n      Object.keys(this.queries).forEach(qid => {\n        const query = this.queries[qid];\n\n        if (query.ordered) {\n          query.results = [];\n        } else {\n          query.results.clear();\n        }\n      });\n\n      if (callback) {\n        Meteor.defer(() => {\n          callback(null, result);\n        });\n      }\n\n      return result;\n    }\n\n    const matcher = new Minimongo.Matcher(selector);\n    const remove = [];\n\n    this._eachPossiblyMatchingDoc(selector, (doc, id) => {\n      if (matcher.documentMatches(doc).result) {\n        remove.push(id);\n      }\n    });\n\n    const queriesToRecompute = [];\n    const queryRemove = [];\n\n    for (let i = 0; i < remove.length; i++) {\n      const removeId = remove[i];\n      const removeDoc = this._docs.get(removeId);\n\n      Object.keys(this.queries).forEach(qid => {\n        const query = this.queries[qid];\n\n        if (query.dirty) {\n          return;\n        }\n\n        if (query.matcher.documentMatches(removeDoc).result) {\n          if (query.cursor.skip || query.cursor.limit) {\n            queriesToRecompute.push(qid);\n          } else {\n            queryRemove.push({qid, doc: removeDoc});\n          }\n        }\n      });\n\n      this._saveOriginal(removeId, removeDoc);\n      this._docs.remove(removeId);\n    }\n\n    // run live query callbacks _after_ we've removed the documents.\n    queryRemove.forEach(remove => {\n      const query = this.queries[remove.qid];\n\n      if (query) {\n        query.distances && query.distances.remove(remove.doc._id);\n        LocalCollection._removeFromResults(query, remove.doc);\n      }\n    });\n\n    queriesToRecompute.forEach(qid => {\n      const query = this.queries[qid];\n\n      if (query) {\n        this._recomputeResults(query);\n      }\n    });\n\n    this._observeQueue.drain();\n\n    const result = remove.length;\n\n    if (callback) {\n      Meteor.defer(() => {\n        callback(null, result);\n      });\n    }\n\n    return result;\n  }\n\n  // Resume the observers. Observers immediately receive change\n  // notifications to bring them to the current state of the\n  // database. Note that this is not just replaying all the changes that\n  // happened during the pause, it is a smarter 'coalesced' diff.\n  resumeObservers() {\n    // No-op if not paused.\n    if (!this.paused) {\n      return;\n    }\n\n    // Unset the 'paused' flag. Make sure to do this first, otherwise\n    // observer methods won't actually fire when we trigger them.\n    this.paused = false;\n\n    Object.keys(this.queries).forEach(qid => {\n      const query = this.queries[qid];\n\n      if (query.dirty) {\n        query.dirty = false;\n\n        // re-compute results will perform `LocalCollection._diffQueryChanges`\n        // automatically.\n        this._recomputeResults(query, query.resultsSnapshot);\n      } else {\n        // Diff the current results against the snapshot and send to observers.\n        // pass the query object for its observer callbacks.\n        LocalCollection._diffQueryChanges(\n          query.ordered,\n          query.resultsSnapshot,\n          query.results,\n          query,\n          {projectionFn: query.projectionFn}\n        );\n      }\n\n      query.resultsSnapshot = null;\n    });\n\n    this._observeQueue.drain();\n  }\n\n  retrieveOriginals() {\n    if (!this._savedOriginals) {\n      throw new Error('Called retrieveOriginals without saveOriginals');\n    }\n\n    const originals = this._savedOriginals;\n\n    this._savedOriginals = null;\n\n    return originals;\n  }\n\n  // To track what documents are affected by a piece of code, call\n  // saveOriginals() before it and retrieveOriginals() after it.\n  // retrieveOriginals returns an object whose keys are the ids of the documents\n  // that were affected since the call to saveOriginals(), and the values are\n  // equal to the document's contents at the time of saveOriginals. (In the case\n  // of an inserted document, undefined is the value.) You must alternate\n  // between calls to saveOriginals() and retrieveOriginals().\n  saveOriginals() {\n    if (this._savedOriginals) {\n      throw new Error('Called saveOriginals twice without retrieveOriginals');\n    }\n\n    this._savedOriginals = new LocalCollection._IdMap;\n  }\n\n  // XXX atomicity: if multi is true, and one modification fails, do\n  // we rollback the whole operation, or what?\n  update(selector, mod, options, callback) {\n    if (! callback && options instanceof Function) {\n      callback = options;\n      options = null;\n    }\n\n    if (!options) {\n      options = {};\n    }\n\n    const matcher = new Minimongo.Matcher(selector, true);\n\n    // Save the original results of any query that we might need to\n    // _recomputeResults on, because _modifyAndNotify will mutate the objects in\n    // it. (We don't need to save the original results of paused queries because\n    // they already have a resultsSnapshot and we won't be diffing in\n    // _recomputeResults.)\n    const qidToOriginalResults = {};\n\n    // We should only clone each document once, even if it appears in multiple\n    // queries\n    const docMap = new LocalCollection._IdMap;\n    const idsMatched = LocalCollection._idsMatchedBySelector(selector);\n\n    Object.keys(this.queries).forEach(qid => {\n      const query = this.queries[qid];\n\n      if ((query.cursor.skip || query.cursor.limit) && ! this.paused) {\n        // Catch the case of a reactive `count()` on a cursor with skip\n        // or limit, which registers an unordered observe. This is a\n        // pretty rare case, so we just clone the entire result set with\n        // no optimizations for documents that appear in these result\n        // sets and other queries.\n        if (query.results instanceof LocalCollection._IdMap) {\n          qidToOriginalResults[qid] = query.results.clone();\n          return;\n        }\n\n        if (!(query.results instanceof Array)) {\n          throw new Error('Assertion failed: query.results not an array');\n        }\n\n        // Clones a document to be stored in `qidToOriginalResults`\n        // because it may be modified before the new and old result sets\n        // are diffed. But if we know exactly which document IDs we're\n        // going to modify, then we only need to clone those.\n        const memoizedCloneIfNeeded = doc => {\n          if (docMap.has(doc._id)) {\n            return docMap.get(doc._id);\n          }\n\n          const docToMemoize = (\n            idsMatched &&\n            !idsMatched.some(id => EJSON.equals(id, doc._id))\n          ) ? doc : EJSON.clone(doc);\n\n          docMap.set(doc._id, docToMemoize);\n\n          return docToMemoize;\n        };\n\n        qidToOriginalResults[qid] = query.results.map(memoizedCloneIfNeeded);\n      }\n    });\n\n    const recomputeQids = {};\n\n    let updateCount = 0;\n\n    this._eachPossiblyMatchingDoc(selector, (doc, id) => {\n      const queryResult = matcher.documentMatches(doc);\n\n      if (queryResult.result) {\n        // XXX Should we save the original even if mod ends up being a no-op?\n        this._saveOriginal(id, doc);\n        this._modifyAndNotify(\n          doc,\n          mod,\n          recomputeQids,\n          queryResult.arrayIndices\n        );\n\n        ++updateCount;\n\n        if (!options.multi) {\n          return false; // break\n        }\n      }\n\n      return true;\n    });\n\n    Object.keys(recomputeQids).forEach(qid => {\n      const query = this.queries[qid];\n\n      if (query) {\n        this._recomputeResults(query, qidToOriginalResults[qid]);\n      }\n    });\n\n    this._observeQueue.drain();\n\n    // If we are doing an upsert, and we didn't modify any documents yet, then\n    // it's time to do an insert. Figure out what document we are inserting, and\n    // generate an id for it.\n    let insertedId;\n    if (updateCount === 0 && options.upsert) {\n      const doc = LocalCollection._createUpsertDocument(selector, mod);\n      if (! doc._id && options.insertedId) {\n        doc._id = options.insertedId;\n      }\n\n      insertedId = this.insert(doc);\n      updateCount = 1;\n    }\n\n    // Return the number of affected documents, or in the upsert case, an object\n    // containing the number of affected docs and the id of the doc that was\n    // inserted, if any.\n    let result;\n    if (options._returnObject) {\n      result = {numberAffected: updateCount};\n\n      if (insertedId !== undefined) {\n        result.insertedId = insertedId;\n      }\n    } else {\n      result = updateCount;\n    }\n\n    if (callback) {\n      Meteor.defer(() => {\n        callback(null, result);\n      });\n    }\n\n    return result;\n  }\n\n  // A convenience wrapper on update. LocalCollection.upsert(sel, mod) is\n  // equivalent to LocalCollection.update(sel, mod, {upsert: true,\n  // _returnObject: true}).\n  upsert(selector, mod, options, callback) {\n    if (!callback && typeof options === 'function') {\n      callback = options;\n      options = {};\n    }\n\n    return this.update(\n      selector,\n      mod,\n      Object.assign({}, options, {upsert: true, _returnObject: true}),\n      callback\n    );\n  }\n\n  // Iterates over a subset of documents that could match selector; calls\n  // fn(doc, id) on each of them.  Specifically, if selector specifies\n  // specific _id's, it only looks at those.  doc is *not* cloned: it is the\n  // same object that is in _docs.\n  _eachPossiblyMatchingDoc(selector, fn) {\n    const specificIds = LocalCollection._idsMatchedBySelector(selector);\n\n    if (specificIds) {\n      specificIds.some(id => {\n        const doc = this._docs.get(id);\n\n        if (doc) {\n          return fn(doc, id) === false;\n        }\n      });\n    } else {\n      this._docs.forEach(fn);\n    }\n  }\n\n  _modifyAndNotify(doc, mod, recomputeQids, arrayIndices) {\n    const matched_before = {};\n\n    Object.keys(this.queries).forEach(qid => {\n      const query = this.queries[qid];\n\n      if (query.dirty) {\n        return;\n      }\n\n      if (query.ordered) {\n        matched_before[qid] = query.matcher.documentMatches(doc).result;\n      } else {\n        // Because we don't support skip or limit (yet) in unordered queries, we\n        // can just do a direct lookup.\n        matched_before[qid] = query.results.has(doc._id);\n      }\n    });\n\n    const old_doc = EJSON.clone(doc);\n\n    LocalCollection._modify(doc, mod, {arrayIndices});\n\n    Object.keys(this.queries).forEach(qid => {\n      const query = this.queries[qid];\n\n      if (query.dirty) {\n        return;\n      }\n\n      const afterMatch = query.matcher.documentMatches(doc);\n      const after = afterMatch.result;\n      const before = matched_before[qid];\n\n      if (after && query.distances && afterMatch.distance !== undefined) {\n        query.distances.set(doc._id, afterMatch.distance);\n      }\n\n      if (query.cursor.skip || query.cursor.limit) {\n        // We need to recompute any query where the doc may have been in the\n        // cursor's window either before or after the update. (Note that if skip\n        // or limit is set, \"before\" and \"after\" being true do not necessarily\n        // mean that the document is in the cursor's output after skip/limit is\n        // applied... but if they are false, then the document definitely is NOT\n        // in the output. So it's safe to skip recompute if neither before or\n        // after are true.)\n        if (before || after) {\n          recomputeQids[qid] = true;\n        }\n      } else if (before && !after) {\n        LocalCollection._removeFromResults(query, doc);\n      } else if (!before && after) {\n        LocalCollection._insertInResults(query, doc);\n      } else if (before && after) {\n        LocalCollection._updateInResults(query, doc, old_doc);\n      }\n    });\n  }\n\n  // Recomputes the results of a query and runs observe callbacks for the\n  // difference between the previous results and the current results (unless\n  // paused). Used for skip/limit queries.\n  //\n  // When this is used by insert or remove, it can just use query.results for\n  // the old results (and there's no need to pass in oldResults), because these\n  // operations don't mutate the documents in the collection. Update needs to\n  // pass in an oldResults which was deep-copied before the modifier was\n  // applied.\n  //\n  // oldResults is guaranteed to be ignored if the query is not paused.\n  _recomputeResults(query, oldResults) {\n    if (this.paused) {\n      // There's no reason to recompute the results now as we're still paused.\n      // By flagging the query as \"dirty\", the recompute will be performed\n      // when resumeObservers is called.\n      query.dirty = true;\n      return;\n    }\n\n    if (!this.paused && !oldResults) {\n      oldResults = query.results;\n    }\n\n    if (query.distances) {\n      query.distances.clear();\n    }\n\n    query.results = query.cursor._getRawObjects({\n      distances: query.distances,\n      ordered: query.ordered\n    });\n\n    if (!this.paused) {\n      LocalCollection._diffQueryChanges(\n        query.ordered,\n        oldResults,\n        query.results,\n        query,\n        {projectionFn: query.projectionFn}\n      );\n    }\n  }\n\n  _saveOriginal(id, doc) {\n    // Are we even trying to save originals?\n    if (!this._savedOriginals) {\n      return;\n    }\n\n    // Have we previously mutated the original (and so 'doc' is not actually\n    // original)?  (Note the 'has' check rather than truth: we store undefined\n    // here for inserted docs!)\n    if (this._savedOriginals.has(id)) {\n      return;\n    }\n\n    this._savedOriginals.set(id, EJSON.clone(doc));\n  }\n}\n\nLocalCollection.Cursor = Cursor;\n\nLocalCollection.ObserveHandle = ObserveHandle;\n\n// XXX maybe move these into another ObserveHelpers package or something\n\n// _CachingChangeObserver is an object which receives observeChanges callbacks\n// and keeps a cache of the current cursor state up to date in this.docs. Users\n// of this class should read the docs field but not modify it. You should pass\n// the \"applyChange\" field as the callbacks to the underlying observeChanges\n// call. Optionally, you can specify your own observeChanges callbacks which are\n// invoked immediately before the docs field is updated; this object is made\n// available as `this` to those callbacks.\nLocalCollection._CachingChangeObserver = class _CachingChangeObserver {\n  constructor(options = {}) {\n    const orderedFromCallbacks = (\n      options.callbacks &&\n      LocalCollection._observeChangesCallbacksAreOrdered(options.callbacks)\n    );\n\n    if (hasOwn.call(options, 'ordered')) {\n      this.ordered = options.ordered;\n\n      if (options.callbacks && options.ordered !== orderedFromCallbacks) {\n        throw Error('ordered option doesn\\'t match callbacks');\n      }\n    } else if (options.callbacks) {\n      this.ordered = orderedFromCallbacks;\n    } else {\n      throw Error('must provide ordered or callbacks');\n    }\n\n    const callbacks = options.callbacks || {};\n\n    if (this.ordered) {\n      this.docs = new OrderedDict(MongoID.idStringify);\n      this.applyChange = {\n        addedBefore: (id, fields, before) => {\n          const doc = EJSON.clone(fields);\n\n          doc._id = id;\n\n          if (callbacks.addedBefore) {\n            callbacks.addedBefore.call(this, id, fields, before);\n          }\n\n          // This line triggers if we provide added with movedBefore.\n          if (callbacks.added) {\n            callbacks.added.call(this, id, fields);\n          }\n\n          // XXX could `before` be a falsy ID?  Technically\n          // idStringify seems to allow for them -- though\n          // OrderedDict won't call stringify on a falsy arg.\n          this.docs.putBefore(id, doc, before || null);\n        },\n        movedBefore: (id, before) => {\n          const doc = this.docs.get(id);\n\n          if (callbacks.movedBefore) {\n            callbacks.movedBefore.call(this, id, before);\n          }\n\n          this.docs.moveBefore(id, before || null);\n        },\n      };\n    } else {\n      this.docs = new LocalCollection._IdMap;\n      this.applyChange = {\n        added: (id, fields) => {\n          const doc = EJSON.clone(fields);\n\n          if (callbacks.added) {\n            callbacks.added.call(this, id, fields);\n          }\n\n          doc._id = id;\n\n          this.docs.set(id,  doc);\n        },\n      };\n    }\n\n    // The methods in _IdMap and OrderedDict used by these callbacks are\n    // identical.\n    this.applyChange.changed = (id, fields) => {\n      const doc = this.docs.get(id);\n\n      if (!doc) {\n        throw new Error(`Unknown id for changed: ${id}`);\n      }\n\n      if (callbacks.changed) {\n        callbacks.changed.call(this, id, EJSON.clone(fields));\n      }\n\n      DiffSequence.applyChanges(doc, fields);\n    };\n\n    this.applyChange.removed = id => {\n      if (callbacks.removed) {\n        callbacks.removed.call(this, id);\n      }\n\n      this.docs.remove(id);\n    };\n  }\n};\n\nLocalCollection._IdMap = class _IdMap extends IdMap {\n  constructor() {\n    super(MongoID.idStringify, MongoID.idParse);\n  }\n};\n\n// Wrap a transform function to return objects that have the _id field\n// of the untransformed document. This ensures that subsystems such as\n// the observe-sequence package that call `observe` can keep track of\n// the documents identities.\n//\n// - Require that it returns objects\n// - If the return value has an _id field, verify that it matches the\n//   original _id field\n// - If the return value doesn't have an _id field, add it back.\nLocalCollection.wrapTransform = transform => {\n  if (!transform) {\n    return null;\n  }\n\n  // No need to doubly-wrap transforms.\n  if (transform.__wrappedTransform__) {\n    return transform;\n  }\n\n  const wrapped = doc => {\n    if (!hasOwn.call(doc, '_id')) {\n      // XXX do we ever have a transform on the oplog's collection? because that\n      // collection has no _id.\n      throw new Error('can only transform documents with _id');\n    }\n\n    const id = doc._id;\n\n    // XXX consider making tracker a weak dependency and checking\n    // Package.tracker here\n    const transformed = Tracker.nonreactive(() => transform(doc));\n\n    if (!LocalCollection._isPlainObject(transformed)) {\n      throw new Error('transform must return object');\n    }\n\n    if (hasOwn.call(transformed, '_id')) {\n      if (!EJSON.equals(transformed._id, id)) {\n        throw new Error('transformed document can\\'t have different _id');\n      }\n    } else {\n      transformed._id = id;\n    }\n\n    return transformed;\n  };\n\n  wrapped.__wrappedTransform__ = true;\n\n  return wrapped;\n};\n\n// XXX the sorted-query logic below is laughably inefficient. we'll\n// need to come up with a better datastructure for this.\n//\n// XXX the logic for observing with a skip or a limit is even more\n// laughably inefficient. we recompute the whole results every time!\n\n// This binary search puts a value between any equal values, and the first\n// lesser value.\nLocalCollection._binarySearch = (cmp, array, value) => {\n  let first = 0;\n  let range = array.length;\n\n  while (range > 0) {\n    const halfRange = Math.floor(range / 2);\n\n    if (cmp(value, array[first + halfRange]) >= 0) {\n      first += halfRange + 1;\n      range -= halfRange + 1;\n    } else {\n      range = halfRange;\n    }\n  }\n\n  return first;\n};\n\nLocalCollection._checkSupportedProjection = fields => {\n  if (fields !== Object(fields) || Array.isArray(fields)) {\n    throw MinimongoError('fields option must be an object');\n  }\n\n  Object.keys(fields).forEach(keyPath => {\n    if (keyPath.split('.').includes('$')) {\n      throw MinimongoError(\n        'Minimongo doesn\\'t support $ operator in projections yet.'\n      );\n    }\n\n    const value = fields[keyPath];\n\n    if (typeof value === 'object' &&\n        ['$elemMatch', '$meta', '$slice'].some(key =>\n          hasOwn.call(value, key)\n        )) {\n      throw MinimongoError(\n        'Minimongo doesn\\'t support operators in projections yet.'\n      );\n    }\n\n    if (![1, 0, true, false].includes(value)) {\n      throw MinimongoError(\n        'Projection values should be one of 1, 0, true, or false'\n      );\n    }\n  });\n};\n\n// Knows how to compile a fields projection to a predicate function.\n// @returns - Function: a closure that filters out an object according to the\n//            fields projection rules:\n//            @param obj - Object: MongoDB-styled document\n//            @returns - Object: a document with the fields filtered out\n//                       according to projection rules. Doesn't retain subfields\n//                       of passed argument.\nLocalCollection._compileProjection = fields => {\n  LocalCollection._checkSupportedProjection(fields);\n\n  const _idProjection = fields._id === undefined ? true : fields._id;\n  const details = projectionDetails(fields);\n\n  // returns transformed doc according to ruleTree\n  const transform = (doc, ruleTree) => {\n    // Special case for \"sets\"\n    if (Array.isArray(doc)) {\n      return doc.map(subdoc => transform(subdoc, ruleTree));\n    }\n\n    const result = details.including ? {} : EJSON.clone(doc);\n\n    Object.keys(ruleTree).forEach(key => {\n      if (!hasOwn.call(doc, key)) {\n        return;\n      }\n\n      const rule = ruleTree[key];\n\n      if (rule === Object(rule)) {\n        // For sub-objects/subsets we branch\n        if (doc[key] === Object(doc[key])) {\n          result[key] = transform(doc[key], rule);\n        }\n      } else if (details.including) {\n        // Otherwise we don't even touch this subfield\n        result[key] = EJSON.clone(doc[key]);\n      } else {\n        delete result[key];\n      }\n    });\n\n    return result;\n  };\n\n  return doc => {\n    const result = transform(doc, details.tree);\n\n    if (_idProjection && hasOwn.call(doc, '_id')) {\n      result._id = doc._id;\n    }\n\n    if (!_idProjection && hasOwn.call(result, '_id')) {\n      delete result._id;\n    }\n\n    return result;\n  };\n};\n\n// Calculates the document to insert in case we're doing an upsert and the\n// selector does not match any elements\nLocalCollection._createUpsertDocument = (selector, modifier) => {\n  const selectorDocument = populateDocumentWithQueryFields(selector);\n  const isModify = LocalCollection._isModificationMod(modifier);\n\n  const newDoc = {};\n\n  if (selectorDocument._id) {\n    newDoc._id = selectorDocument._id;\n    delete selectorDocument._id;\n  }\n\n  // This double _modify call is made to help with nested properties (see issue\n  // #8631). We do this even if it's a replacement for validation purposes (e.g.\n  // ambiguous id's)\n  LocalCollection._modify(newDoc, {$set: selectorDocument});\n  LocalCollection._modify(newDoc, modifier, {isInsert: true});\n\n  if (isModify) {\n    return newDoc;\n  }\n\n  // Replacement can take _id from query document\n  const replacement = Object.assign({}, modifier);\n  if (newDoc._id) {\n    replacement._id = newDoc._id;\n  }\n\n  return replacement;\n};\n\nLocalCollection._diffObjects = (left, right, callbacks) => {\n  return DiffSequence.diffObjects(left, right, callbacks);\n};\n\n// ordered: bool.\n// old_results and new_results: collections of documents.\n//    if ordered, they are arrays.\n//    if unordered, they are IdMaps\nLocalCollection._diffQueryChanges = (ordered, oldResults, newResults, observer, options) =>\n  DiffSequence.diffQueryChanges(ordered, oldResults, newResults, observer, options)\n;\n\nLocalCollection._diffQueryOrderedChanges = (oldResults, newResults, observer, options) =>\n  DiffSequence.diffQueryOrderedChanges(oldResults, newResults, observer, options)\n;\n\nLocalCollection._diffQueryUnorderedChanges = (oldResults, newResults, observer, options) =>\n  DiffSequence.diffQueryUnorderedChanges(oldResults, newResults, observer, options)\n;\n\nLocalCollection._findInOrderedResults = (query, doc) => {\n  if (!query.ordered) {\n    throw new Error('Can\\'t call _findInOrderedResults on unordered query');\n  }\n\n  for (let i = 0; i < query.results.length; i++) {\n    if (query.results[i] === doc) {\n      return i;\n    }\n  }\n\n  throw Error('object missing from query');\n};\n\n// If this is a selector which explicitly constrains the match by ID to a finite\n// number of documents, returns a list of their IDs.  Otherwise returns\n// null. Note that the selector may have other restrictions so it may not even\n// match those document!  We care about $in and $and since those are generated\n// access-controlled update and remove.\nLocalCollection._idsMatchedBySelector = selector => {\n  // Is the selector just an ID?\n  if (LocalCollection._selectorIsId(selector)) {\n    return [selector];\n  }\n\n  if (!selector) {\n    return null;\n  }\n\n  // Do we have an _id clause?\n  if (hasOwn.call(selector, '_id')) {\n    // Is the _id clause just an ID?\n    if (LocalCollection._selectorIsId(selector._id)) {\n      return [selector._id];\n    }\n\n    // Is the _id clause {_id: {$in: [\"x\", \"y\", \"z\"]}}?\n    if (selector._id\n        && Array.isArray(selector._id.$in)\n        && selector._id.$in.length\n        && selector._id.$in.every(LocalCollection._selectorIsId)) {\n      return selector._id.$in;\n    }\n\n    return null;\n  }\n\n  // If this is a top-level $and, and any of the clauses constrain their\n  // documents, then the whole selector is constrained by any one clause's\n  // constraint. (Well, by their intersection, but that seems unlikely.)\n  if (Array.isArray(selector.$and)) {\n    for (let i = 0; i < selector.$and.length; ++i) {\n      const subIds = LocalCollection._idsMatchedBySelector(selector.$and[i]);\n\n      if (subIds) {\n        return subIds;\n      }\n    }\n  }\n\n  return null;\n};\n\nLocalCollection._insertInResults = (query, doc) => {\n  const fields = EJSON.clone(doc);\n\n  delete fields._id;\n\n  if (query.ordered) {\n    if (!query.sorter) {\n      query.addedBefore(doc._id, query.projectionFn(fields), null);\n      query.results.push(doc);\n    } else {\n      const i = LocalCollection._insertInSortedList(\n        query.sorter.getComparator({distances: query.distances}),\n        query.results,\n        doc\n      );\n\n      let next = query.results[i + 1];\n      if (next) {\n        next = next._id;\n      } else {\n        next = null;\n      }\n\n      query.addedBefore(doc._id, query.projectionFn(fields), next);\n    }\n\n    query.added(doc._id, query.projectionFn(fields));\n  } else {\n    query.added(doc._id, query.projectionFn(fields));\n    query.results.set(doc._id, doc);\n  }\n};\n\nLocalCollection._insertInSortedList = (cmp, array, value) => {\n  if (array.length === 0) {\n    array.push(value);\n    return 0;\n  }\n\n  const i = LocalCollection._binarySearch(cmp, array, value);\n\n  array.splice(i, 0, value);\n\n  return i;\n};\n\nLocalCollection._isModificationMod = mod => {\n  let isModify = false;\n  let isReplace = false;\n\n  Object.keys(mod).forEach(key => {\n    if (key.substr(0, 1) === '$') {\n      isModify = true;\n    } else {\n      isReplace = true;\n    }\n  });\n\n  if (isModify && isReplace) {\n    throw new Error(\n      'Update parameter cannot have both modifier and non-modifier fields.'\n    );\n  }\n\n  return isModify;\n};\n\n// XXX maybe this should be EJSON.isObject, though EJSON doesn't know about\n// RegExp\n// XXX note that _type(undefined) === 3!!!!\nLocalCollection._isPlainObject = x => {\n  return x && LocalCollection._f._type(x) === 3;\n};\n\n// XXX need a strategy for passing the binding of $ into this\n// function, from the compiled selector\n//\n// maybe just {key.up.to.just.before.dollarsign: array_index}\n//\n// XXX atomicity: if one modification fails, do we roll back the whole\n// change?\n//\n// options:\n//   - isInsert is set when _modify is being called to compute the document to\n//     insert as part of an upsert operation. We use this primarily to figure\n//     out when to set the fields in $setOnInsert, if present.\nLocalCollection._modify = (doc, modifier, options = {}) => {\n  if (!LocalCollection._isPlainObject(modifier)) {\n    throw MinimongoError('Modifier must be an object');\n  }\n\n  // Make sure the caller can't mutate our data structures.\n  modifier = EJSON.clone(modifier);\n\n  const isModifier = isOperatorObject(modifier);\n  const newDoc = isModifier ? EJSON.clone(doc) : modifier;\n\n  if (isModifier) {\n    // apply modifiers to the doc.\n    Object.keys(modifier).forEach(operator => {\n      // Treat $setOnInsert as $set if this is an insert.\n      const setOnInsert = options.isInsert && operator === '$setOnInsert';\n      const modFunc = MODIFIERS[setOnInsert ? '$set' : operator];\n      const operand = modifier[operator];\n\n      if (!modFunc) {\n        throw MinimongoError(`Invalid modifier specified ${operator}`);\n      }\n\n      Object.keys(operand).forEach(keypath => {\n        const arg = operand[keypath];\n\n        if (keypath === '') {\n          throw MinimongoError('An empty update path is not valid.');\n        }\n\n        const keyparts = keypath.split('.');\n\n        if (!keyparts.every(Boolean)) {\n          throw MinimongoError(\n            `The update path '${keypath}' contains an empty field name, ` +\n            'which is not allowed.'\n          );\n        }\n\n        const target = findModTarget(newDoc, keyparts, {\n          arrayIndices: options.arrayIndices,\n          forbidArray: operator === '$rename',\n          noCreate: NO_CREATE_MODIFIERS[operator]\n        });\n\n        modFunc(target, keyparts.pop(), arg, keypath, newDoc);\n      });\n    });\n\n    if (doc._id && !EJSON.equals(doc._id, newDoc._id)) {\n      throw MinimongoError(\n        `After applying the update to the document {_id: \"${doc._id}\", ...},` +\n        ' the (immutable) field \\'_id\\' was found to have been altered to ' +\n        `_id: \"${newDoc._id}\"`\n      );\n    }\n  } else {\n    if (doc._id && modifier._id && !EJSON.equals(doc._id, modifier._id)) {\n      throw MinimongoError(\n        `The _id field cannot be changed from {_id: \"${doc._id}\"} to ` +\n        `{_id: \"${modifier._id}\"}`\n      );\n    }\n\n    // replace the whole document\n    assertHasValidFieldNames(modifier);\n  }\n\n  // move new document into place.\n  Object.keys(doc).forEach(key => {\n    // Note: this used to be for (var key in doc) however, this does not\n    // work right in Opera. Deleting from a doc while iterating over it\n    // would sometimes cause opera to skip some keys.\n    if (key !== '_id') {\n      delete doc[key];\n    }\n  });\n\n  Object.keys(newDoc).forEach(key => {\n    doc[key] = newDoc[key];\n  });\n};\n\nLocalCollection._observeFromObserveChanges = (cursor, observeCallbacks) => {\n  const transform = cursor.getTransform() || (doc => doc);\n  let suppressed = !!observeCallbacks._suppress_initial;\n\n  let observeChangesCallbacks;\n  if (LocalCollection._observeCallbacksAreOrdered(observeCallbacks)) {\n    // The \"_no_indices\" option sets all index arguments to -1 and skips the\n    // linear scans required to generate them.  This lets observers that don't\n    // need absolute indices benefit from the other features of this API --\n    // relative order, transforms, and applyChanges -- without the speed hit.\n    const indices = !observeCallbacks._no_indices;\n\n    observeChangesCallbacks = {\n      addedBefore(id, fields, before) {\n        if (suppressed || !(observeCallbacks.addedAt || observeCallbacks.added)) {\n          return;\n        }\n\n        const doc = transform(Object.assign(fields, {_id: id}));\n\n        if (observeCallbacks.addedAt) {\n          observeCallbacks.addedAt(\n            doc,\n            indices\n              ? before\n                ? this.docs.indexOf(before)\n                : this.docs.size()\n              : -1,\n            before\n          );\n        } else {\n          observeCallbacks.added(doc);\n        }\n      },\n      changed(id, fields) {\n        if (!(observeCallbacks.changedAt || observeCallbacks.changed)) {\n          return;\n        }\n\n        let doc = EJSON.clone(this.docs.get(id));\n        if (!doc) {\n          throw new Error(`Unknown id for changed: ${id}`);\n        }\n\n        const oldDoc = transform(EJSON.clone(doc));\n\n        DiffSequence.applyChanges(doc, fields);\n\n        if (observeCallbacks.changedAt) {\n          observeCallbacks.changedAt(\n            transform(doc),\n            oldDoc,\n            indices ? this.docs.indexOf(id) : -1\n          );\n        } else {\n          observeCallbacks.changed(transform(doc), oldDoc);\n        }\n      },\n      movedBefore(id, before) {\n        if (!observeCallbacks.movedTo) {\n          return;\n        }\n\n        const from = indices ? this.docs.indexOf(id) : -1;\n        let to = indices\n          ? before\n            ? this.docs.indexOf(before)\n            : this.docs.size()\n          : -1;\n\n        // When not moving backwards, adjust for the fact that removing the\n        // document slides everything back one slot.\n        if (to > from) {\n          --to;\n        }\n\n        observeCallbacks.movedTo(\n          transform(EJSON.clone(this.docs.get(id))),\n          from,\n          to,\n          before || null\n        );\n      },\n      removed(id) {\n        if (!(observeCallbacks.removedAt || observeCallbacks.removed)) {\n          return;\n        }\n\n        // technically maybe there should be an EJSON.clone here, but it's about\n        // to be removed from this.docs!\n        const doc = transform(this.docs.get(id));\n\n        if (observeCallbacks.removedAt) {\n          observeCallbacks.removedAt(doc, indices ? this.docs.indexOf(id) : -1);\n        } else {\n          observeCallbacks.removed(doc);\n        }\n      },\n    };\n  } else {\n    observeChangesCallbacks = {\n      added(id, fields) {\n        if (!suppressed && observeCallbacks.added) {\n          observeCallbacks.added(transform(Object.assign(fields, {_id: id})));\n        }\n      },\n      changed(id, fields) {\n        if (observeCallbacks.changed) {\n          const oldDoc = this.docs.get(id);\n          const doc = EJSON.clone(oldDoc);\n\n          DiffSequence.applyChanges(doc, fields);\n\n          observeCallbacks.changed(\n            transform(doc),\n            transform(EJSON.clone(oldDoc))\n          );\n        }\n      },\n      removed(id) {\n        if (observeCallbacks.removed) {\n          observeCallbacks.removed(transform(this.docs.get(id)));\n        }\n      },\n    };\n  }\n\n  const changeObserver = new LocalCollection._CachingChangeObserver({\n    callbacks: observeChangesCallbacks\n  });\n\n  const handle = cursor.observeChanges(changeObserver.applyChange);\n\n  suppressed = false;\n\n  return handle;\n};\n\nLocalCollection._observeCallbacksAreOrdered = callbacks => {\n  if (callbacks.added && callbacks.addedAt) {\n    throw new Error('Please specify only one of added() and addedAt()');\n  }\n\n  if (callbacks.changed && callbacks.changedAt) {\n    throw new Error('Please specify only one of changed() and changedAt()');\n  }\n\n  if (callbacks.removed && callbacks.removedAt) {\n    throw new Error('Please specify only one of removed() and removedAt()');\n  }\n\n  return !!(\n    callbacks.addedAt ||\n    callbacks.changedAt ||\n    callbacks.movedTo ||\n    callbacks.removedAt\n  );\n};\n\nLocalCollection._observeChangesCallbacksAreOrdered = callbacks => {\n  if (callbacks.added && callbacks.addedBefore) {\n    throw new Error('Please specify only one of added() and addedBefore()');\n  }\n\n  return !!(callbacks.addedBefore || callbacks.movedBefore);\n};\n\nLocalCollection._removeFromResults = (query, doc) => {\n  if (query.ordered) {\n    const i = LocalCollection._findInOrderedResults(query, doc);\n\n    query.removed(doc._id);\n    query.results.splice(i, 1);\n  } else {\n    const id = doc._id;  // in case callback mutates doc\n\n    query.removed(doc._id);\n    query.results.remove(id);\n  }\n};\n\n// Is this selector just shorthand for lookup by _id?\nLocalCollection._selectorIsId = selector =>\n  typeof selector === 'number' ||\n  typeof selector === 'string' ||\n  selector instanceof MongoID.ObjectID\n;\n\n// Is the selector just lookup by _id (shorthand or not)?\nLocalCollection._selectorIsIdPerhapsAsObject = selector =>\n  LocalCollection._selectorIsId(selector) ||\n  LocalCollection._selectorIsId(selector && selector._id) &&\n  Object.keys(selector).length === 1\n;\n\nLocalCollection._updateInResults = (query, doc, old_doc) => {\n  if (!EJSON.equals(doc._id, old_doc._id)) {\n    throw new Error('Can\\'t change a doc\\'s _id while updating');\n  }\n\n  const projectionFn = query.projectionFn;\n  const changedFields = DiffSequence.makeChangedFields(\n    projectionFn(doc),\n    projectionFn(old_doc)\n  );\n\n  if (!query.ordered) {\n    if (Object.keys(changedFields).length) {\n      query.changed(doc._id, changedFields);\n      query.results.set(doc._id, doc);\n    }\n\n    return;\n  }\n\n  const old_idx = LocalCollection._findInOrderedResults(query, doc);\n\n  if (Object.keys(changedFields).length) {\n    query.changed(doc._id, changedFields);\n  }\n\n  if (!query.sorter) {\n    return;\n  }\n\n  // just take it out and put it back in again, and see if the index changes\n  query.results.splice(old_idx, 1);\n\n  const new_idx = LocalCollection._insertInSortedList(\n    query.sorter.getComparator({distances: query.distances}),\n    query.results,\n    doc\n  );\n\n  if (old_idx !== new_idx) {\n    let next = query.results[new_idx + 1];\n    if (next) {\n      next = next._id;\n    } else {\n      next = null;\n    }\n\n    query.movedBefore && query.movedBefore(doc._id, next);\n  }\n};\n\nconst MODIFIERS = {\n  $currentDate(target, field, arg) {\n    if (typeof arg === 'object' && hasOwn.call(arg, '$type')) {\n      if (arg.$type !== 'date') {\n        throw MinimongoError(\n          'Minimongo does currently only support the date type in ' +\n          '$currentDate modifiers',\n          {field}\n        );\n      }\n    } else if (arg !== true) {\n      throw MinimongoError('Invalid $currentDate modifier', {field});\n    }\n\n    target[field] = new Date();\n  },\n  $min(target, field, arg) {\n    if (typeof arg !== 'number') {\n      throw MinimongoError('Modifier $min allowed for numbers only', {field});\n    }\n\n    if (field in target) {\n      if (typeof target[field] !== 'number') {\n        throw MinimongoError(\n          'Cannot apply $min modifier to non-number',\n          {field}\n        );\n      }\n\n      if (target[field] > arg) {\n        target[field] = arg;\n      }\n    } else {\n      target[field] = arg;\n    }\n  },\n  $max(target, field, arg) {\n    if (typeof arg !== 'number') {\n      throw MinimongoError('Modifier $max allowed for numbers only', {field});\n    }\n\n    if (field in target) {\n      if (typeof target[field] !== 'number') {\n        throw MinimongoError(\n          'Cannot apply $max modifier to non-number',\n          {field}\n        );\n      }\n\n      if (target[field] < arg) {\n        target[field] = arg;\n      }\n    } else {\n      target[field] = arg;\n    }\n  },\n  $inc(target, field, arg) {\n    if (typeof arg !== 'number') {\n      throw MinimongoError('Modifier $inc allowed for numbers only', {field});\n    }\n\n    if (field in target) {\n      if (typeof target[field] !== 'number') {\n        throw MinimongoError(\n          'Cannot apply $inc modifier to non-number',\n          {field}\n        );\n      }\n\n      target[field] += arg;\n    } else {\n      target[field] = arg;\n    }\n  },\n  $set(target, field, arg) {\n    if (target !== Object(target)) { // not an array or an object\n      const error = MinimongoError(\n        'Cannot set property on non-object field',\n        {field}\n      );\n      error.setPropertyError = true;\n      throw error;\n    }\n\n    if (target === null) {\n      const error = MinimongoError('Cannot set property on null', {field});\n      error.setPropertyError = true;\n      throw error;\n    }\n\n    assertHasValidFieldNames(arg);\n\n    target[field] = arg;\n  },\n  $setOnInsert(target, field, arg) {\n    // converted to `$set` in `_modify`\n  },\n  $unset(target, field, arg) {\n    if (target !== undefined) {\n      if (target instanceof Array) {\n        if (field in target) {\n          target[field] = null;\n        }\n      } else {\n        delete target[field];\n      }\n    }\n  },\n  $push(target, field, arg) {\n    if (target[field] === undefined) {\n      target[field] = [];\n    }\n\n    if (!(target[field] instanceof Array)) {\n      throw MinimongoError('Cannot apply $push modifier to non-array', {field});\n    }\n\n    if (!(arg && arg.$each)) {\n      // Simple mode: not $each\n      assertHasValidFieldNames(arg);\n\n      target[field].push(arg);\n\n      return;\n    }\n\n    // Fancy mode: $each (and maybe $slice and $sort and $position)\n    const toPush = arg.$each;\n    if (!(toPush instanceof Array)) {\n      throw MinimongoError('$each must be an array', {field});\n    }\n\n    assertHasValidFieldNames(toPush);\n\n    // Parse $position\n    let position = undefined;\n    if ('$position' in arg) {\n      if (typeof arg.$position !== 'number') {\n        throw MinimongoError('$position must be a numeric value', {field});\n      }\n\n      // XXX should check to make sure integer\n      if (arg.$position < 0) {\n        throw MinimongoError(\n          '$position in $push must be zero or positive',\n          {field}\n        );\n      }\n\n      position = arg.$position;\n    }\n\n    // Parse $slice.\n    let slice = undefined;\n    if ('$slice' in arg) {\n      if (typeof arg.$slice !== 'number') {\n        throw MinimongoError('$slice must be a numeric value', {field});\n      }\n\n      // XXX should check to make sure integer\n      slice = arg.$slice;\n    }\n\n    // Parse $sort.\n    let sortFunction = undefined;\n    if (arg.$sort) {\n      if (slice === undefined) {\n        throw MinimongoError('$sort requires $slice to be present', {field});\n      }\n\n      // XXX this allows us to use a $sort whose value is an array, but that's\n      // actually an extension of the Node driver, so it won't work\n      // server-side. Could be confusing!\n      // XXX is it correct that we don't do geo-stuff here?\n      sortFunction = new Minimongo.Sorter(arg.$sort).getComparator();\n\n      toPush.forEach(element => {\n        if (LocalCollection._f._type(element) !== 3) {\n          throw MinimongoError(\n            '$push like modifiers using $sort require all elements to be ' +\n            'objects',\n            {field}\n          );\n        }\n      });\n    }\n\n    // Actually push.\n    if (position === undefined) {\n      toPush.forEach(element => {\n        target[field].push(element);\n      });\n    } else {\n      const spliceArguments = [position, 0];\n\n      toPush.forEach(element => {\n        spliceArguments.push(element);\n      });\n\n      target[field].splice(...spliceArguments);\n    }\n\n    // Actually sort.\n    if (sortFunction) {\n      target[field].sort(sortFunction);\n    }\n\n    // Actually slice.\n    if (slice !== undefined) {\n      if (slice === 0) {\n        target[field] = []; // differs from Array.slice!\n      } else if (slice < 0) {\n        target[field] = target[field].slice(slice);\n      } else {\n        target[field] = target[field].slice(0, slice);\n      }\n    }\n  },\n  $pushAll(target, field, arg) {\n    if (!(typeof arg === 'object' && arg instanceof Array)) {\n      throw MinimongoError('Modifier $pushAll/pullAll allowed for arrays only');\n    }\n\n    assertHasValidFieldNames(arg);\n\n    const toPush = target[field];\n\n    if (toPush === undefined) {\n      target[field] = arg;\n    } else if (!(toPush instanceof Array)) {\n      throw MinimongoError(\n        'Cannot apply $pushAll modifier to non-array',\n        {field}\n      );\n    } else {\n      toPush.push(...arg);\n    }\n  },\n  $addToSet(target, field, arg) {\n    let isEach = false;\n\n    if (typeof arg === 'object') {\n      // check if first key is '$each'\n      const keys = Object.keys(arg);\n      if (keys[0] === '$each') {\n        isEach = true;\n      }\n    }\n\n    const values = isEach ? arg.$each : [arg];\n\n    assertHasValidFieldNames(values);\n\n    const toAdd = target[field];\n    if (toAdd === undefined) {\n      target[field] = values;\n    } else if (!(toAdd instanceof Array)) {\n      throw MinimongoError(\n        'Cannot apply $addToSet modifier to non-array',\n        {field}\n      );\n    } else {\n      values.forEach(value => {\n        if (toAdd.some(element => LocalCollection._f._equal(value, element))) {\n          return;\n        }\n\n        toAdd.push(value);\n      });\n    }\n  },\n  $pop(target, field, arg) {\n    if (target === undefined) {\n      return;\n    }\n\n    const toPop = target[field];\n\n    if (toPop === undefined) {\n      return;\n    }\n\n    if (!(toPop instanceof Array)) {\n      throw MinimongoError('Cannot apply $pop modifier to non-array', {field});\n    }\n\n    if (typeof arg === 'number' && arg < 0) {\n      toPop.splice(0, 1);\n    } else {\n      toPop.pop();\n    }\n  },\n  $pull(target, field, arg) {\n    if (target === undefined) {\n      return;\n    }\n\n    const toPull = target[field];\n    if (toPull === undefined) {\n      return;\n    }\n\n    if (!(toPull instanceof Array)) {\n      throw MinimongoError(\n        'Cannot apply $pull/pullAll modifier to non-array',\n        {field}\n      );\n    }\n\n    let out;\n    if (arg != null && typeof arg === 'object' && !(arg instanceof Array)) {\n      // XXX would be much nicer to compile this once, rather than\n      // for each document we modify.. but usually we're not\n      // modifying that many documents, so we'll let it slide for\n      // now\n\n      // XXX Minimongo.Matcher isn't up for the job, because we need\n      // to permit stuff like {$pull: {a: {$gt: 4}}}.. something\n      // like {$gt: 4} is not normally a complete selector.\n      // same issue as $elemMatch possibly?\n      const matcher = new Minimongo.Matcher(arg);\n\n      out = toPull.filter(element => !matcher.documentMatches(element).result);\n    } else {\n      out = toPull.filter(element => !LocalCollection._f._equal(element, arg));\n    }\n\n    target[field] = out;\n  },\n  $pullAll(target, field, arg) {\n    if (!(typeof arg === 'object' && arg instanceof Array)) {\n      throw MinimongoError(\n        'Modifier $pushAll/pullAll allowed for arrays only',\n        {field}\n      );\n    }\n\n    if (target === undefined) {\n      return;\n    }\n\n    const toPull = target[field];\n\n    if (toPull === undefined) {\n      return;\n    }\n\n    if (!(toPull instanceof Array)) {\n      throw MinimongoError(\n        'Cannot apply $pull/pullAll modifier to non-array',\n        {field}\n      );\n    }\n\n    target[field] = toPull.filter(object =>\n      !arg.some(element => LocalCollection._f._equal(object, element))\n    );\n  },\n  $rename(target, field, arg, keypath, doc) {\n    // no idea why mongo has this restriction..\n    if (keypath === arg) {\n      throw MinimongoError('$rename source must differ from target', {field});\n    }\n\n    if (target === null) {\n      throw MinimongoError('$rename source field invalid', {field});\n    }\n\n    if (typeof arg !== 'string') {\n      throw MinimongoError('$rename target must be a string', {field});\n    }\n\n    if (arg.includes('\\0')) {\n      // Null bytes are not allowed in Mongo field names\n      // https://docs.mongodb.com/manual/reference/limits/#Restrictions-on-Field-Names\n      throw MinimongoError(\n        'The \\'to\\' field for $rename cannot contain an embedded null byte',\n        {field}\n      );\n    }\n\n    if (target === undefined) {\n      return;\n    }\n\n    const object = target[field];\n\n    delete target[field];\n\n    const keyparts = arg.split('.');\n    const target2 = findModTarget(doc, keyparts, {forbidArray: true});\n\n    if (target2 === null) {\n      throw MinimongoError('$rename target field invalid', {field});\n    }\n\n    target2[keyparts.pop()] = object;\n  },\n  $bit(target, field, arg) {\n    // XXX mongo only supports $bit on integers, and we only support\n    // native javascript numbers (doubles) so far, so we can't support $bit\n    throw MinimongoError('$bit is not supported', {field});\n  },\n  $v() {\n    // As discussed in https://github.com/meteor/meteor/issues/9623,\n    // the `$v` operator is not needed by Meteor, but problems can occur if\n    // it's not at least callable (as of Mongo >= 3.6). It's defined here as\n    // a no-op to work around these problems.\n  }\n};\n\nconst NO_CREATE_MODIFIERS = {\n  $pop: true,\n  $pull: true,\n  $pullAll: true,\n  $rename: true,\n  $unset: true\n};\n\n// Make sure field names do not contain Mongo restricted\n// characters ('.', '$', '\\0').\n// https://docs.mongodb.com/manual/reference/limits/#Restrictions-on-Field-Names\nconst invalidCharMsg = {\n  $: 'start with \\'$\\'',\n  '.': 'contain \\'.\\'',\n  '\\0': 'contain null bytes'\n};\n\n// checks if all field names in an object are valid\nfunction assertHasValidFieldNames(doc) {\n  if (doc && typeof doc === 'object') {\n    JSON.stringify(doc, (key, value) => {\n      assertIsValidFieldName(key);\n      return value;\n    });\n  }\n}\n\nfunction assertIsValidFieldName(key) {\n  let match;\n  if (typeof key === 'string' && (match = key.match(/^\\$|\\.|\\0/))) {\n    throw MinimongoError(`Key ${key} must not ${invalidCharMsg[match[0]]}`);\n  }\n}\n\n// for a.b.c.2.d.e, keyparts should be ['a', 'b', 'c', '2', 'd', 'e'],\n// and then you would operate on the 'e' property of the returned\n// object.\n//\n// if options.noCreate is falsey, creates intermediate levels of\n// structure as necessary, like mkdir -p (and raises an exception if\n// that would mean giving a non-numeric property to an array.) if\n// options.noCreate is true, return undefined instead.\n//\n// may modify the last element of keyparts to signal to the caller that it needs\n// to use a different value to index into the returned object (for example,\n// ['a', '01'] -> ['a', 1]).\n//\n// if forbidArray is true, return null if the keypath goes through an array.\n//\n// if options.arrayIndices is set, use its first element for the (first) '$' in\n// the path.\nfunction findModTarget(doc, keyparts, options = {}) {\n  let usedArrayIndex = false;\n\n  for (let i = 0; i < keyparts.length; i++) {\n    const last = i === keyparts.length - 1;\n    let keypart = keyparts[i];\n\n    if (!isIndexable(doc)) {\n      if (options.noCreate) {\n        return undefined;\n      }\n\n      const error = MinimongoError(\n        `cannot use the part '${keypart}' to traverse ${doc}`\n      );\n      error.setPropertyError = true;\n      throw error;\n    }\n\n    if (doc instanceof Array) {\n      if (options.forbidArray) {\n        return null;\n      }\n\n      if (keypart === '$') {\n        if (usedArrayIndex) {\n          throw MinimongoError('Too many positional (i.e. \\'$\\') elements');\n        }\n\n        if (!options.arrayIndices || !options.arrayIndices.length) {\n          throw MinimongoError(\n            'The positional operator did not find the match needed from the ' +\n            'query'\n          );\n        }\n\n        keypart = options.arrayIndices[0];\n        usedArrayIndex = true;\n      } else if (isNumericKey(keypart)) {\n        keypart = parseInt(keypart);\n      } else {\n        if (options.noCreate) {\n          return undefined;\n        }\n\n        throw MinimongoError(\n          `can't append to array using string field name [${keypart}]`\n        );\n      }\n\n      if (last) {\n        keyparts[i] = keypart; // handle 'a.01'\n      }\n\n      if (options.noCreate && keypart >= doc.length) {\n        return undefined;\n      }\n\n      while (doc.length < keypart) {\n        doc.push(null);\n      }\n\n      if (!last) {\n        if (doc.length === keypart) {\n          doc.push({});\n        } else if (typeof doc[keypart] !== 'object') {\n          throw MinimongoError(\n            `can't modify field '${keyparts[i + 1]}' of list value ` +\n            JSON.stringify(doc[keypart])\n          );\n        }\n      }\n    } else {\n      assertIsValidFieldName(keypart);\n\n      if (!(keypart in doc)) {\n        if (options.noCreate) {\n          return undefined;\n        }\n\n        if (!last) {\n          doc[keypart] = {};\n        }\n      }\n    }\n\n    if (last) {\n      return doc;\n    }\n\n    doc = doc[keypart];\n  }\n\n  // notreached\n}\n","import LocalCollection from './local_collection.js';\nimport {\n  compileDocumentSelector,\n  hasOwn,\n  nothingMatcher,\n} from './common.js';\n\n// The minimongo selector compiler!\n\n// Terminology:\n//  - a 'selector' is the EJSON object representing a selector\n//  - a 'matcher' is its compiled form (whether a full Minimongo.Matcher\n//    object or one of the component lambdas that matches parts of it)\n//  - a 'result object' is an object with a 'result' field and maybe\n//    distance and arrayIndices.\n//  - a 'branched value' is an object with a 'value' field and maybe\n//    'dontIterate' and 'arrayIndices'.\n//  - a 'document' is a top-level object that can be stored in a collection.\n//  - a 'lookup function' is a function that takes in a document and returns\n//    an array of 'branched values'.\n//  - a 'branched matcher' maps from an array of branched values to a result\n//    object.\n//  - an 'element matcher' maps from a single value to a bool.\n\n// Main entry point.\n//   var matcher = new Minimongo.Matcher({a: {$gt: 5}});\n//   if (matcher.documentMatches({a: 7})) ...\nexport default class Matcher {\n  constructor(selector, isUpdate) {\n    // A set (object mapping string -> *) of all of the document paths looked\n    // at by the selector. Also includes the empty string if it may look at any\n    // path (eg, $where).\n    this._paths = {};\n    // Set to true if compilation finds a $near.\n    this._hasGeoQuery = false;\n    // Set to true if compilation finds a $where.\n    this._hasWhere = false;\n    // Set to false if compilation finds anything other than a simple equality\n    // or one or more of '$gt', '$gte', '$lt', '$lte', '$ne', '$in', '$nin' used\n    // with scalars as operands.\n    this._isSimple = true;\n    // Set to a dummy document which always matches this Matcher. Or set to null\n    // if such document is too hard to find.\n    this._matchingDocument = undefined;\n    // A clone of the original selector. It may just be a function if the user\n    // passed in a function; otherwise is definitely an object (eg, IDs are\n    // translated into {_id: ID} first. Used by canBecomeTrueByModifier and\n    // Sorter._useWithMatcher.\n    this._selector = null;\n    this._docMatcher = this._compileSelector(selector);\n    // Set to true if selection is done for an update operation\n    // Default is false\n    // Used for $near array update (issue #3599)\n    this._isUpdate = isUpdate;\n  }\n\n  documentMatches(doc) {\n    if (doc !== Object(doc)) {\n      throw Error('documentMatches needs a document');\n    }\n\n    return this._docMatcher(doc);\n  }\n\n  hasGeoQuery() {\n    return this._hasGeoQuery;\n  }\n\n  hasWhere() {\n    return this._hasWhere;\n  }\n\n  isSimple() {\n    return this._isSimple;\n  }\n\n  // Given a selector, return a function that takes one argument, a\n  // document. It returns a result object.\n  _compileSelector(selector) {\n    // you can pass a literal function instead of a selector\n    if (selector instanceof Function) {\n      this._isSimple = false;\n      this._selector = selector;\n      this._recordPathUsed('');\n\n      return doc => ({result: !!selector.call(doc)});\n    }\n\n    // shorthand -- scalar _id\n    if (LocalCollection._selectorIsId(selector)) {\n      this._selector = {_id: selector};\n      this._recordPathUsed('_id');\n\n      return doc => ({result: EJSON.equals(doc._id, selector)});\n    }\n\n    // protect against dangerous selectors.  falsey and {_id: falsey} are both\n    // likely programmer error, and not what you want, particularly for\n    // destructive operations.\n    if (!selector || hasOwn.call(selector, '_id') && !selector._id) {\n      this._isSimple = false;\n      return nothingMatcher;\n    }\n\n    // Top level can't be an array or true or binary.\n    if (Array.isArray(selector) ||\n        EJSON.isBinary(selector) ||\n        typeof selector === 'boolean') {\n      throw new Error(`Invalid selector: ${selector}`);\n    }\n\n    this._selector = EJSON.clone(selector);\n\n    return compileDocumentSelector(selector, this, {isRoot: true});\n  }\n\n  // Returns a list of key paths the given selector is looking for. It includes\n  // the empty string if there is a $where.\n  _getPaths() {\n    return Object.keys(this._paths);\n  }\n\n  _recordPathUsed(path) {\n    this._paths[path] = true;\n  }\n}\n\n// helpers used by compiled selector code\nLocalCollection._f = {\n  // XXX for _all and _in, consider building 'inquery' at compile time..\n  _type(v) {\n    if (typeof v === 'number') {\n      return 1;\n    }\n\n    if (typeof v === 'string') {\n      return 2;\n    }\n\n    if (typeof v === 'boolean') {\n      return 8;\n    }\n\n    if (Array.isArray(v)) {\n      return 4;\n    }\n\n    if (v === null) {\n      return 10;\n    }\n\n    // note that typeof(/x/) === \"object\"\n    if (v instanceof RegExp) {\n      return 11;\n    }\n\n    if (typeof v === 'function') {\n      return 13;\n    }\n\n    if (v instanceof Date) {\n      return 9;\n    }\n\n    if (EJSON.isBinary(v)) {\n      return 5;\n    }\n\n    if (v instanceof MongoID.ObjectID) {\n      return 7;\n    }\n\n    // object\n    return 3;\n\n    // XXX support some/all of these:\n    // 14, symbol\n    // 15, javascript code with scope\n    // 16, 18: 32-bit/64-bit integer\n    // 17, timestamp\n    // 255, minkey\n    // 127, maxkey\n  },\n\n  // deep equality test: use for literal document and array matches\n  _equal(a, b) {\n    return EJSON.equals(a, b, {keyOrderSensitive: true});\n  },\n\n  // maps a type code to a value that can be used to sort values of different\n  // types\n  _typeorder(t) {\n    // http://www.mongodb.org/display/DOCS/What+is+the+Compare+Order+for+BSON+Types\n    // XXX what is the correct sort position for Javascript code?\n    // ('100' in the matrix below)\n    // XXX minkey/maxkey\n    return [\n      -1,  // (not a type)\n      1,   // number\n      2,   // string\n      3,   // object\n      4,   // array\n      5,   // binary\n      -1,  // deprecated\n      6,   // ObjectID\n      7,   // bool\n      8,   // Date\n      0,   // null\n      9,   // RegExp\n      -1,  // deprecated\n      100, // JS code\n      2,   // deprecated (symbol)\n      100, // JS code\n      1,   // 32-bit int\n      8,   // Mongo timestamp\n      1    // 64-bit int\n    ][t];\n  },\n\n  // compare two values of unknown type according to BSON ordering\n  // semantics. (as an extension, consider 'undefined' to be less than\n  // any other value.) return negative if a is less, positive if b is\n  // less, or 0 if equal\n  _cmp(a, b) {\n    if (a === undefined) {\n      return b === undefined ? 0 : -1;\n    }\n\n    if (b === undefined) {\n      return 1;\n    }\n\n    let ta = LocalCollection._f._type(a);\n    let tb = LocalCollection._f._type(b);\n\n    const oa = LocalCollection._f._typeorder(ta);\n    const ob = LocalCollection._f._typeorder(tb);\n\n    if (oa !== ob) {\n      return oa < ob ? -1 : 1;\n    }\n\n    // XXX need to implement this if we implement Symbol or integers, or\n    // Timestamp\n    if (ta !== tb) {\n      throw Error('Missing type coercion logic in _cmp');\n    }\n\n    if (ta === 7) { // ObjectID\n      // Convert to string.\n      ta = tb = 2;\n      a = a.toHexString();\n      b = b.toHexString();\n    }\n\n    if (ta === 9) { // Date\n      // Convert to millis.\n      ta = tb = 1;\n      a = a.getTime();\n      b = b.getTime();\n    }\n\n    if (ta === 1) // double\n      return a - b;\n\n    if (tb === 2) // string\n      return a < b ? -1 : a === b ? 0 : 1;\n\n    if (ta === 3) { // Object\n      // this could be much more efficient in the expected case ...\n      const toArray = object => {\n        const result = [];\n\n        Object.keys(object).forEach(key => {\n          result.push(key, object[key]);\n        });\n\n        return result;\n      };\n\n      return LocalCollection._f._cmp(toArray(a), toArray(b));\n    }\n\n    if (ta === 4) { // Array\n      for (let i = 0; ; i++) {\n        if (i === a.length) {\n          return i === b.length ? 0 : -1;\n        }\n\n        if (i === b.length) {\n          return 1;\n        }\n\n        const s = LocalCollection._f._cmp(a[i], b[i]);\n        if (s !== 0) {\n          return s;\n        }\n      }\n    }\n\n    if (ta === 5) { // binary\n      // Surprisingly, a small binary blob is always less than a large one in\n      // Mongo.\n      if (a.length !== b.length) {\n        return a.length - b.length;\n      }\n\n      for (let i = 0; i < a.length; i++) {\n        if (a[i] < b[i]) {\n          return -1;\n        }\n\n        if (a[i] > b[i]) {\n          return 1;\n        }\n      }\n\n      return 0;\n    }\n\n    if (ta === 8) { // boolean\n      if (a) {\n        return b ? 0 : 1;\n      }\n\n      return b ? -1 : 0;\n    }\n\n    if (ta === 10) // null\n      return 0;\n\n    if (ta === 11) // regexp\n      throw Error('Sorting not supported on regular expression'); // XXX\n\n    // 13: javascript code\n    // 14: symbol\n    // 15: javascript code with scope\n    // 16: 32-bit integer\n    // 17: timestamp\n    // 18: 64-bit integer\n    // 255: minkey\n    // 127: maxkey\n    if (ta === 13) // javascript code\n      throw Error('Sorting not supported on Javascript code'); // XXX\n\n    throw Error('Unknown type to sort');\n  },\n};\n","import LocalCollection_ from './local_collection.js';\nimport Matcher from './matcher.js';\nimport Sorter from './sorter.js';\n\nLocalCollection = LocalCollection_;\nMinimongo = {\n    LocalCollection: LocalCollection_,\n    Matcher,\n    Sorter\n};\n","// ObserveHandle: the return value of a live query.\nexport default class ObserveHandle {}\n","import {\n  ELEMENT_OPERATORS,\n  equalityElementMatcher,\n  expandArraysInBranches,\n  hasOwn,\n  isOperatorObject,\n  makeLookupFunction,\n  regexpElementMatcher,\n} from './common.js';\n\n// Give a sort spec, which can be in any of these forms:\n//   {\"key1\": 1, \"key2\": -1}\n//   [[\"key1\", \"asc\"], [\"key2\", \"desc\"]]\n//   [\"key1\", [\"key2\", \"desc\"]]\n//\n// (.. with the first form being dependent on the key enumeration\n// behavior of your javascript VM, which usually does what you mean in\n// this case if the key names don't look like integers ..)\n//\n// return a function that takes two objects, and returns -1 if the\n// first object comes first in order, 1 if the second object comes\n// first, or 0 if neither object comes before the other.\n\nexport default class Sorter {\n  constructor(spec) {\n    this._sortSpecParts = [];\n    this._sortFunction = null;\n\n    const addSpecPart = (path, ascending) => {\n      if (!path) {\n        throw Error('sort keys must be non-empty');\n      }\n\n      if (path.charAt(0) === '$') {\n        throw Error(`unsupported sort key: ${path}`);\n      }\n\n      this._sortSpecParts.push({\n        ascending,\n        lookup: makeLookupFunction(path, {forSort: true}),\n        path\n      });\n    };\n\n    if (spec instanceof Array) {\n      spec.forEach(element => {\n        if (typeof element === 'string') {\n          addSpecPart(element, true);\n        } else {\n          addSpecPart(element[0], element[1] !== 'desc');\n        }\n      });\n    } else if (typeof spec === 'object') {\n      Object.keys(spec).forEach(key => {\n        addSpecPart(key, spec[key] >= 0);\n      });\n    } else if (typeof spec === 'function') {\n      this._sortFunction = spec;\n    } else {\n      throw Error(`Bad sort specification: ${JSON.stringify(spec)}`);\n    }\n\n    // If a function is specified for sorting, we skip the rest.\n    if (this._sortFunction) {\n      return;\n    }\n\n    // To implement affectedByModifier, we piggy-back on top of Matcher's\n    // affectedByModifier code; we create a selector that is affected by the\n    // same modifiers as this sort order. This is only implemented on the\n    // server.\n    if (this.affectedByModifier) {\n      const selector = {};\n\n      this._sortSpecParts.forEach(spec => {\n        selector[spec.path] = 1;\n      });\n\n      this._selectorForAffectedByModifier = new Minimongo.Matcher(selector);\n    }\n\n    this._keyComparator = composeComparators(\n      this._sortSpecParts.map((spec, i) => this._keyFieldComparator(i))\n    );\n  }\n\n  getComparator(options) {\n    // If sort is specified or have no distances, just use the comparator from\n    // the source specification (which defaults to \"everything is equal\".\n    // issue #3599\n    // https://docs.mongodb.com/manual/reference/operator/query/near/#sort-operation\n    // sort effectively overrides $near\n    if (this._sortSpecParts.length || !options || !options.distances) {\n      return this._getBaseComparator();\n    }\n\n    const distances = options.distances;\n\n    // Return a comparator which compares using $near distances.\n    return (a, b) => {\n      if (!distances.has(a._id)) {\n        throw Error(`Missing distance for ${a._id}`);\n      }\n\n      if (!distances.has(b._id)) {\n        throw Error(`Missing distance for ${b._id}`);\n      }\n\n      return distances.get(a._id) - distances.get(b._id);\n    };\n  }\n\n  // Takes in two keys: arrays whose lengths match the number of spec\n  // parts. Returns negative, 0, or positive based on using the sort spec to\n  // compare fields.\n  _compareKeys(key1, key2) {\n    if (key1.length !== this._sortSpecParts.length ||\n        key2.length !== this._sortSpecParts.length) {\n      throw Error('Key has wrong length');\n    }\n\n    return this._keyComparator(key1, key2);\n  }\n\n  // Iterates over each possible \"key\" from doc (ie, over each branch), calling\n  // 'cb' with the key.\n  _generateKeysFromDoc(doc, cb) {\n    if (this._sortSpecParts.length === 0) {\n      throw new Error('can\\'t generate keys without a spec');\n    }\n\n    const pathFromIndices = indices => `${indices.join(',')},`;\n\n    let knownPaths = null;\n\n    // maps index -> ({'' -> value} or {path -> value})\n    const valuesByIndexAndPath = this._sortSpecParts.map(spec => {\n      // Expand any leaf arrays that we find, and ignore those arrays\n      // themselves.  (We never sort based on an array itself.)\n      let branches = expandArraysInBranches(spec.lookup(doc), true);\n\n      // If there are no values for a key (eg, key goes to an empty array),\n      // pretend we found one undefined value.\n      if (!branches.length) {\n        branches = [{ value: void 0 }];\n      }\n\n      const element = Object.create(null);\n      let usedPaths = false;\n\n      branches.forEach(branch => {\n        if (!branch.arrayIndices) {\n          // If there are no array indices for a branch, then it must be the\n          // only branch, because the only thing that produces multiple branches\n          // is the use of arrays.\n          if (branches.length > 1) {\n            throw Error('multiple branches but no array used?');\n          }\n\n          element[''] = branch.value;\n          return;\n        }\n\n        usedPaths = true;\n\n        const path = pathFromIndices(branch.arrayIndices);\n\n        if (hasOwn.call(element, path)) {\n          throw Error(`duplicate path: ${path}`);\n        }\n\n        element[path] = branch.value;\n\n        // If two sort fields both go into arrays, they have to go into the\n        // exact same arrays and we have to find the same paths.  This is\n        // roughly the same condition that makes MongoDB throw this strange\n        // error message.  eg, the main thing is that if sort spec is {a: 1,\n        // b:1} then a and b cannot both be arrays.\n        //\n        // (In MongoDB it seems to be OK to have {a: 1, 'a.x.y': 1} where 'a'\n        // and 'a.x.y' are both arrays, but we don't allow this for now.\n        // #NestedArraySort\n        // XXX achieve full compatibility here\n        if (knownPaths && !hasOwn.call(knownPaths, path)) {\n          throw Error('cannot index parallel arrays');\n        }\n      });\n\n      if (knownPaths) {\n        // Similarly to above, paths must match everywhere, unless this is a\n        // non-array field.\n        if (!hasOwn.call(element, '') &&\n            Object.keys(knownPaths).length !== Object.keys(element).length) {\n          throw Error('cannot index parallel arrays!');\n        }\n      } else if (usedPaths) {\n        knownPaths = {};\n\n        Object.keys(element).forEach(path => {\n          knownPaths[path] = true;\n        });\n      }\n\n      return element;\n    });\n\n    if (!knownPaths) {\n      // Easy case: no use of arrays.\n      const soleKey = valuesByIndexAndPath.map(values => {\n        if (!hasOwn.call(values, '')) {\n          throw Error('no value in sole key case?');\n        }\n\n        return values[''];\n      });\n\n      cb(soleKey);\n\n      return;\n    }\n\n    Object.keys(knownPaths).forEach(path => {\n      const key = valuesByIndexAndPath.map(values => {\n        if (hasOwn.call(values, '')) {\n          return values[''];\n        }\n\n        if (!hasOwn.call(values, path)) {\n          throw Error('missing path?');\n        }\n\n        return values[path];\n      });\n\n      cb(key);\n    });\n  }\n\n  // Returns a comparator that represents the sort specification (but not\n  // including a possible geoquery distance tie-breaker).\n  _getBaseComparator() {\n    if (this._sortFunction) {\n      return this._sortFunction;\n    }\n\n    // If we're only sorting on geoquery distance and no specs, just say\n    // everything is equal.\n    if (!this._sortSpecParts.length) {\n      return (doc1, doc2) => 0;\n    }\n\n    return (doc1, doc2) => {\n      const key1 = this._getMinKeyFromDoc(doc1);\n      const key2 = this._getMinKeyFromDoc(doc2);\n      return this._compareKeys(key1, key2);\n    };\n  }\n\n  // Finds the minimum key from the doc, according to the sort specs.  (We say\n  // \"minimum\" here but this is with respect to the sort spec, so \"descending\"\n  // sort fields mean we're finding the max for that field.)\n  //\n  // Note that this is NOT \"find the minimum value of the first field, the\n  // minimum value of the second field, etc\"... it's \"choose the\n  // lexicographically minimum value of the key vector, allowing only keys which\n  // you can find along the same paths\".  ie, for a doc {a: [{x: 0, y: 5}, {x:\n  // 1, y: 3}]} with sort spec {'a.x': 1, 'a.y': 1}, the only keys are [0,5] and\n  // [1,3], and the minimum key is [0,5]; notably, [0,3] is NOT a key.\n  _getMinKeyFromDoc(doc) {\n    let minKey = null;\n\n    this._generateKeysFromDoc(doc, key => {\n      if (minKey === null) {\n        minKey = key;\n        return;\n      }\n\n      if (this._compareKeys(key, minKey) < 0) {\n        minKey = key;\n      }\n    });\n\n    return minKey;\n  }\n\n  _getPaths() {\n    return this._sortSpecParts.map(part => part.path);\n  }\n\n  // Given an index 'i', returns a comparator that compares two key arrays based\n  // on field 'i'.\n  _keyFieldComparator(i) {\n    const invert = !this._sortSpecParts[i].ascending;\n\n    return (key1, key2) => {\n      const compare = LocalCollection._f._cmp(key1[i], key2[i]);\n      return invert ? -compare : compare;\n    };\n  }\n}\n\n// Given an array of comparators\n// (functions (a,b)->(negative or positive or zero)), returns a single\n// comparator which uses each comparator in order and returns the first\n// non-zero value.\nfunction composeComparators(comparatorArray) {\n  return (a, b) => {\n    for (let i = 0; i < comparatorArray.length; ++i) {\n      const compare = comparatorArray[i](a, b);\n      if (compare !== 0) {\n        return compare;\n      }\n    }\n\n    return 0;\n  };\n}\n"]}