@depup/gatsby 5.16.1-depup.0

package/dist/datastore/in-memory/indexing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexing.js","names":["nodeIdToIdentifierMap","Map","getGatsbyNodePartial","node","indexFields","resolvedFields","cacheKey","id","internal","counter","derefPartial","undefined","has","get","deref","map","field","gatsbyNodePartialInternalData","dottedFields","fieldsToStore","Set","sortFieldIds","getSortFieldIdentifierKeys","fullNodeObject","resolvedNodeFields","dottedField","startsWith","getResolvedFields","getValueAt","slice","length","getNode","partial","Object","assign","type","set","WeakRef","sortByIds","a","b","postIndexingMetaSetup","filterCache","op","bucket","byValue","sort","postIndexingMetaSetupNeNin","includes","postIndexingMetaSetupLtLteGtGte","arr","meta","nodesUnordered","forEach","v","nodeId","push","entriesNullable","entries","filter","orderedNodes","orderedValues","offsets","valuesAsc","nodesByValueAsc","valueRangesAsc","valuesDesc","nodesByValueDesc","valueRangesDesc","ensureIndexByQuery","filterCacheKey","filterPath","nodeTypeNames","filtersCache","getDataStore","iterateNodesByType","addNodeToFilterCache","chain","iterateNodes","ensureEmptyFilterCache","orderedByCounter","valueOffset","i","nextProp","Array","isArray","markNodeForValue","value","ensureIndexByElemMatch","addNodeToBucketWithElemMatch","valueAtCurrentStep","path","nestedQuery","elem","binarySearchAsc","values","needle","min","max","pivot","Math","floor","binarySearchDesc","getNodesFromCacheByValue","filterValue","wasElemMatch","arrNull","arrUndef","unionNodesByCounter","Error","filterValueArr","add","nodes","expensiveDedupeInline","removeBucketFromSet","RegExp","regex","test","String","ranges","range","point","pivotMin","pivotMax","pivotValue","exclPivot","inclPivot","until","reverse","cache","delete","intersectNodesByCounter","pointerA","pointerB","result","maxA","maxB","lastAdded","counterA","counterB","prev","j","objectToDottedField","dottedFieldKeys","keys","fieldKeys","some","key"],"sources":["../../../src/datastore/in-memory/indexing.ts"],"sourcesContent":["import { IGatsbyNode } from \"../../redux/types\"\nimport {\n  IDbQueryElemMatch,\n  FilterValue,\n  FilterValueNullable,\n  objectToDottedField,\n} from \"../common/query\"\nimport { getDataStore, getNode } from \"../\"\nimport _ from \"lodash\"\nimport { getValueAt } from \"../../utils/get-value-at\"\nimport { getResolvedFields } from \"../../schema/utils\"\n\n// Only list supported ops here. \"CacheableFilterOp\"\n// TODO: merge with DbComparator ?\nexport type FilterOp =\n  | \"$eq\"\n  | \"$ne\"\n  | \"$lt\"\n  | \"$lte\"\n  | \"$gt\"\n  | \"$gte\"\n  | \"$in\"\n  | \"$nin\"\n  | \"$regex\" // Note: this includes $glob\n\nexport type FilterCacheKey = string\ntype GatsbyNodeID = string\n\nexport interface IGatsbyNodePartial {\n  id: GatsbyNodeID\n  internal: {\n    type: string\n    counter: number\n  }\n  gatsbyNodePartialInternalData: {\n    indexFields: Set<string>\n  }\n  [k: string]: any\n}\n\nconst nodeIdToIdentifierMap = new Map<\n  GatsbyNodeID,\n  WeakRef<IGatsbyNodePartial>\n>()\n\n/**\n * Grabs an instance of IGatsbyNodePartial for the given node.\n * This accepts an IGatsbyNode or IGatsbyNodePartial as input, which allows\n * us to conditionally store index fields on the partial if we encounter\n * one that hasn't been stored on the partial yet.\n */\nexport const getGatsbyNodePartial = (\n  node: IGatsbyNode | IGatsbyNodePartial,\n  indexFields: Array<string>,\n  resolvedFields: Record<string, any>\n): IGatsbyNodePartial => {\n  // first, check if we have the partial in the cache\n  const cacheKey = `${node.id}_____${node.internal.counter}`\n  let derefPartial: IGatsbyNodePartial | undefined = undefined\n  if (nodeIdToIdentifierMap.has(cacheKey)) {\n    derefPartial = nodeIdToIdentifierMap.get(cacheKey)?.deref()\n\n    // now check if we have it in memory and it has all the fields we need\n    if (\n      derefPartial &&\n      _.every(\n        indexFields.map(field =>\n          derefPartial!.gatsbyNodePartialInternalData.indexFields.has(field)\n        )\n      )\n    ) {\n      return derefPartial\n    }\n  }\n\n  // find all the keys of fields and store them and their values on the partial\n  // if we've already passed this partial, merge both sets of index fields\n  const dottedFields = {}\n  const fieldsToStore = derefPartial\n    ? new Set([\n        ...derefPartial.gatsbyNodePartialInternalData.indexFields,\n        ...indexFields,\n      ])\n    : new Set(indexFields)\n\n  const sortFieldIds = getSortFieldIdentifierKeys(\n    [...fieldsToStore],\n    resolvedFields\n  )\n  let fullNodeObject: IGatsbyNode | undefined =\n    node.gatsbyNodePartialInternalData ? undefined : (node as IGatsbyNode)\n  let resolvedNodeFields\n\n  for (const dottedField of sortFieldIds) {\n    if (dottedField in node) {\n      dottedFields[dottedField] = node[dottedField]\n    } else {\n      if (dottedField.startsWith(`__gatsby_resolved.`)) {\n        if (!resolvedNodeFields) {\n          resolvedNodeFields = getResolvedFields(node)\n        }\n\n        dottedFields[dottedField] = getValueAt(\n          resolvedNodeFields,\n          dottedField.slice(`__gatsby_resolved.`.length)\n        )\n      } else {\n        // if we haven't gotten the full node object, fetch it once\n        // use the full node object to fetch the value\n        if (!fullNodeObject) {\n          fullNodeObject = getNode(node.id)!\n        }\n        dottedFields[dottedField] = getValueAt(fullNodeObject, dottedField)\n      }\n    }\n  }\n\n  // create the partial object\n  const partial = Object.assign(dottedFields, {\n    id: node.id,\n    internal: {\n      counter: node.internal.counter,\n      type: node.internal.type,\n    },\n    gatsbyNodePartialInternalData: {\n      indexFields: fieldsToStore,\n    },\n  })\n\n  // set the object in the cache for later fetching\n  nodeIdToIdentifierMap.set(cacheKey, new WeakRef<IGatsbyNodePartial>(partial))\n\n  return partial\n}\n\nconst sortByIds = (a: IGatsbyNodePartial, b: IGatsbyNodePartial): number =>\n  a.internal.counter - b.internal.counter\n\nexport interface IFilterCache {\n  op: FilterOp\n  // In this map `undefined` values represent nodes that did not have the path\n  // The individual arrays are ordered asc by internal.counter which will\n  // preserve insertion order and guarantee uniqueness and it's a number so our\n  // .sort() calls can subtract one from the other which is nice :)\n  // This arrays may contain duplicates (!) because those only get filtered in the\n  // last step.\n  // TODO: We might decide to make sure these buckets _are_ deduped for eq perf\n  byValue: Map<FilterValueNullable, Array<IGatsbyNodePartial>>\n  meta: {\n    // Used by ne/nin, which will create a Set from this array and then remove another set(s) and sort\n    nodesUnordered?: Array<IGatsbyNodePartial>\n    // Flat list of all nodes by requested types, ordered by counter (cached for empty filters)\n    orderedByCounter?: Array<IGatsbyNodePartial>\n    // Ordered list of all values (by `<`) found by this filter. No null / undefs\n    valuesAsc?: Array<FilterValue>\n    // Flat list of nodes, ordered by valueAsc\n    nodesByValueAsc?: Array<IGatsbyNodePartial>\n    // Ranges of nodes per value, maps to the nodesByValueAsc array\n    valueRangesAsc?: Map<FilterValue, [number, number]>\n    // Ordered list of all values (by `>`) found by this filter. No null / undefs\n    valuesDesc?: Array<FilterValue>\n    // Flat list of nodes, ordered by valueDesc\n    nodesByValueDesc?: Array<IGatsbyNodePartial>\n    // Ranges of nodes per value, maps to the nodesByValueDesc array\n    valueRangesDesc?: Map<FilterValue, [number, number]>\n  }\n}\nexport type FiltersCache = Map<FilterCacheKey, IFilterCache>\n\nexport function postIndexingMetaSetup(\n  filterCache: IFilterCache,\n  op: FilterOp\n): void {\n  // Loop through byValue and make sure the buckets are sorted by counter\n  // Since we don't do insertion sort, we have to do it afterwards\n  for (const bucket of filterCache.byValue) {\n    bucket[1].sort(sortByIds)\n  }\n\n  if (op === `$ne` || op === `$nin`) {\n    postIndexingMetaSetupNeNin(filterCache)\n  } else if ([`$lt`, `$lte`, `$gt`, `$gte`].includes(op)) {\n    postIndexingMetaSetupLtLteGtGte(filterCache, op)\n  }\n}\n\nfunction postIndexingMetaSetupNeNin(filterCache: IFilterCache): void {\n  // Note: edge cases regarding `null` and `undefined`. Here `undefined` signals\n  // that the property did not exist as the filters do not support actual\n  // `undefined` values.\n  // For $ne, `null` only returns nodes that actually have the property\n  // and in that case the property cannot be `null` either. For any other value,\n  // $ne will return all nodes where the value is not actually the needle,\n  // including nodes where the value is null.\n  // A $nin does the same as an $ne except it filters multiple values instead\n  // of just one.\n  // For `$ne` we will take the list of all targeted nodes and eliminate the\n  // bucket of nodes with a particular value, if it exists at all..\n\n  const arr: Array<IGatsbyNodePartial> = []\n  filterCache.meta.nodesUnordered = arr\n  filterCache.byValue.forEach(v => {\n    v.forEach(nodeId => {\n      arr.push(nodeId)\n    })\n  })\n}\n\nfunction postIndexingMetaSetupLtLteGtGte(\n  filterCache: IFilterCache,\n  op: FilterOp\n): void {\n  // Create an ordered array of individual nodes, ordered (grouped) by the\n  // value to which the filter resolves. Nodes per value are ordered by\n  // internal.counter, asc.\n  // This way non-eq ops can simply slice the array to get a range.\n\n  const entriesNullable: Array<\n    [FilterValueNullable, Array<IGatsbyNodePartial>]\n  > = [...filterCache.byValue.entries()]\n\n  // These range checks never return `null` or `undefined` so filter those out\n  // By filtering them out early, the sort should be faster. Could be ...\n  const entries: Array<[FilterValue, Array<IGatsbyNodePartial>]> =\n    entriesNullable.filter(([v]) => v != null) as Array<\n      [FilterValue, Array<IGatsbyNodePartial>]\n    >\n\n  // Sort all arrays by its value, asc. Ignore/allow potential type casting.\n  // Note: while `<` is the inverse of `>=`, the ordering might coerce values.\n  // This coercion makes the op no longer idempotent (normally the result of\n  // `a < b` is the opposite of `b >= a` for any a or b of the same type). The\n  // exception is a number that is `NaN`, which we're ignoring here as it's most\n  // likely a bug in the user code. However, when coercing the ops may end up\n  // comparing against `NaN`, too. For example: `(\"abc\" <= 12) !== (12 > \"abc\")`\n  // which ends up doing `NaN <= 12` and `NaN > \"abc\"`, which will both yield\n  // false.\n  // So instead we potentially track two ordered lists; ascending and descending\n  // and the only difference when comparing the inverse of one to the other\n  // should be how these `NaN` cases end up getting ordered.\n  // It's fine for `lt` and `lte` to use the same ordered list. Same for gt/gte.\n  if (op === `$lt` || op === `$lte`) {\n    // Order ascending; first value is lowest\n    entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n  } else if (op === `$gt` || op === `$gte`) {\n    // Order descending; first value is highest\n    entries.sort(([a], [b]) => (a > b ? -1 : a < b ? 1 : 0))\n  }\n\n  const orderedNodes: Array<IGatsbyNodePartial> = []\n  const orderedValues: Array<FilterValue> = []\n  const offsets: Map<FilterValue, [number, number]> = new Map()\n  entries.forEach(([v, bucket]: [FilterValue, Array<IGatsbyNodePartial>]) => {\n    // Record the range containing all nodes with as filter value v\n    // The last value of the range should be the offset of the next value\n    // (So you should be able to do `nodes.slice(start, stop)` to get them)\n    offsets.set(v, [orderedNodes.length, orderedNodes.length + bucket.length])\n    // We could do `arr.push(...bucket)` here but that's not safe with very\n    // large sets, so we use a regular loop\n    bucket.forEach(node => orderedNodes.push(node))\n    orderedValues.push(v)\n  })\n\n  if (op === `$lt` || op === `$lte`) {\n    filterCache.meta.valuesAsc = orderedValues\n    filterCache.meta.nodesByValueAsc = orderedNodes\n    // The nodesByValueAsc is ordered by value, but multiple nodes per value are\n    // not ordered. To make lt as fast as lte, we must know the start and stop\n    // index for each value. Similarly useful for for `ne`.\n    filterCache.meta.valueRangesAsc = offsets\n  } else if (op === `$gt` || op === `$gte`) {\n    filterCache.meta.valuesDesc = orderedValues\n    filterCache.meta.nodesByValueDesc = orderedNodes\n    // The nodesByValueDesc is ordered by value, but multiple nodes per value are\n    // not ordered. To make gt as fast as gte, we must know the start and stop\n    // index for each value. Similarly useful for for `ne`.\n    filterCache.meta.valueRangesDesc = offsets\n  }\n}\n\n/**\n * Given a single non-elemMatch filter path, a list of node types, and a\n * cache, create a cache that for each resulting value of the filter contains\n * all the Nodes in a list.\n * This cache is used for applying the filter and is a massive improvement over\n * looping over all the nodes, when the number of pages (/nodes) scales up.\n */\nexport const ensureIndexByQuery = (\n  op: FilterOp,\n  filterCacheKey: FilterCacheKey,\n  filterPath: Array<string>,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  indexFields: Array<string>,\n  resolvedFields: Record<string, any>\n): void => {\n  const filterCache: IFilterCache = {\n    op,\n    byValue: new Map<FilterValueNullable, Array<IGatsbyNodePartial>>(),\n    meta: {},\n  } as IFilterCache\n  filtersCache.set(filterCacheKey, filterCache)\n\n  // We cache the subsets of nodes by type, but only one type. So if searching\n  // through one node type we can prevent a search through all nodes, otherwise\n  // it's probably faster to loop through all nodes. Perhaps. Maybe.\n\n  if (nodeTypeNames.length === 1) {\n    getDataStore()\n      .iterateNodesByType(nodeTypeNames[0])\n      .forEach(node => {\n        addNodeToFilterCache({\n          node,\n          chain: filterPath,\n          filterCache,\n          indexFields,\n          resolvedFields,\n        })\n      })\n  } else {\n    // Here we must first filter for the node type\n    // This loop is expensive at scale (!)\n    getDataStore()\n      .iterateNodes()\n      .forEach(node => {\n        if (!nodeTypeNames.includes(node.internal.type)) {\n          return\n        }\n\n        addNodeToFilterCache({\n          node,\n          chain: filterPath,\n          filterCache,\n          indexFields,\n          resolvedFields,\n        })\n      })\n  }\n\n  postIndexingMetaSetup(filterCache, op)\n}\n\nexport function ensureEmptyFilterCache(\n  filterCacheKey,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  indexFields: Array<string>,\n  resolvedFields: Record<string, any>\n): void {\n  // This is called for queries without any filters\n  // We want to cache the result since it's basically a list of nodes by type(s)\n  // There are sites that have multiple queries which are empty\n\n  const orderedByCounter: Array<IGatsbyNodePartial> = []\n\n  filtersCache.set(filterCacheKey, {\n    op: `$eq`, // Ignore.\n    byValue: new Map<FilterValueNullable, Array<IGatsbyNodePartial>>(),\n    meta: {\n      orderedByCounter, // This is what we want\n    },\n  })\n\n  if (nodeTypeNames.length === 1) {\n    getDataStore()\n      .iterateNodesByType(nodeTypeNames[0])\n      .forEach(node => {\n        orderedByCounter.push(\n          getGatsbyNodePartial(node, indexFields, resolvedFields)\n        )\n      })\n  } else {\n    // Here we must first filter for the node type\n    // This loop is expensive at scale (!)\n    getDataStore()\n      .iterateNodes()\n      .forEach(node => {\n        if (nodeTypeNames.includes(node.internal.type)) {\n          orderedByCounter.push(\n            getGatsbyNodePartial(node, indexFields, resolvedFields)\n          )\n        }\n      })\n  }\n\n  // Since each node can only have one type, we shouldn't have to be concerned\n  // about duplicates in this array. Just make sure they're sorted.\n  orderedByCounter.sort(sortByIds)\n}\n\nfunction addNodeToFilterCache({\n  node,\n  chain,\n  filterCache,\n  indexFields,\n  resolvedFields,\n  valueOffset = node,\n}: {\n  node: IGatsbyNode\n  chain: Array<string>\n  filterCache: IFilterCache\n  indexFields: Array<string>\n  resolvedFields: Record<string, any>\n  valueOffset?: any\n}): void {\n  // - for plain query, valueOffset === node\n  // - for elemMatch, valueOffset is sub-tree of the node to continue matching\n  let v = valueOffset as any\n  let i = 0\n  while (i < chain.length && v) {\n    const nextProp = chain[i++]\n    if (i === 1 && nextProp === `__gatsby_resolved`) {\n      v = getResolvedFields(v)\n    } else {\n      v = v[nextProp]\n    }\n  }\n\n  if (\n    (typeof v !== `string` &&\n      typeof v !== `number` &&\n      typeof v !== `boolean` &&\n      v !== null) ||\n    i !== chain.length\n  ) {\n    if (i === chain.length && Array.isArray(v)) {\n      // The op resolved to an array\n      // Add an entry for each element of the array. This would work for ops\n      // like eq and ne, but not sure about range ops like lt,lte,gt,gte.\n\n      v.forEach(v =>\n        markNodeForValue(filterCache, node, v, indexFields, resolvedFields)\n      )\n\n      return\n    }\n\n    // This means that either\n    // - The filter resolved to `undefined`, or\n    // - The filter resolved to something other than a primitive\n    // Set the value to `undefined` to mark \"path does not (fully) exist\"\n    v = undefined\n  }\n\n  markNodeForValue(filterCache, node, v, indexFields, resolvedFields)\n}\n\nfunction markNodeForValue(\n  filterCache: IFilterCache,\n  node: IGatsbyNode,\n  value: FilterValueNullable,\n  indexFields: Array<string>,\n  resolvedFields: Record<string, any>\n): void {\n  let arr = filterCache.byValue.get(value)\n  if (!arr) {\n    arr = []\n    filterCache.byValue.set(value, arr)\n  }\n\n  const partial = getGatsbyNodePartial(node, indexFields, resolvedFields)\n  if (!arr.includes(partial)) {\n    arr.push(partial)\n  }\n}\n\nexport const ensureIndexByElemMatch = (\n  op: FilterOp,\n  filterCacheKey: FilterCacheKey,\n  filter: IDbQueryElemMatch,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  indexFields: Array<string>,\n  resolvedFields: Record<string, any>\n): void => {\n  // Given an elemMatch filter, generate the cache that contains all nodes that\n  // matches a given value for that sub-query\n\n  const filterCache: IFilterCache = {\n    op,\n    byValue: new Map<FilterValueNullable, Array<IGatsbyNodePartial>>(),\n    meta: {},\n  } as IFilterCache\n  filtersCache.set(filterCacheKey, filterCache)\n\n  if (nodeTypeNames.length === 1) {\n    getDataStore()\n      .iterateNodesByType(nodeTypeNames[0])\n      .forEach(node => {\n        addNodeToBucketWithElemMatch({\n          node,\n          valueAtCurrentStep: node,\n          filter,\n          filterCache,\n          indexFields,\n          resolvedFields,\n        })\n      })\n  } else {\n    // Expensive at scale\n    getDataStore()\n      .iterateNodes()\n      .forEach(node => {\n        if (!nodeTypeNames.includes(node.internal.type)) {\n          return\n        }\n\n        addNodeToBucketWithElemMatch({\n          node,\n          valueAtCurrentStep: node,\n          filter,\n          filterCache,\n          indexFields,\n          resolvedFields,\n        })\n      })\n  }\n\n  postIndexingMetaSetup(filterCache, op)\n}\n\nfunction addNodeToBucketWithElemMatch({\n  node,\n  valueAtCurrentStep, // Arbitrary step on the path inside the node\n  filter,\n  filterCache,\n  indexFields,\n  resolvedFields,\n}: {\n  node: IGatsbyNode\n  valueAtCurrentStep: any // Arbitrary step on the path inside the node\n  filter: IDbQueryElemMatch\n  filterCache: IFilterCache\n  indexFields: Array<string>\n  resolvedFields: Record<string, any>\n}): void {\n  const { path, nestedQuery } = filter\n\n  // Find the value to apply elemMatch to\n  let i = 0\n  while (i < path.length && valueAtCurrentStep) {\n    const nextProp = path[i++]\n    if (i === 1 && nextProp === `__gatsby_resolved`) {\n      valueAtCurrentStep = getResolvedFields(valueAtCurrentStep)\n    } else {\n      valueAtCurrentStep = valueAtCurrentStep[nextProp]\n    }\n  }\n\n  if (path.length !== i) {\n    // Found undefined before the end of the path\n    return\n  }\n\n  // `v` should now be an elemMatch target, probably an array (but maybe not)\n  if (!Array.isArray(valueAtCurrentStep)) {\n    // It's possible to `elemMatch` on a non-array so let's support that too\n    valueAtCurrentStep = [valueAtCurrentStep]\n  }\n\n  // Note: We need to check all elements because the node may need to be added\n  // to multiple buckets (`{a:[{b:3},{b:4}]}`, for `a.elemMatch.b/eq` that\n  // node ends up in buckets for value 3 and 4. This may lead to duplicate\n  // work when elements resolve to the same value, but that can't be helped.\n  valueAtCurrentStep.forEach(elem => {\n    if (nestedQuery.type === `elemMatch`) {\n      addNodeToBucketWithElemMatch({\n        node,\n        valueAtCurrentStep: elem,\n        filter: nestedQuery,\n        filterCache,\n        indexFields,\n        resolvedFields,\n      })\n    } else {\n      // Now take same route as non-elemMatch filters would take\n      addNodeToFilterCache({\n        node,\n        chain: nestedQuery.path,\n        filterCache,\n        indexFields,\n        resolvedFields,\n        valueOffset: elem,\n      })\n    }\n  })\n}\n\nconst binarySearchAsc = (\n  values: Array<FilterValue>, // Assume ordered asc\n  needle: FilterValue\n): [number, number] | undefined => {\n  let min = 0\n  let max = values.length - 1\n  let pivot = Math.floor(values.length / 2)\n  while (min <= max) {\n    const value = values[pivot]\n    if (needle < value) {\n      // Move pivot to middle of nodes left of current pivot\n      // assert pivot < max\n      max = pivot\n    } else if (needle > value) {\n      // Move pivot to middle of nodes right of current pivot\n      // assert pivot > min\n      min = pivot\n    } else {\n      // This means needle === value\n      // TODO: except for NaN ... and potentially certain type casting cases\n      return [pivot, pivot]\n    }\n\n    if (max - min <= 1) {\n      // End of search. Needle not found (as expected). Use pivot as index.\n      // If the needle was not found, max-min==1 and max is returned.\n      return [min, max]\n    }\n\n    pivot = min + Math.floor((max - min) / 2)\n  }\n\n  // Shouldn't be reachable\n  return undefined\n}\nconst binarySearchDesc = (\n  values: Array<FilterValue>, // Assume ordered desc\n  needle: FilterValue\n): [number, number] | undefined => {\n  let min = 0\n  let max = values.length - 1\n  let pivot = Math.floor(values.length / 2)\n  while (min <= max) {\n    const value = values[pivot]\n    if (needle < value) {\n      // Move pivot to middle of nodes right of current pivot\n      // assert pivot < min\n      min = pivot\n    } else if (needle > value) {\n      // Move pivot to middle of nodes left of current pivot\n      // assert pivot > max\n      max = pivot\n    } else {\n      // This means needle === value\n      // TODO: except for NaN ... and potentially certain type casting cases\n      return [pivot, pivot]\n    }\n\n    if (max - min <= 1) {\n      // End of search. Needle not found (as expected). Use pivot as index.\n      // If the needle was not found, max-min==1 and max is returned.\n      return [min, max]\n    }\n\n    pivot = min + Math.floor((max - min) / 2)\n  }\n\n  // Shouldn't be reachable\n  return undefined\n}\n\n/**\n * Given the cache key for a filter and a target value return the list of nodes\n * that resolve to this value. The returned array should be ordered by id.\n * This returns `undefined` if there is no such node\n *\n * Basically if the filter was {a: {b: {slug: {eq: \"foo/bar\"}}}} then it will\n * return all the nodes that have `node.slug === \"foo/bar\"`. That usually (but\n * not always) at most one node for slug, but this filter can apply to anything.\n *\n * Arrays returned by this function must be ordered by internal.counter and\n * not contain duplicate nodes (!)\n */\nexport const getNodesFromCacheByValue = (\n  filterCacheKey: FilterCacheKey,\n  filterValue: FilterValueNullable,\n  filtersCache: FiltersCache,\n  wasElemMatch\n): Array<IGatsbyNodePartial> | undefined => {\n  const filterCache = filtersCache.get(filterCacheKey)\n  if (!filterCache) {\n    return undefined\n  }\n\n  const op = filterCache.op\n\n  if (op === `$eq`) {\n    // Arrays in byValue are assumed to be ordered by counter\n\n    if (filterValue == null) {\n      // Edge case for null; fetch all nodes for `null` and `undefined` because\n      // `$eq` also returns nodes without the path when searching for `null`.\n      // Not all ops do so, so we map non-existing paths to `undefined`.\n\n      const arrNull = filterCache.byValue.get(null) ?? []\n      const arrUndef = filterCache.byValue.get(undefined) ?? []\n\n      // Merge the two (ordered) arrays and return an ordered deduped array\n      // TODO: is there a reason left why we cant just cache this merged list?\n      return unionNodesByCounter(arrNull, arrUndef)\n    }\n\n    return filterCache.byValue.get(filterValue)\n  }\n\n  if (op === `$in`) {\n    if (!Array.isArray(filterValue)) {\n      throw new Error(\"The argument to the `in` comparator should be an array\")\n    }\n    const filterValueArr: Array<FilterValueNullable> = filterValue\n\n    const set: Set<IGatsbyNodePartial> = new Set()\n\n    // TODO: we can also mergeSort for every step. this may perform worse because of how memory in js works.\n    // For every value in the needle array, find the bucket of nodes for\n    // that value, add this bucket of nodes to one list, return the list.\n    filterValueArr.forEach((v: FilterValueNullable) =>\n      filterCache.byValue.get(v)?.forEach(v => set.add(v))\n    )\n\n    const arr = [...set] // this is bad for perf but will guarantee us a unique set :(\n    arr.sort(sortByIds)\n\n    // Note: it's very unlikely that the list of filter values is big so .includes should be fine here\n    if (filterValueArr.includes(null)) {\n      // Like all other ops, `in: [null]` behaves weirdly, allowing all nodes\n      // that do not actually have a (complete) path (v=undefined)\n      const nodes = filterCache.byValue.get(undefined)\n      if (nodes) {\n        // This will also dedupe so don't do that immediately\n        return unionNodesByCounter(nodes, arr)\n      }\n    }\n\n    // elemMatch can cause a node to appear in multiple buckets so we must dedupe first\n    if (wasElemMatch) {\n      expensiveDedupeInline(arr)\n    }\n\n    return arr\n  }\n\n  if (op === `$nin`) {\n    // This is essentially the same as the $ne operator, just with multiple\n    // values to exclude.\n\n    if (!Array.isArray(filterValue)) {\n      throw new Error(`The $nin operator expects an array as value`)\n    }\n\n    const values: Set<FilterValueNullable> = new Set(filterValue)\n    const set = new Set(filterCache.meta.nodesUnordered)\n\n    // Do the action for \"$ne\" for each element in the set of values\n    values.forEach(filterValue => {\n      removeBucketFromSet(filterValue, filterCache, set)\n    })\n\n    // TODO: there's probably a more efficient algorithm to do set\n    //       subtraction in such a way that we don't have to re-sort\n    return [...set].sort(sortByIds)\n  }\n\n  if (op === `$ne`) {\n    const set = new Set(filterCache.meta.nodesUnordered)\n\n    removeBucketFromSet(filterValue, filterCache, set)\n\n    // TODO: there's probably a more efficient algorithm to do set\n    //       subtraction in such a way that we don't have to resort here\n    return [...set].sort(sortByIds)\n  }\n\n  if (op === `$regex`) {\n    // Note: $glob is converted to $regex so $glob filters go through here, too\n    // Aside from the input pattern format, further behavior is exactly the same.\n\n    // The input to the filter must be a string (including leading/trailing slash and regex flags)\n    // By the time the filter reaches this point, the filterValue has to be a regex.\n\n    if (!(filterValue instanceof RegExp)) {\n      throw new Error(\n        `The value for the $regex comparator must be an instance of RegExp`\n      )\n    }\n    const regex = filterValue\n\n    const arr: Array<IGatsbyNodePartial> = []\n    filterCache.byValue.forEach((nodes, value) => {\n      // TODO: does the value have to be a string for $regex? Can we auto-ignore any non-strings? Or does it coerce.\n      // Note: for legacy reasons partial paths should also be included for regex\n      if (value !== undefined && regex.test(String(value))) {\n        nodes.forEach(node => arr.push(node))\n      }\n    })\n\n    // TODO: we _can_ cache this list as well. Might make sense if it turns out that $regex is mostly used with literals\n    // TODO: it may make sense to first collect all buckets and then to .concat them, or merge sort them\n\n    arr.sort(sortByIds)\n\n    // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n    if (wasElemMatch) {\n      expensiveDedupeInline(arr)\n    }\n\n    return arr\n  }\n\n  if (filterValue == null) {\n    if (op === `$lt` || op === `$gt`) {\n      // Nothing is lt/gt null\n      return undefined\n    }\n\n    // This is an edge case and this value should be directly indexed\n    // For `lte`/`gte` this should only return nodes for `null`, not a \"range\"\n    return filterCache.byValue.get(filterValue)\n  }\n\n  if (Array.isArray(filterValue)) {\n    throw new Error(\n      \"Array is an invalid filter value for the `\" + op + \"` comparator\"\n    )\n  }\n\n  if (filterValue instanceof RegExp) {\n    // This is most likely an internal error, although it is possible for\n    // users to talk to this API more directly.\n    throw new Error(\n      `A RegExp instance is only valid for $regex and $glob comparators`\n    )\n  }\n\n  if (op === `$lt`) {\n    // First try a direct approach. If a value is queried that also exists then\n    // we can prevent a binary search through the whole list, O(1) vs O(log n)\n\n    const ranges = filterCache.meta.valueRangesAsc\n    const nodes = filterCache.meta.nodesByValueAsc\n\n    const range = ranges!.get(filterValue)\n    if (range) {\n      const arr = nodes!.slice(0, range[0])\n      arr.sort(sortByIds)\n      // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n      if (wasElemMatch) {\n        expensiveDedupeInline(arr)\n      }\n      return arr\n    }\n\n    // Query may ask for a value that doesn't appear in the list, like if the\n    // list is [1, 2, 5, 6] and the query is <= 3. In that case we have to\n    // apply a search (we'll do binary) to determine the offset to slice from.\n\n    // Note: for lte, the valueAsc array must be list at this point\n    const values = filterCache.meta.valuesAsc as Array<FilterValue>\n    // It shouldn't find the targetValue (but it might) and return the index of\n    // the two value between which targetValue sits, or first/last element.\n    const point = binarySearchAsc(values, filterValue)\n    if (!point) {\n      return undefined\n    }\n    const [pivotMin, pivotMax] = point\n\n    // Each pivot index must have a value and a range\n    // The returned min/max index may include the lower/upper bound, so we still\n    // have to do lte checks for both values.\n    let pivotValue = values[pivotMax]\n    if (pivotValue > filterValue) {\n      pivotValue = values[pivotMin]\n    }\n\n    // Note: the pivot value _shouldnt_ match the filter value because that\n    // means the value was actually found, but those should have been indexed\n    // so should have yielded a result in the .get() above.\n\n    const [exclPivot, inclPivot] = ranges!.get(pivotValue) as [number, number]\n\n    // Note: technically, `5 <= \"5\" === true` but `5` would not be cached.\n    // So we have to consider weak comparison and may have to include the pivot\n    const until = pivotValue < filterValue ? inclPivot : exclPivot\n    const arr = nodes!.slice(0, until)\n    arr.sort(sortByIds)\n    // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n    if (wasElemMatch) {\n      expensiveDedupeInline(arr)\n    }\n    return arr\n  }\n\n  if (op === `$lte`) {\n    // First try a direct approach. If a value is queried that also exists then\n    // we can prevent a binary search through the whole list, O(1) vs O(log n)\n\n    const ranges = filterCache.meta.valueRangesAsc\n    const nodes = filterCache.meta.nodesByValueAsc\n\n    const range = ranges!.get(filterValue)\n    if (range) {\n      const arr = nodes!.slice(0, range[1])\n      arr.sort(sortByIds)\n      // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n      if (wasElemMatch) {\n        expensiveDedupeInline(arr)\n      }\n      return arr\n    }\n\n    // Query may ask for a value that doesn't appear in the list, like if the\n    // list is [1, 2, 5, 6] and the query is <= 3. In that case we have to\n    // apply a search (we'll do binary) to determine the offset to slice from.\n\n    // Note: for lte, the valueAsc array must be list at this point\n    const values = filterCache.meta.valuesAsc as Array<FilterValue>\n    // It shouldn't find the targetValue (but it might) and return the index of\n    // the two value between which targetValue sits, or first/last element.\n    const point = binarySearchAsc(values, filterValue)\n    if (!point) {\n      return undefined\n    }\n    const [pivotMin, pivotMax] = point\n\n    // Each pivot index must have a value and a range\n    // The returned min/max index may include the lower/upper bound, so we still\n    // have to do lte checks for both values.\n    let pivotValue = values[pivotMax]\n    if (pivotValue > filterValue) {\n      pivotValue = values[pivotMin]\n    }\n\n    // Note: the pivot value _shouldnt_ match the filter value because that\n    // means the value was actually found, but those should have been indexed\n    // so should have yielded a result in the .get() above.\n\n    const [exclPivot, inclPivot] = ranges!.get(pivotValue) as [number, number]\n\n    // Note: technically, `5 <= \"5\" === true` but `5` would not be cached.\n    // So we have to consider weak comparison and may have to include the pivot\n    const until = pivotValue <= filterValue ? inclPivot : exclPivot\n    const arr = nodes!.slice(0, until)\n    arr.sort(sortByIds)\n    // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n    if (wasElemMatch) {\n      expensiveDedupeInline(arr)\n    }\n    return arr\n  }\n\n  if (op === `$gt`) {\n    // First try a direct approach. If a value is queried that also exists then\n    // we can prevent a binary search through the whole list, O(1) vs O(log n)\n\n    const ranges = filterCache.meta.valueRangesDesc\n    const nodes = filterCache.meta.nodesByValueDesc\n\n    const range = ranges!.get(filterValue)\n    if (range) {\n      const arr = nodes!.slice(0, range[0]).reverse()\n      arr.sort(sortByIds)\n      // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n      if (wasElemMatch) {\n        expensiveDedupeInline(arr)\n      }\n      return arr\n    }\n\n    // Query may ask for a value that doesn't appear in the list, like if the\n    // list is [1, 2, 5, 6] and the query is <= 3. In that case we have to\n    // apply a search (we'll do binary) to determine the offset to slice from.\n\n    // Note: for gte, the valueDesc array must be list at this point\n    const values = filterCache.meta.valuesDesc as Array<FilterValue>\n    // It shouldn't find the targetValue (but it might) and return the index of\n    // the two value between which targetValue sits, or first/last element.\n    const point = binarySearchDesc(values, filterValue)\n    if (!point) {\n      return undefined\n    }\n    const [pivotMin, pivotMax] = point\n\n    // Each pivot index must have a value and a range\n    // The returned min/max index may include the lower/upper bound, so we still\n    // have to do gte checks for both values.\n    let pivotValue = values[pivotMax]\n    if (pivotValue < filterValue) {\n      pivotValue = values[pivotMin]\n    }\n\n    // Note: the pivot value _shouldnt_ match the filter value because that\n    // means the value was actually found, but those should have been indexed\n    // so should have yielded a result in the .get() above.\n\n    const [exclPivot, inclPivot] = ranges!.get(pivotValue) as [number, number]\n\n    // Note: technically, `5 >= \"5\" === true` but `5` would not be cached.\n    // So we have to consider weak comparison and may have to include the pivot\n    const until = pivotValue > filterValue ? inclPivot : exclPivot\n    const arr = nodes!.slice(0, until).reverse()\n    arr.sort(sortByIds)\n    // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n    if (wasElemMatch) {\n      expensiveDedupeInline(arr)\n    }\n    return arr\n  }\n\n  if (op === `$gte`) {\n    // First try a direct approach. If a value is queried that also exists then\n    // we can prevent a binary search through the whole list, O(1) vs O(log n)\n\n    const ranges = filterCache.meta.valueRangesDesc\n    const nodes = filterCache.meta.nodesByValueDesc\n\n    const range = ranges!.get(filterValue)\n    if (range) {\n      const arr = nodes!.slice(0, range[1]).reverse()\n      arr.sort(sortByIds)\n      // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n      if (wasElemMatch) {\n        expensiveDedupeInline(arr)\n      }\n      return arr\n    }\n\n    // Query may ask for a value that doesn't appear in the list, like if the\n    // list is [1, 2, 5, 6] and the query is <= 3. In that case we have to\n    // apply a search (we'll do binary) to determine the offset to slice from.\n\n    // Note: for gte, the valueDesc array must be list at this point\n    const values = filterCache.meta.valuesDesc as Array<FilterValue>\n    // It shouldn't find the targetValue (but it might) and return the index of\n    // the two value between which targetValue sits, or first/last element.\n    const point = binarySearchDesc(values, filterValue)\n    if (!point) {\n      return undefined\n    }\n    const [pivotMin, pivotMax] = point\n\n    // Each pivot index must have a value and a range\n    // The returned min/max index may include the lower/upper bound, so we still\n    // have to do gte checks for both values.\n    let pivotValue = values[pivotMax]\n    if (pivotValue < filterValue) {\n      pivotValue = values[pivotMin]\n    }\n\n    // Note: the pivot value _shouldnt_ match the filter value because that\n    // means the value was actually found, but those should have been indexed\n    // so should have yielded a result in the .get() above.\n\n    const [exclPivot, inclPivot] = ranges!.get(pivotValue) as [number, number]\n\n    // Note: technically, `5 >= \"5\" === true` but `5` would not be cached.\n    // So we have to consider weak comparison and may have to include the pivot\n    const until = pivotValue >= filterValue ? inclPivot : exclPivot\n    const arr = nodes!.slice(0, until).reverse()\n    arr.sort(sortByIds)\n    // elemMatch can cause a node to appear in multiple buckets so we must dedupe\n    if (wasElemMatch) {\n      expensiveDedupeInline(arr)\n    }\n    return arr\n  }\n\n  // Unreachable because we checked all values of FilterOp (which op is)\n  return undefined\n}\n\nfunction removeBucketFromSet(\n  filterValue: FilterValueNullable,\n  filterCache: IFilterCache,\n  set: Set<IGatsbyNodePartial>\n): void {\n  if (filterValue === null) {\n    // Edge case: $ne with `null` returns only the nodes that contain the full\n    // path and that don't resolve to null, so drop `undefined` as well.\n    let cache = filterCache.byValue.get(undefined)\n    if (cache) cache.forEach(node => set.delete(node))\n    cache = filterCache.byValue.get(null)\n    if (cache) cache.forEach(node => set.delete(node))\n  } else {\n    // Not excluding null so it should include undefined leafs or leafs where\n    // only the partial path exists for whatever reason.\n    const cache = filterCache.byValue.get(filterValue)\n    if (cache) cache.forEach(node => set.delete(node))\n  }\n}\n\n/**\n * Finds the intersection of two arrays in O(n) with n = min(a.length, b.length)\n * The returned set should not contain duplicate nodes.\n *\n * The input should be ordered by node.internal.counter and it will return a\n * list that is also ordered by node.internal.counter\n */\nexport function intersectNodesByCounter(\n  a: Array<IGatsbyNodePartial>,\n  b: Array<IGatsbyNodePartial>\n): Array<IGatsbyNodePartial> {\n  let pointerA = 0\n  let pointerB = 0\n  // TODO: perf check: is it helpful to init the array to min(maxA,maxB) items?\n  const result: Array<IGatsbyNodePartial> = []\n  const maxA = a.length\n  const maxB = b.length\n  let lastAdded: IGatsbyNodePartial | undefined = undefined // Used to dedupe the list\n\n  while (pointerA < maxA && pointerB < maxB) {\n    const counterA = a[pointerA].internal.counter\n    const counterB = b[pointerB].internal.counter\n\n    if (counterA < counterB) {\n      pointerA++\n    } else if (counterA > counterB) {\n      pointerB++\n    } else {\n      if (a[pointerA].id !== b[pointerB].id) {\n        throw new Error(\n          `Invariant violation: inconsistent node counters detected`\n        )\n      }\n      // nodeA===nodeB. Make sure we didn't just add this node already.\n      // Since input arrays are sorted, the same node should be grouped\n      // back to back, so even if both input arrays contained the same node\n      // twice, this check would prevent the result from getting duplicate nodes\n      if (lastAdded !== a[pointerA]) {\n        result.push(a[pointerA])\n        lastAdded = a[pointerA]\n      }\n      pointerA++\n      pointerB++\n    }\n  }\n\n  return result\n}\n\n/**\n * Merge two lists of nodes.\n * The returned set should not contain duplicate nodes.\n *\n * The input should be ordered by node.internal.counter and it will return a\n * list that is also ordered by node.internal.counter\n */\nexport function unionNodesByCounter(\n  a: Array<IGatsbyNodePartial>,\n  b: Array<IGatsbyNodePartial>\n): Array<IGatsbyNodePartial> {\n  // TODO: perf check: is it helpful to init the array to max(maxA,maxB) items?\n  const arr: Array<IGatsbyNodePartial> = []\n  let lastAdded: IGatsbyNodePartial | undefined = undefined // Used to dedupe the list\n\n  let pointerA = 0\n  let pointerB = 0\n  const maxA = a.length\n  const maxB = b.length\n\n  while (pointerA < maxA && pointerB < maxB) {\n    const counterA = a[pointerA].internal.counter\n    const counterB = b[pointerB].internal.counter\n\n    if (counterA < counterB) {\n      if (lastAdded !== a[pointerA]) {\n        arr.push(a[pointerA])\n        lastAdded = a[pointerA]\n      }\n      pointerA++\n    } else if (counterA > counterB) {\n      if (lastAdded !== b[pointerB]) {\n        arr.push(b[pointerB])\n        lastAdded = b[pointerB]\n      }\n      pointerB++\n    } else {\n      if (lastAdded !== a[pointerA]) {\n        arr.push(a[pointerA])\n        lastAdded = a[pointerA]\n      }\n      pointerA++\n      pointerB++\n    }\n  }\n\n  while (pointerA < maxA) {\n    if (lastAdded !== a[pointerA]) {\n      arr.push(a[pointerA])\n      lastAdded = a[pointerA]\n    }\n    pointerA++\n  }\n\n  while (pointerB < maxB) {\n    if (lastAdded !== b[pointerB]) {\n      arr.push(b[pointerB])\n      lastAdded = b[pointerB]\n    }\n    pointerB++\n  }\n\n  return arr\n}\n\nfunction expensiveDedupeInline(arr: Array<IGatsbyNodePartial>): void {\n  // An elemMatch filter may cause duplicates to appear in a bucket.\n  // Since the bucket is sorted those should now be back to back\n  // Worst case this is a fast O(n) loop that does nothing.\n  let prev: IGatsbyNodePartial | undefined = undefined\n\n  // We copy-on-find because a splice is expensive and we can't use Sets\n\n  let j = 0\n  for (let i = 0; i < arr.length; ++i) {\n    const node = arr[i]\n    if (node !== prev) {\n      // Only start copying the remainder of the list once a dupe is found\n      if (i !== j) {\n        arr[j] = node\n      }\n      ++j\n      prev = node\n    }\n  }\n  arr.length = j\n}\n\nexport function getSortFieldIdentifierKeys(\n  indexFields: Array<string>,\n  resolvedFields: Record<string, any>\n): Array<string> {\n  const dottedFields = objectToDottedField(resolvedFields)\n  const dottedFieldKeys = Object.keys(dottedFields)\n  const fieldKeys = indexFields.map(field => {\n    if (\n      dottedFields[field] ||\n      dottedFieldKeys.some(key => field.startsWith(key))\n    ) {\n      return `__gatsby_resolved.${field}`\n    } else {\n      return field\n    }\n  })\n\n  return fieldKeys\n}\n"],"mappings":";;;;;;;;;;;AACA;AAMA;AAEA;AACA;AA8BA,MAAMA,qBAAqB,GAAG,IAAIC,GAAG,EAGlC;;AAEH;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,oBAAoB,GAAG,CAClCC,IAAsC,EACtCC,WAA0B,EAC1BC,cAAmC,KACZ;EACvB;EACA,MAAMC,QAAQ,GAAI,GAAEH,IAAI,CAACI,EAAG,QAAOJ,IAAI,CAACK,QAAQ,CAACC,OAAQ,EAAC;EAC1D,IAAIC,YAA4C,GAAGC,SAAS;EAC5D,IAAIX,qBAAqB,CAACY,GAAG,CAACN,QAAQ,CAAC,EAAE;IAAA;IACvCI,YAAY,4BAAGV,qBAAqB,CAACa,GAAG,CAACP,QAAQ,CAAC,0DAAnC,sBAAqCQ,KAAK,EAAE;;IAE3D;IACA,IACEJ,YAAY,IACZ,qBACEN,WAAW,CAACW,GAAG,CAACC,KAAK,IACnBN,YAAY,CAAEO,6BAA6B,CAACb,WAAW,CAACQ,GAAG,CAACI,KAAK,CAAC,CACnE,CACF,EACD;MACA,OAAON,YAAY;IACrB;EACF;;EAEA;EACA;EACA,MAAMQ,YAAY,GAAG,CAAC,CAAC;EACvB,MAAMC,aAAa,GAAGT,YAAY,GAC9B,IAAIU,GAAG,CAAC,CACN,GAAGV,YAAY,CAACO,6BAA6B,CAACb,WAAW,EACzD,GAAGA,WAAW,CACf,CAAC,GACF,IAAIgB,GAAG,CAAChB,WAAW,CAAC;EAExB,MAAMiB,YAAY,GAAGC,0BAA0B,CAC7C,CAAC,GAAGH,aAAa,CAAC,EAClBd,cAAc,CACf;EACD,IAAIkB,cAAuC,GACzCpB,IAAI,CAACc,6BAA6B,GAAGN,SAAS,GAAIR,IAAoB;EACxE,IAAIqB,kBAAkB;EAEtB,KAAK,MAAMC,WAAW,IAAIJ,YAAY,EAAE;IACtC,IAAII,WAAW,IAAItB,IAAI,EAAE;MACvBe,YAAY,CAACO,WAAW,CAAC,GAAGtB,IAAI,CAACsB,WAAW,CAAC;IAC/C,CAAC,MAAM;MACL,IAAIA,WAAW,CAACC,UAAU,CAAE,oBAAmB,CAAC,EAAE;QAChD,IAAI,CAACF,kBAAkB,EAAE;UACvBA,kBAAkB,GAAG,IAAAG,wBAAiB,EAACxB,IAAI,CAAC;QAC9C;QAEAe,YAAY,CAACO,WAAW,CAAC,GAAG,IAAAG,sBAAU,EACpCJ,kBAAkB,EAClBC,WAAW,CAACI,KAAK,CAAE,oBAAmB,CAACC,MAAM,CAAC,CAC/C;MACH,CAAC,MAAM;QACL;QACA;QACA,IAAI,CAACP,cAAc,EAAE;UACnBA,cAAc,GAAG,IAAAQ,UAAO,EAAC5B,IAAI,CAACI,EAAE,CAAE;QACpC;QACAW,YAAY,CAACO,WAAW,CAAC,GAAG,IAAAG,sBAAU,EAACL,cAAc,EAAEE,WAAW,CAAC;MACrE;IACF;EACF;;EAEA;EACA,MAAMO,OAAO,GAAGC,MAAM,CAACC,MAAM,CAAChB,YAAY,EAAE;IAC1CX,EAAE,EAAEJ,IAAI,CAACI,EAAE;IACXC,QAAQ,EAAE;MACRC,OAAO,EAAEN,IAAI,CAACK,QAAQ,CAACC,OAAO;MAC9B0B,IAAI,EAAEhC,IAAI,CAACK,QAAQ,CAAC2B;IACtB,CAAC;IACDlB,6BAA6B,EAAE;MAC7Bb,WAAW,EAAEe;IACf;EACF,CAAC,CAAC;;EAEF;EACAnB,qBAAqB,CAACoC,GAAG,CAAC9B,QAAQ,EAAE,IAAI+B,OAAO,CAAqBL,OAAO,CAAC,CAAC;EAE7E,OAAOA,OAAO;AAChB,CAAC;AAAA;AAED,MAAMM,SAAS,GAAG,CAACC,CAAqB,EAAEC,CAAqB,KAC7DD,CAAC,CAAC/B,QAAQ,CAACC,OAAO,GAAG+B,CAAC,CAAChC,QAAQ,CAACC,OAAO;AAiClC,SAASgC,qBAAqB,CACnCC,WAAyB,EACzBC,EAAY,EACN;EACN;EACA;EACA,KAAK,MAAMC,MAAM,IAAIF,WAAW,CAACG,OAAO,EAAE;IACxCD,MAAM,CAAC,CAAC,CAAC,CAACE,IAAI,CAACR,SAAS,CAAC;EAC3B;EAEA,IAAIK,EAAE,KAAM,KAAI,IAAIA,EAAE,KAAM,MAAK,EAAE;IACjCI,0BAA0B,CAACL,WAAW,CAAC;EACzC,CAAC,MAAM,IAAI,CAAE,KAAI,EAAG,MAAK,EAAG,KAAI,EAAG,MAAK,CAAC,CAACM,QAAQ,CAACL,EAAE,CAAC,EAAE;IACtDM,+BAA+B,CAACP,WAAW,EAAEC,EAAE,CAAC;EAClD;AACF;AAEA,SAASI,0BAA0B,CAACL,WAAyB,EAAQ;EACnE;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA,MAAMQ,GAA8B,GAAG,EAAE;EACzCR,WAAW,CAACS,IAAI,CAACC,cAAc,GAAGF,GAAG;EACrCR,WAAW,CAACG,OAAO,CAACQ,OAAO,CAACC,CAAC,IAAI;IAC/BA,CAAC,CAACD,OAAO,CAACE,MAAM,IAAI;MAClBL,GAAG,CAACM,IAAI,CAACD,MAAM,CAAC;IAClB,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ;AAEA,SAASN,+BAA+B,CACtCP,WAAyB,EACzBC,EAAY,EACN;EACN;EACA;EACA;EACA;;EAEA,MAAMc,eAEL,GAAG,CAAC,GAAGf,WAAW,CAACG,OAAO,CAACa,OAAO,EAAE,CAAC;;EAEtC;EACA;EACA,MAAMA,OAAwD,GAC5DD,eAAe,CAACE,MAAM,CAAC,CAAC,CAACL,CAAC,CAAC,KAAKA,CAAC,IAAI,IAAI,CAExC;;EAEH;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,IAAIX,EAAE,KAAM,KAAI,IAAIA,EAAE,KAAM,MAAK,EAAE;IACjC;IACAe,OAAO,CAACZ,IAAI,CAAC,CAAC,CAACP,CAAC,CAAC,EAAE,CAACC,CAAC,CAAC,KAAMD,CAAC,GAAGC,CAAC,GAAG,CAAC,CAAC,GAAGD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;EAC1D,CAAC,MAAM,IAAIG,EAAE,KAAM,KAAI,IAAIA,EAAE,KAAM,MAAK,EAAE;IACxC;IACAe,OAAO,CAACZ,IAAI,CAAC,CAAC,CAACP,CAAC,CAAC,EAAE,CAACC,CAAC,CAAC,KAAMD,CAAC,GAAGC,CAAC,GAAG,CAAC,CAAC,GAAGD,CAAC,GAAGC,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;EAC1D;EAEA,MAAMoB,YAAuC,GAAG,EAAE;EAClD,MAAMC,aAAiC,GAAG,EAAE;EAC5C,MAAMC,OAA2C,GAAG,IAAI7D,GAAG,EAAE;EAC7DyD,OAAO,CAACL,OAAO,CAAC,CAAC,CAACC,CAAC,EAAEV,MAAM,CAA2C,KAAK;IACzE;IACA;IACA;IACAkB,OAAO,CAAC1B,GAAG,CAACkB,CAAC,EAAE,CAACM,YAAY,CAAC9B,MAAM,EAAE8B,YAAY,CAAC9B,MAAM,GAAGc,MAAM,CAACd,MAAM,CAAC,CAAC;IAC1E;IACA;IACAc,MAAM,CAACS,OAAO,CAAClD,IAAI,IAAIyD,YAAY,CAACJ,IAAI,CAACrD,IAAI,CAAC,CAAC;IAC/C0D,aAAa,CAACL,IAAI,CAACF,CAAC,CAAC;EACvB,CAAC,CAAC;EAEF,IAAIX,EAAE,KAAM,KAAI,IAAIA,EAAE,KAAM,MAAK,EAAE;IACjCD,WAAW,CAACS,IAAI,CAACY,SAAS,GAAGF,aAAa;IAC1CnB,WAAW,CAACS,IAAI,CAACa,eAAe,GAAGJ,YAAY;IAC/C;IACA;IACA;IACAlB,WAAW,CAACS,IAAI,CAACc,cAAc,GAAGH,OAAO;EAC3C,CAAC,MAAM,IAAInB,EAAE,KAAM,KAAI,IAAIA,EAAE,KAAM,MAAK,EAAE;IACxCD,WAAW,CAACS,IAAI,CAACe,UAAU,GAAGL,aAAa;IAC3CnB,WAAW,CAACS,IAAI,CAACgB,gBAAgB,GAAGP,YAAY;IAChD;IACA;IACA;IACAlB,WAAW,CAACS,IAAI,CAACiB,eAAe,GAAGN,OAAO;EAC5C;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMO,kBAAkB,GAAG,CAChC1B,EAAY,EACZ2B,cAA8B,EAC9BC,UAAyB,EACzBC,aAA4B,EAC5BC,YAA0B,EAC1BrE,WAA0B,EAC1BC,cAAmC,KAC1B;EACT,MAAMqC,WAAyB,GAAG;IAChCC,EAAE;IACFE,OAAO,EAAE,IAAI5C,GAAG,EAAkD;IAClEkD,IAAI,EAAE,CAAC;EACT,CAAiB;EACjBsB,YAAY,CAACrC,GAAG,CAACkC,cAAc,EAAE5B,WAAW,CAAC;;EAE7C;EACA;EACA;;EAEA,IAAI8B,aAAa,CAAC1C,MAAM,KAAK,CAAC,EAAE;IAC9B,IAAA4C,eAAY,GAAE,CACXC,kBAAkB,CAACH,aAAa,CAAC,CAAC,CAAC,CAAC,CACpCnB,OAAO,CAAClD,IAAI,IAAI;MACfyE,oBAAoB,CAAC;QACnBzE,IAAI;QACJ0E,KAAK,EAAEN,UAAU;QACjB7B,WAAW;QACXtC,WAAW;QACXC;MACF,CAAC,CAAC;IACJ,CAAC,CAAC;EACN,CAAC,MAAM;IACL;IACA;IACA,IAAAqE,eAAY,GAAE,CACXI,YAAY,EAAE,CACdzB,OAAO,CAAClD,IAAI,IAAI;MACf,IAAI,CAACqE,aAAa,CAACxB,QAAQ,CAAC7C,IAAI,CAACK,QAAQ,CAAC2B,IAAI,CAAC,EAAE;QAC/C;MACF;MAEAyC,oBAAoB,CAAC;QACnBzE,IAAI;QACJ0E,KAAK,EAAEN,UAAU;QACjB7B,WAAW;QACXtC,WAAW;QACXC;MACF,CAAC,CAAC;IACJ,CAAC,CAAC;EACN;EAEAoC,qBAAqB,CAACC,WAAW,EAAEC,EAAE,CAAC;AACxC,CAAC;AAAA;AAEM,SAASoC,sBAAsB,CACpCT,cAAc,EACdE,aAA4B,EAC5BC,YAA0B,EAC1BrE,WAA0B,EAC1BC,cAAmC,EAC7B;EACN;EACA;EACA;;EAEA,MAAM2E,gBAA2C,GAAG,EAAE;EAEtDP,YAAY,CAACrC,GAAG,CAACkC,cAAc,EAAE;IAC/B3B,EAAE,EAAG,KAAI;IAAE;IACXE,OAAO,EAAE,IAAI5C,GAAG,EAAkD;IAClEkD,IAAI,EAAE;MACJ6B,gBAAgB,CAAE;IACpB;EACF,CAAC,CAAC;;EAEF,IAAIR,aAAa,CAAC1C,MAAM,KAAK,CAAC,EAAE;IAC9B,IAAA4C,eAAY,GAAE,CACXC,kBAAkB,CAACH,aAAa,CAAC,CAAC,CAAC,CAAC,CACpCnB,OAAO,CAAClD,IAAI,IAAI;MACf6E,gBAAgB,CAACxB,IAAI,CACnBtD,oBAAoB,CAACC,IAAI,EAAEC,WAAW,EAAEC,cAAc,CAAC,CACxD;IACH,CAAC,CAAC;EACN,CAAC,MAAM;IACL;IACA;IACA,IAAAqE,eAAY,GAAE,CACXI,YAAY,EAAE,CACdzB,OAAO,CAAClD,IAAI,IAAI;MACf,IAAIqE,aAAa,CAACxB,QAAQ,CAAC7C,IAAI,CAACK,QAAQ,CAAC2B,IAAI,CAAC,EAAE;QAC9C6C,gBAAgB,CAACxB,IAAI,CACnBtD,oBAAoB,CAACC,IAAI,EAAEC,WAAW,EAAEC,cAAc,CAAC,CACxD;MACH;IACF,CAAC,CAAC;EACN;;EAEA;EACA;EACA2E,gBAAgB,CAAClC,IAAI,CAACR,SAAS,CAAC;AAClC;AAEA,SAASsC,oBAAoB,CAAC;EAC5BzE,IAAI;EACJ0E,KAAK;EACLnC,WAAW;EACXtC,WAAW;EACXC,cAAc;EACd4E,WAAW,GAAG9E;AAQhB,CAAC,EAAQ;EACP;EACA;EACA,IAAImD,CAAC,GAAG2B,WAAkB;EAC1B,IAAIC,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,GAAGL,KAAK,CAAC/C,MAAM,IAAIwB,CAAC,EAAE;IAC5B,MAAM6B,QAAQ,GAAGN,KAAK,CAACK,CAAC,EAAE,CAAC;IAC3B,IAAIA,CAAC,KAAK,CAAC,IAAIC,QAAQ,KAAM,mBAAkB,EAAE;MAC/C7B,CAAC,GAAG,IAAA3B,wBAAiB,EAAC2B,CAAC,CAAC;IAC1B,CAAC,MAAM;MACLA,CAAC,GAAGA,CAAC,CAAC6B,QAAQ,CAAC;IACjB;EACF;EAEA,IACG,OAAO7B,CAAC,KAAM,QAAO,IACpB,OAAOA,CAAC,KAAM,QAAO,IACrB,OAAOA,CAAC,KAAM,SAAQ,IACtBA,CAAC,KAAK,IAAI,IACZ4B,CAAC,KAAKL,KAAK,CAAC/C,MAAM,EAClB;IACA,IAAIoD,CAAC,KAAKL,KAAK,CAAC/C,MAAM,IAAIsD,KAAK,CAACC,OAAO,CAAC/B,CAAC,CAAC,EAAE;MAC1C;MACA;MACA;;MAEAA,CAAC,CAACD,OAAO,CAACC,CAAC,IACTgC,gBAAgB,CAAC5C,WAAW,EAAEvC,IAAI,EAAEmD,CAAC,EAAElD,WAAW,EAAEC,cAAc,CAAC,CACpE;MAED;IACF;;IAEA;IACA;IACA;IACA;IACAiD,CAAC,GAAG3C,SAAS;EACf;EAEA2E,gBAAgB,CAAC5C,WAAW,EAAEvC,IAAI,EAAEmD,CAAC,EAAElD,WAAW,EAAEC,cAAc,CAAC;AACrE;AAEA,SAASiF,gBAAgB,CACvB5C,WAAyB,EACzBvC,IAAiB,EACjBoF,KAA0B,EAC1BnF,WAA0B,EAC1BC,cAAmC,EAC7B;EACN,IAAI6C,GAAG,GAAGR,WAAW,CAACG,OAAO,CAAChC,GAAG,CAAC0E,KAAK,CAAC;EACxC,IAAI,CAACrC,GAAG,EAAE;IACRA,GAAG,GAAG,EAAE;IACRR,WAAW,CAACG,OAAO,CAACT,GAAG,CAACmD,KAAK,EAAErC,GAAG,CAAC;EACrC;EAEA,MAAMlB,OAAO,GAAG9B,oBAAoB,CAACC,IAAI,EAAEC,WAAW,EAAEC,cAAc,CAAC;EACvE,IAAI,CAAC6C,GAAG,CAACF,QAAQ,CAAChB,OAAO,CAAC,EAAE;IAC1BkB,GAAG,CAACM,IAAI,CAACxB,OAAO,CAAC;EACnB;AACF;AAEO,MAAMwD,sBAAsB,GAAG,CACpC7C,EAAY,EACZ2B,cAA8B,EAC9BX,MAAyB,EACzBa,aAA4B,EAC5BC,YAA0B,EAC1BrE,WAA0B,EAC1BC,cAAmC,KAC1B;EACT;EACA;;EAEA,MAAMqC,WAAyB,GAAG;IAChCC,EAAE;IACFE,OAAO,EAAE,IAAI5C,GAAG,EAAkD;IAClEkD,IAAI,EAAE,CAAC;EACT,CAAiB;EACjBsB,YAAY,CAACrC,GAAG,CAACkC,cAAc,EAAE5B,WAAW,CAAC;EAE7C,IAAI8B,aAAa,CAAC1C,MAAM,KAAK,CAAC,EAAE;IAC9B,IAAA4C,eAAY,GAAE,CACXC,kBAAkB,CAACH,aAAa,CAAC,CAAC,CAAC,CAAC,CACpCnB,OAAO,CAAClD,IAAI,IAAI;MACfsF,4BAA4B,CAAC;QAC3BtF,IAAI;QACJuF,kBAAkB,EAAEvF,IAAI;QACxBwD,MAAM;QACNjB,WAAW;QACXtC,WAAW;QACXC;MACF,CAAC,CAAC;IACJ,CAAC,CAAC;EACN,CAAC,MAAM;IACL;IACA,IAAAqE,eAAY,GAAE,CACXI,YAAY,EAAE,CACdzB,OAAO,CAAClD,IAAI,IAAI;MACf,IAAI,CAACqE,aAAa,CAACxB,QAAQ,CAAC7C,IAAI,CAACK,QAAQ,CAAC2B,IAAI,CAAC,EAAE;QAC/C;MACF;MAEAsD,4BAA4B,CAAC;QAC3BtF,IAAI;QACJuF,kBAAkB,EAAEvF,IAAI;QACxBwD,MAAM;QACNjB,WAAW;QACXtC,WAAW;QACXC;MACF,CAAC,CAAC;IACJ,CAAC,CAAC;EACN;EAEAoC,qBAAqB,CAACC,WAAW,EAAEC,EAAE,CAAC;AACxC,CAAC;AAAA;AAED,SAAS8C,4BAA4B,CAAC;EACpCtF,IAAI;EACJuF,kBAAkB;EAAE;EACpB/B,MAAM;EACNjB,WAAW;EACXtC,WAAW;EACXC;AAQF,CAAC,EAAQ;EACP,MAAM;IAAEsF,IAAI;IAAEC;EAAY,CAAC,GAAGjC,MAAM;;EAEpC;EACA,IAAIuB,CAAC,GAAG,CAAC;EACT,OAAOA,CAAC,GAAGS,IAAI,CAAC7D,MAAM,IAAI4D,kBAAkB,EAAE;IAC5C,MAAMP,QAAQ,GAAGQ,IAAI,CAACT,CAAC,EAAE,CAAC;IAC1B,IAAIA,CAAC,KAAK,CAAC,IAAIC,QAAQ,KAAM,mBAAkB,EAAE;MAC/CO,kBAAkB,GAAG,IAAA/D,wBAAiB,EAAC+D,kBAAkB,CAAC;IAC5D,CAAC,MAAM;MACLA,kBAAkB,GAAGA,kBAAkB,CAACP,QAAQ,CAAC;IACnD;EACF;EAEA,IAAIQ,IAAI,CAAC7D,MAAM,KAAKoD,CAAC,EAAE;IACrB;IACA;EACF;;EAEA;EACA,IAAI,CAACE,KAAK,CAACC,OAAO,CAACK,kBAAkB,CAAC,EAAE;IACtC;IACAA,kBAAkB,GAAG,CAACA,kBAAkB,CAAC;EAC3C;;EAEA;EACA;EACA;EACA;EACAA,kBAAkB,CAACrC,OAAO,CAACwC,IAAI,IAAI;IACjC,IAAID,WAAW,CAACzD,IAAI,KAAM,WAAU,EAAE;MACpCsD,4BAA4B,CAAC;QAC3BtF,IAAI;QACJuF,kBAAkB,EAAEG,IAAI;QACxBlC,MAAM,EAAEiC,WAAW;QACnBlD,WAAW;QACXtC,WAAW;QACXC;MACF,CAAC,CAAC;IACJ,CAAC,MAAM;MACL;MACAuE,oBAAoB,CAAC;QACnBzE,IAAI;QACJ0E,KAAK,EAAEe,WAAW,CAACD,IAAI;QACvBjD,WAAW;QACXtC,WAAW;QACXC,cAAc;QACd4E,WAAW,EAAEY;MACf,CAAC,CAAC;IACJ;EACF,CAAC,CAAC;AACJ;AAEA,MAAMC,eAAe,GAAG,CACtBC,MAA0B,EAC1BC,MAAmB,KACc;EACjC,IAAIC,GAAG,GAAG,CAAC;EACX,IAAIC,GAAG,GAAGH,MAAM,CAACjE,MAAM,GAAG,CAAC;EAC3B,IAAIqE,KAAK,GAAGC,IAAI,CAACC,KAAK,CAACN,MAAM,CAACjE,MAAM,GAAG,CAAC,CAAC;EACzC,OAAOmE,GAAG,IAAIC,GAAG,EAAE;IACjB,MAAMX,KAAK,GAAGQ,MAAM,CAACI,KAAK,CAAC;IAC3B,IAAIH,MAAM,GAAGT,KAAK,EAAE;MAClB;MACA;MACAW,GAAG,GAAGC,KAAK;IACb,CAAC,MAAM,IAAIH,MAAM,GAAGT,KAAK,EAAE;MACzB;MACA;MACAU,GAAG,GAAGE,KAAK;IACb,CAAC,MAAM;MACL;MACA;MACA,OAAO,CAACA,KAAK,EAAEA,KAAK,CAAC;IACvB;IAEA,IAAID,GAAG,GAAGD,GAAG,IAAI,CAAC,EAAE;MAClB;MACA;MACA,OAAO,CAACA,GAAG,EAAEC,GAAG,CAAC;IACnB;IAEAC,KAAK,GAAGF,GAAG,GAAGG,IAAI,CAACC,KAAK,CAAC,CAACH,GAAG,GAAGD,GAAG,IAAI,CAAC,CAAC;EAC3C;;EAEA;EACA,OAAOtF,SAAS;AAClB,CAAC;AACD,MAAM2F,gBAAgB,GAAG,CACvBP,MAA0B,EAC1BC,MAAmB,KACc;EACjC,IAAIC,GAAG,GAAG,CAAC;EACX,IAAIC,GAAG,GAAGH,MAAM,CAACjE,MAAM,GAAG,CAAC;EAC3B,IAAIqE,KAAK,GAAGC,IAAI,CAACC,KAAK,CAACN,MAAM,CAACjE,MAAM,GAAG,CAAC,CAAC;EACzC,OAAOmE,GAAG,IAAIC,GAAG,EAAE;IACjB,MAAMX,KAAK,GAAGQ,MAAM,CAACI,KAAK,CAAC;IAC3B,IAAIH,MAAM,GAAGT,KAAK,EAAE;MAClB;MACA;MACAU,GAAG,GAAGE,KAAK;IACb,CAAC,MAAM,IAAIH,MAAM,GAAGT,KAAK,EAAE;MACzB;MACA;MACAW,GAAG,GAAGC,KAAK;IACb,CAAC,MAAM;MACL;MACA;MACA,OAAO,CAACA,KAAK,EAAEA,KAAK,CAAC;IACvB;IAEA,IAAID,GAAG,GAAGD,GAAG,IAAI,CAAC,EAAE;MAClB;MACA;MACA,OAAO,CAACA,GAAG,EAAEC,GAAG,CAAC;IACnB;IAEAC,KAAK,GAAGF,GAAG,GAAGG,IAAI,CAACC,KAAK,CAAC,CAACH,GAAG,GAAGD,GAAG,IAAI,CAAC,CAAC;EAC3C;;EAEA;EACA,OAAOtF,SAAS;AAClB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAM4F,wBAAwB,GAAG,CACtCjC,cAA8B,EAC9BkC,WAAgC,EAChC/B,YAA0B,EAC1BgC,YAAY,KAC8B;EAC1C,MAAM/D,WAAW,GAAG+B,YAAY,CAAC5D,GAAG,CAACyD,cAAc,CAAC;EACpD,IAAI,CAAC5B,WAAW,EAAE;IAChB,OAAO/B,SAAS;EAClB;EAEA,MAAMgC,EAAE,GAAGD,WAAW,CAACC,EAAE;EAEzB,IAAIA,EAAE,KAAM,KAAI,EAAE;IAChB;;IAEA,IAAI6D,WAAW,IAAI,IAAI,EAAE;MAAA;MACvB;MACA;MACA;;MAEA,MAAME,OAAO,4BAAGhE,WAAW,CAACG,OAAO,CAAChC,GAAG,CAAC,IAAI,CAAC,yEAAI,EAAE;MACnD,MAAM8F,QAAQ,6BAAGjE,WAAW,CAACG,OAAO,CAAChC,GAAG,CAACF,SAAS,CAAC,2EAAI,EAAE;;MAEzD;MACA;MACA,OAAOiG,mBAAmB,CAACF,OAAO,EAAEC,QAAQ,CAAC;IAC/C;IAEA,OAAOjE,WAAW,CAACG,OAAO,CAAChC,GAAG,CAAC2F,WAAW,CAAC;EAC7C;EAEA,IAAI7D,EAAE,KAAM,KAAI,EAAE;IAChB,IAAI,CAACyC,KAAK,CAACC,OAAO,CAACmB,WAAW,CAAC,EAAE;MAC/B,MAAM,IAAIK,KAAK,CAAC,wDAAwD,CAAC;IAC3E;IACA,MAAMC,cAA0C,GAAGN,WAAW;IAE9D,MAAMpE,GAA4B,GAAG,IAAIhB,GAAG,EAAE;;IAE9C;IACA;IACA;IACA0F,cAAc,CAACzD,OAAO,CAAEC,CAAsB;MAAA;MAAA,iCAC5CZ,WAAW,CAACG,OAAO,CAAChC,GAAG,CAACyC,CAAC,CAAC,2DAA1B,uBAA4BD,OAAO,CAACC,CAAC,IAAIlB,GAAG,CAAC2E,GAAG,CAACzD,CAAC,CAAC,CAAC;IAAA,EACrD;IAED,MAAMJ,GAAG,GAAG,CAAC,GAAGd,GAAG,CAAC,EAAC;IACrBc,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;;IAEnB;IACA,IAAIwE,cAAc,CAAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE;MACjC;MACA;MACA,MAAMgE,KAAK,GAAGtE,WAAW,CAACG,OAAO,CAAChC,GAAG,CAACF,SAAS,CAAC;MAChD,IAAIqG,KAAK,EAAE;QACT;QACA,OAAOJ,mBAAmB,CAACI,KAAK,EAAE9D,GAAG,CAAC;MACxC;IACF;;IAEA;IACA,IAAIuD,YAAY,EAAE;MAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;IAC5B;IAEA,OAAOA,GAAG;EACZ;EAEA,IAAIP,EAAE,KAAM,MAAK,EAAE;IACjB;IACA;;IAEA,IAAI,CAACyC,KAAK,CAACC,OAAO,CAACmB,WAAW,CAAC,EAAE;MAC/B,MAAM,IAAIK,KAAK,CAAE,6CAA4C,CAAC;IAChE;IAEA,MAAMd,MAAgC,GAAG,IAAI3E,GAAG,CAACoF,WAAW,CAAC;IAC7D,MAAMpE,GAAG,GAAG,IAAIhB,GAAG,CAACsB,WAAW,CAACS,IAAI,CAACC,cAAc,CAAC;;IAEpD;IACA2C,MAAM,CAAC1C,OAAO,CAACmD,WAAW,IAAI;MAC5BU,mBAAmB,CAACV,WAAW,EAAE9D,WAAW,EAAEN,GAAG,CAAC;IACpD,CAAC,CAAC;;IAEF;IACA;IACA,OAAO,CAAC,GAAGA,GAAG,CAAC,CAACU,IAAI,CAACR,SAAS,CAAC;EACjC;EAEA,IAAIK,EAAE,KAAM,KAAI,EAAE;IAChB,MAAMP,GAAG,GAAG,IAAIhB,GAAG,CAACsB,WAAW,CAACS,IAAI,CAACC,cAAc,CAAC;IAEpD8D,mBAAmB,CAACV,WAAW,EAAE9D,WAAW,EAAEN,GAAG,CAAC;;IAElD;IACA;IACA,OAAO,CAAC,GAAGA,GAAG,CAAC,CAACU,IAAI,CAACR,SAAS,CAAC;EACjC;EAEA,IAAIK,EAAE,KAAM,QAAO,EAAE;IACnB;IACA;;IAEA;IACA;;IAEA,IAAI,EAAE6D,WAAW,YAAYW,MAAM,CAAC,EAAE;MACpC,MAAM,IAAIN,KAAK,CACZ,mEAAkE,CACpE;IACH;IACA,MAAMO,KAAK,GAAGZ,WAAW;IAEzB,MAAMtD,GAA8B,GAAG,EAAE;IACzCR,WAAW,CAACG,OAAO,CAACQ,OAAO,CAAC,CAAC2D,KAAK,EAAEzB,KAAK,KAAK;MAC5C;MACA;MACA,IAAIA,KAAK,KAAK5E,SAAS,IAAIyG,KAAK,CAACC,IAAI,CAACC,MAAM,CAAC/B,KAAK,CAAC,CAAC,EAAE;QACpDyB,KAAK,CAAC3D,OAAO,CAAClD,IAAI,IAAI+C,GAAG,CAACM,IAAI,CAACrD,IAAI,CAAC,CAAC;MACvC;IACF,CAAC,CAAC;;IAEF;IACA;;IAEA+C,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;;IAEnB;IACA,IAAImE,YAAY,EAAE;MAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;IAC5B;IAEA,OAAOA,GAAG;EACZ;EAEA,IAAIsD,WAAW,IAAI,IAAI,EAAE;IACvB,IAAI7D,EAAE,KAAM,KAAI,IAAIA,EAAE,KAAM,KAAI,EAAE;MAChC;MACA,OAAOhC,SAAS;IAClB;;IAEA;IACA;IACA,OAAO+B,WAAW,CAACG,OAAO,CAAChC,GAAG,CAAC2F,WAAW,CAAC;EAC7C;EAEA,IAAIpB,KAAK,CAACC,OAAO,CAACmB,WAAW,CAAC,EAAE;IAC9B,MAAM,IAAIK,KAAK,CACb,4CAA4C,GAAGlE,EAAE,GAAG,cAAc,CACnE;EACH;EAEA,IAAI6D,WAAW,YAAYW,MAAM,EAAE;IACjC;IACA;IACA,MAAM,IAAIN,KAAK,CACZ,kEAAiE,CACnE;EACH;EAEA,IAAIlE,EAAE,KAAM,KAAI,EAAE;IAChB;IACA;;IAEA,MAAM4E,MAAM,GAAG7E,WAAW,CAACS,IAAI,CAACc,cAAc;IAC9C,MAAM+C,KAAK,GAAGtE,WAAW,CAACS,IAAI,CAACa,eAAe;IAE9C,MAAMwD,KAAK,GAAGD,MAAM,CAAE1G,GAAG,CAAC2F,WAAW,CAAC;IACtC,IAAIgB,KAAK,EAAE;MACT,MAAMtE,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAE2F,KAAK,CAAC,CAAC,CAAC,CAAC;MACrCtE,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;MACnB;MACA,IAAImE,YAAY,EAAE;QAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;MAC5B;MACA,OAAOA,GAAG;IACZ;;IAEA;IACA;IACA;;IAEA;IACA,MAAM6C,MAAM,GAAGrD,WAAW,CAACS,IAAI,CAACY,SAA+B;IAC/D;IACA;IACA,MAAM0D,KAAK,GAAG3B,eAAe,CAACC,MAAM,EAAES,WAAW,CAAC;IAClD,IAAI,CAACiB,KAAK,EAAE;MACV,OAAO9G,SAAS;IAClB;IACA,MAAM,CAAC+G,QAAQ,EAAEC,QAAQ,CAAC,GAAGF,KAAK;;IAElC;IACA;IACA;IACA,IAAIG,UAAU,GAAG7B,MAAM,CAAC4B,QAAQ,CAAC;IACjC,IAAIC,UAAU,GAAGpB,WAAW,EAAE;MAC5BoB,UAAU,GAAG7B,MAAM,CAAC2B,QAAQ,CAAC;IAC/B;;IAEA;IACA;IACA;;IAEA,MAAM,CAACG,SAAS,EAAEC,SAAS,CAAC,GAAGP,MAAM,CAAE1G,GAAG,CAAC+G,UAAU,CAAqB;;IAE1E;IACA;IACA,MAAMG,KAAK,GAAGH,UAAU,GAAGpB,WAAW,GAAGsB,SAAS,GAAGD,SAAS;IAC9D,MAAM3E,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAEkG,KAAK,CAAC;IAClC7E,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;IACnB;IACA,IAAImE,YAAY,EAAE;MAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;IAC5B;IACA,OAAOA,GAAG;EACZ;EAEA,IAAIP,EAAE,KAAM,MAAK,EAAE;IACjB;IACA;;IAEA,MAAM4E,MAAM,GAAG7E,WAAW,CAACS,IAAI,CAACc,cAAc;IAC9C,MAAM+C,KAAK,GAAGtE,WAAW,CAACS,IAAI,CAACa,eAAe;IAE9C,MAAMwD,KAAK,GAAGD,MAAM,CAAE1G,GAAG,CAAC2F,WAAW,CAAC;IACtC,IAAIgB,KAAK,EAAE;MACT,MAAMtE,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAE2F,KAAK,CAAC,CAAC,CAAC,CAAC;MACrCtE,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;MACnB;MACA,IAAImE,YAAY,EAAE;QAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;MAC5B;MACA,OAAOA,GAAG;IACZ;;IAEA;IACA;IACA;;IAEA;IACA,MAAM6C,MAAM,GAAGrD,WAAW,CAACS,IAAI,CAACY,SAA+B;IAC/D;IACA;IACA,MAAM0D,KAAK,GAAG3B,eAAe,CAACC,MAAM,EAAES,WAAW,CAAC;IAClD,IAAI,CAACiB,KAAK,EAAE;MACV,OAAO9G,SAAS;IAClB;IACA,MAAM,CAAC+G,QAAQ,EAAEC,QAAQ,CAAC,GAAGF,KAAK;;IAElC;IACA;IACA;IACA,IAAIG,UAAU,GAAG7B,MAAM,CAAC4B,QAAQ,CAAC;IACjC,IAAIC,UAAU,GAAGpB,WAAW,EAAE;MAC5BoB,UAAU,GAAG7B,MAAM,CAAC2B,QAAQ,CAAC;IAC/B;;IAEA;IACA;IACA;;IAEA,MAAM,CAACG,SAAS,EAAEC,SAAS,CAAC,GAAGP,MAAM,CAAE1G,GAAG,CAAC+G,UAAU,CAAqB;;IAE1E;IACA;IACA,MAAMG,KAAK,GAAGH,UAAU,IAAIpB,WAAW,GAAGsB,SAAS,GAAGD,SAAS;IAC/D,MAAM3E,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAEkG,KAAK,CAAC;IAClC7E,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;IACnB;IACA,IAAImE,YAAY,EAAE;MAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;IAC5B;IACA,OAAOA,GAAG;EACZ;EAEA,IAAIP,EAAE,KAAM,KAAI,EAAE;IAChB;IACA;;IAEA,MAAM4E,MAAM,GAAG7E,WAAW,CAACS,IAAI,CAACiB,eAAe;IAC/C,MAAM4C,KAAK,GAAGtE,WAAW,CAACS,IAAI,CAACgB,gBAAgB;IAE/C,MAAMqD,KAAK,GAAGD,MAAM,CAAE1G,GAAG,CAAC2F,WAAW,CAAC;IACtC,IAAIgB,KAAK,EAAE;MACT,MAAMtE,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAE2F,KAAK,CAAC,CAAC,CAAC,CAAC,CAACQ,OAAO,EAAE;MAC/C9E,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;MACnB;MACA,IAAImE,YAAY,EAAE;QAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;MAC5B;MACA,OAAOA,GAAG;IACZ;;IAEA;IACA;IACA;;IAEA;IACA,MAAM6C,MAAM,GAAGrD,WAAW,CAACS,IAAI,CAACe,UAAgC;IAChE;IACA;IACA,MAAMuD,KAAK,GAAGnB,gBAAgB,CAACP,MAAM,EAAES,WAAW,CAAC;IACnD,IAAI,CAACiB,KAAK,EAAE;MACV,OAAO9G,SAAS;IAClB;IACA,MAAM,CAAC+G,QAAQ,EAAEC,QAAQ,CAAC,GAAGF,KAAK;;IAElC;IACA;IACA;IACA,IAAIG,UAAU,GAAG7B,MAAM,CAAC4B,QAAQ,CAAC;IACjC,IAAIC,UAAU,GAAGpB,WAAW,EAAE;MAC5BoB,UAAU,GAAG7B,MAAM,CAAC2B,QAAQ,CAAC;IAC/B;;IAEA;IACA;IACA;;IAEA,MAAM,CAACG,SAAS,EAAEC,SAAS,CAAC,GAAGP,MAAM,CAAE1G,GAAG,CAAC+G,UAAU,CAAqB;;IAE1E;IACA;IACA,MAAMG,KAAK,GAAGH,UAAU,GAAGpB,WAAW,GAAGsB,SAAS,GAAGD,SAAS;IAC9D,MAAM3E,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAEkG,KAAK,CAAC,CAACC,OAAO,EAAE;IAC5C9E,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;IACnB;IACA,IAAImE,YAAY,EAAE;MAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;IAC5B;IACA,OAAOA,GAAG;EACZ;EAEA,IAAIP,EAAE,KAAM,MAAK,EAAE;IACjB;IACA;;IAEA,MAAM4E,MAAM,GAAG7E,WAAW,CAACS,IAAI,CAACiB,eAAe;IAC/C,MAAM4C,KAAK,GAAGtE,WAAW,CAACS,IAAI,CAACgB,gBAAgB;IAE/C,MAAMqD,KAAK,GAAGD,MAAM,CAAE1G,GAAG,CAAC2F,WAAW,CAAC;IACtC,IAAIgB,KAAK,EAAE;MACT,MAAMtE,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAE2F,KAAK,CAAC,CAAC,CAAC,CAAC,CAACQ,OAAO,EAAE;MAC/C9E,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;MACnB;MACA,IAAImE,YAAY,EAAE;QAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;MAC5B;MACA,OAAOA,GAAG;IACZ;;IAEA;IACA;IACA;;IAEA;IACA,MAAM6C,MAAM,GAAGrD,WAAW,CAACS,IAAI,CAACe,UAAgC;IAChE;IACA;IACA,MAAMuD,KAAK,GAAGnB,gBAAgB,CAACP,MAAM,EAAES,WAAW,CAAC;IACnD,IAAI,CAACiB,KAAK,EAAE;MACV,OAAO9G,SAAS;IAClB;IACA,MAAM,CAAC+G,QAAQ,EAAEC,QAAQ,CAAC,GAAGF,KAAK;;IAElC;IACA;IACA;IACA,IAAIG,UAAU,GAAG7B,MAAM,CAAC4B,QAAQ,CAAC;IACjC,IAAIC,UAAU,GAAGpB,WAAW,EAAE;MAC5BoB,UAAU,GAAG7B,MAAM,CAAC2B,QAAQ,CAAC;IAC/B;;IAEA;IACA;IACA;;IAEA,MAAM,CAACG,SAAS,EAAEC,SAAS,CAAC,GAAGP,MAAM,CAAE1G,GAAG,CAAC+G,UAAU,CAAqB;;IAE1E;IACA;IACA,MAAMG,KAAK,GAAGH,UAAU,IAAIpB,WAAW,GAAGsB,SAAS,GAAGD,SAAS;IAC/D,MAAM3E,GAAG,GAAG8D,KAAK,CAAEnF,KAAK,CAAC,CAAC,EAAEkG,KAAK,CAAC,CAACC,OAAO,EAAE;IAC5C9E,GAAG,CAACJ,IAAI,CAACR,SAAS,CAAC;IACnB;IACA,IAAImE,YAAY,EAAE;MAChBQ,qBAAqB,CAAC/D,GAAG,CAAC;IAC5B;IACA,OAAOA,GAAG;EACZ;;EAEA;EACA,OAAOvC,SAAS;AAClB,CAAC;AAAA;AAED,SAASuG,mBAAmB,CAC1BV,WAAgC,EAChC9D,WAAyB,EACzBN,GAA4B,EACtB;EACN,IAAIoE,WAAW,KAAK,IAAI,EAAE;IACxB;IACA;IACA,IAAIyB,KAAK,GAAGvF,WAAW,CAACG,OAAO,CAAChC,GAAG,CAACF,SAAS,CAAC;IAC9C,IAAIsH,KAAK,EAAEA,KAAK,CAAC5E,OAAO,CAAClD,IAAI,IAAIiC,GAAG,CAAC8F,MAAM,CAAC/H,IAAI,CAAC,CAAC;IAClD8H,KAAK,GAAGvF,WAAW,CAACG,OAAO,CAAChC,GAAG,CAAC,IAAI,CAAC;IACrC,IAAIoH,KAAK,EAAEA,KAAK,CAAC5E,OAAO,CAAClD,IAAI,IAAIiC,GAAG,CAAC8F,MAAM,CAAC/H,IAAI,CAAC,CAAC;EACpD,CAAC,MAAM;IACL;IACA;IACA,MAAM8H,KAAK,GAAGvF,WAAW,CAACG,OAAO,CAAChC,GAAG,CAAC2F,WAAW,CAAC;IAClD,IAAIyB,KAAK,EAAEA,KAAK,CAAC5E,OAAO,CAAClD,IAAI,IAAIiC,GAAG,CAAC8F,MAAM,CAAC/H,IAAI,CAAC,CAAC;EACpD;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASgI,uBAAuB,CACrC5F,CAA4B,EAC5BC,CAA4B,EACD;EAC3B,IAAI4F,QAAQ,GAAG,CAAC;EAChB,IAAIC,QAAQ,GAAG,CAAC;EAChB;EACA,MAAMC,MAAiC,GAAG,EAAE;EAC5C,MAAMC,IAAI,GAAGhG,CAAC,CAACT,MAAM;EACrB,MAAM0G,IAAI,GAAGhG,CAAC,CAACV,MAAM;EACrB,IAAI2G,SAAyC,GAAG9H,SAAS,EAAC;;EAE1D,OAAOyH,QAAQ,GAAGG,IAAI,IAAIF,QAAQ,GAAGG,IAAI,EAAE;IACzC,MAAME,QAAQ,GAAGnG,CAAC,CAAC6F,QAAQ,CAAC,CAAC5H,QAAQ,CAACC,OAAO;IAC7C,MAAMkI,QAAQ,GAAGnG,CAAC,CAAC6F,QAAQ,CAAC,CAAC7H,QAAQ,CAACC,OAAO;IAE7C,IAAIiI,QAAQ,GAAGC,QAAQ,EAAE;MACvBP,QAAQ,EAAE;IACZ,CAAC,MAAM,IAAIM,QAAQ,GAAGC,QAAQ,EAAE;MAC9BN,QAAQ,EAAE;IACZ,CAAC,MAAM;MACL,IAAI9F,CAAC,CAAC6F,QAAQ,CAAC,CAAC7H,EAAE,KAAKiC,CAAC,CAAC6F,QAAQ,CAAC,CAAC9H,EAAE,EAAE;QACrC,MAAM,IAAIsG,KAAK,CACZ,0DAAyD,CAC3D;MACH;MACA;MACA;MACA;MACA;MACA,IAAI4B,SAAS,KAAKlG,CAAC,CAAC6F,QAAQ,CAAC,EAAE;QAC7BE,MAAM,CAAC9E,IAAI,CAACjB,CAAC,CAAC6F,QAAQ,CAAC,CAAC;QACxBK,SAAS,GAAGlG,CAAC,CAAC6F,QAAQ,CAAC;MACzB;MACAA,QAAQ,EAAE;MACVC,QAAQ,EAAE;IACZ;EACF;EAEA,OAAOC,MAAM;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS1B,mBAAmB,CACjCrE,CAA4B,EAC5BC,CAA4B,EACD;EAC3B;EACA,MAAMU,GAA8B,GAAG,EAAE;EACzC,IAAIuF,SAAyC,GAAG9H,SAAS,EAAC;;EAE1D,IAAIyH,QAAQ,GAAG,CAAC;EAChB,IAAIC,QAAQ,GAAG,CAAC;EAChB,MAAME,IAAI,GAAGhG,CAAC,CAACT,MAAM;EACrB,MAAM0G,IAAI,GAAGhG,CAAC,CAACV,MAAM;EAErB,OAAOsG,QAAQ,GAAGG,IAAI,IAAIF,QAAQ,GAAGG,IAAI,EAAE;IACzC,MAAME,QAAQ,GAAGnG,CAAC,CAAC6F,QAAQ,CAAC,CAAC5H,QAAQ,CAACC,OAAO;IAC7C,MAAMkI,QAAQ,GAAGnG,CAAC,CAAC6F,QAAQ,CAAC,CAAC7H,QAAQ,CAACC,OAAO;IAE7C,IAAIiI,QAAQ,GAAGC,QAAQ,EAAE;MACvB,IAAIF,SAAS,KAAKlG,CAAC,CAAC6F,QAAQ,CAAC,EAAE;QAC7BlF,GAAG,CAACM,IAAI,CAACjB,CAAC,CAAC6F,QAAQ,CAAC,CAAC;QACrBK,SAAS,GAAGlG,CAAC,CAAC6F,QAAQ,CAAC;MACzB;MACAA,QAAQ,EAAE;IACZ,CAAC,MAAM,IAAIM,QAAQ,GAAGC,QAAQ,EAAE;MAC9B,IAAIF,SAAS,KAAKjG,CAAC,CAAC6F,QAAQ,CAAC,EAAE;QAC7BnF,GAAG,CAACM,IAAI,CAAChB,CAAC,CAAC6F,QAAQ,CAAC,CAAC;QACrBI,SAAS,GAAGjG,CAAC,CAAC6F,QAAQ,CAAC;MACzB;MACAA,QAAQ,EAAE;IACZ,CAAC,MAAM;MACL,IAAII,SAAS,KAAKlG,CAAC,CAAC6F,QAAQ,CAAC,EAAE;QAC7BlF,GAAG,CAACM,IAAI,CAACjB,CAAC,CAAC6F,QAAQ,CAAC,CAAC;QACrBK,SAAS,GAAGlG,CAAC,CAAC6F,QAAQ,CAAC;MACzB;MACAA,QAAQ,EAAE;MACVC,QAAQ,EAAE;IACZ;EACF;EAEA,OAAOD,QAAQ,GAAGG,IAAI,EAAE;IACtB,IAAIE,SAAS,KAAKlG,CAAC,CAAC6F,QAAQ,CAAC,EAAE;MAC7BlF,GAAG,CAACM,IAAI,CAACjB,CAAC,CAAC6F,QAAQ,CAAC,CAAC;MACrBK,SAAS,GAAGlG,CAAC,CAAC6F,QAAQ,CAAC;IACzB;IACAA,QAAQ,EAAE;EACZ;EAEA,OAAOC,QAAQ,GAAGG,IAAI,EAAE;IACtB,IAAIC,SAAS,KAAKjG,CAAC,CAAC6F,QAAQ,CAAC,EAAE;MAC7BnF,GAAG,CAACM,IAAI,CAAChB,CAAC,CAAC6F,QAAQ,CAAC,CAAC;MACrBI,SAAS,GAAGjG,CAAC,CAAC6F,QAAQ,CAAC;IACzB;IACAA,QAAQ,EAAE;EACZ;EAEA,OAAOnF,GAAG;AACZ;AAEA,SAAS+D,qBAAqB,CAAC/D,GAA8B,EAAQ;EACnE;EACA;EACA;EACA,IAAI0F,IAAoC,GAAGjI,SAAS;;EAEpD;;EAEA,IAAIkI,CAAC,GAAG,CAAC;EACT,KAAK,IAAI3D,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGhC,GAAG,CAACpB,MAAM,EAAE,EAAEoD,CAAC,EAAE;IACnC,MAAM/E,IAAI,GAAG+C,GAAG,CAACgC,CAAC,CAAC;IACnB,IAAI/E,IAAI,KAAKyI,IAAI,EAAE;MACjB;MACA,IAAI1D,CAAC,KAAK2D,CAAC,EAAE;QACX3F,GAAG,CAAC2F,CAAC,CAAC,GAAG1I,IAAI;MACf;MACA,EAAE0I,CAAC;MACHD,IAAI,GAAGzI,IAAI;IACb;EACF;EACA+C,GAAG,CAACpB,MAAM,GAAG+G,CAAC;AAChB;AAEO,SAASvH,0BAA0B,CACxClB,WAA0B,EAC1BC,cAAmC,EACpB;EACf,MAAMa,YAAY,GAAG,IAAA4H,0BAAmB,EAACzI,cAAc,CAAC;EACxD,MAAM0I,eAAe,GAAG9G,MAAM,CAAC+G,IAAI,CAAC9H,YAAY,CAAC;EACjD,MAAM+H,SAAS,GAAG7I,WAAW,CAACW,GAAG,CAACC,KAAK,IAAI;IACzC,IACEE,YAAY,CAACF,KAAK,CAAC,IACnB+H,eAAe,CAACG,IAAI,CAACC,GAAG,IAAInI,KAAK,CAACU,UAAU,CAACyH,GAAG,CAAC,CAAC,EAClD;MACA,OAAQ,qBAAoBnI,KAAM,EAAC;IACrC,CAAC,MAAM;MACL,OAAOA,KAAK;IACd;EACF,CAAC,CAAC;EAEF,OAAOiI,SAAS;AAClB"}

package/dist/datastore/in-memory/run-fast-filters.d.ts

@@ -0,0 +1,27 @@
+import { DbQuery } from "../common/query";
+import { FiltersCache, IGatsbyNodePartial } from "./indexing";
+import { IRunQueryArgs, IQueryResult } from "../types";
+export interface IRunFilterArg extends IRunQueryArgs {
+    filtersCache: FiltersCache;
+}
+/**
+ * Given the path of a set of filters, return the sets of nodes that pass the
+ * filter.
+ * Only nodes of given node types will be considered
+ * A fast index is created if one doesn't exist yet so cold call is slower.
+ *
+ * Note: Not a public API. Exported for tests.
+ */
+export declare function applyFastFilters(filters: Array<DbQuery>, nodeTypeNames: Array<string>, filtersCache: FiltersCache, sortFields: Array<string>, resolvedFields: any): Array<IGatsbyNodePartial> | null;
+/**
+ * Filters and sorts a list of nodes using mongodb-like syntax.
+ *
+ * @param args raw graphql query filter/sort as an object
+ * @property {{filter?: Object, sort?: Object, skip?: number, limit?: number} | undefined} args.queryArgs
+ * @property {FiltersCache} args.filtersCache A cache of indexes where you can
+ *   look up Nodes grouped by a FilterCacheKey, which yields a Map which holds
+ *   an arr of Nodes for the value that the filter is trying to query against.
+ *   This object lives in query/query-runner.js and is passed down runQuery.
+ * @returns Collection of results. Collection will be sliced by `skip` and `limit`
+ */
+export declare function runFastFiltersAndSort(args: IRunFilterArg): IQueryResult;

package/dist/datastore/in-memory/run-fast-filters.js

@@ -0,0 +1,276 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.applyFastFilters = applyFastFilters;
+exports.runFastFiltersAndSort = runFastFiltersAndSort;
+var _orderBy2 = _interopRequireDefault(require("lodash/orderBy"));
+var _query = require("../common/query");
+var _indexing = require("./indexing");
+var _iterable = require("../common/iterable");
+var _2 = require("../");
+/**
+ * Creates a key for one filterCache inside FiltersCache
+ */
+function createFilterCacheKey(typeNames, filter) {
+  // Note: while `elemMatch` is a special case, in the key it's just `elemMatch`
+  // (This function is future proof for elemMatch support, won't receive it yet)
+  let filterStep = filter;
+  let comparator = ``;
+  const paths = [];
+  while (filterStep) {
+    paths.push(...filterStep.path);
+    if (filterStep.type === `elemMatch`) {
+      const q = filterStep;
+      filterStep = q.nestedQuery;
+      // Make distinction between filtering `a.elemMatch.b.eq` and `a.b.eq`
+      // In practice this is unlikely to be an issue, but it might
+      paths.push(`elemMatch`);
+    } else {
+      const q = filterStep;
+      comparator = q.query.comparator;
+      break;
+    }
+  }
+
+  // Note: the separators (`,` and `/`) are arbitrary but must be different
+  return typeNames.join(`,`) + `/` + paths.join(`,`) + `/` + comparator;
+}
+
+/**
+ * Given the path of a set of filters, return the sets of nodes that pass the
+ * filter.
+ * Only nodes of given node types will be considered
+ * A fast index is created if one doesn't exist yet so cold call is slower.
+ *
+ * Note: Not a public API. Exported for tests.
+ */
+function applyFastFilters(filters, nodeTypeNames, filtersCache, sortFields, resolvedFields) {
+  if (!filtersCache) {
+    // If no filter cache is passed on, explicitly don't use one
+    return null;
+  }
+  const nodesPerValueArrs = getBucketsForFilters(filters, nodeTypeNames, filtersCache, sortFields, resolvedFields);
+  if (!nodesPerValueArrs) {
+    return null;
+  }
+  if (nodesPerValueArrs.length === 0) {
+    return [];
+  } else {
+    // Put smallest last (we'll pop it)
+    nodesPerValueArrs.sort((a, b) => b.length - a.length);
+
+    // All elements of nodesPerValueArrs should be sorted by counter and deduped
+    // So if there's only one bucket in this list the next loop is skipped
+
+    while (nodesPerValueArrs.length > 1) {
+      // TS limitation: cannot guard against .pop(), so we must double cast
+      const a = nodesPerValueArrs.pop();
+      const b = nodesPerValueArrs.pop();
+      nodesPerValueArrs.push((0, _indexing.intersectNodesByCounter)(a, b));
+    }
+    const result = nodesPerValueArrs[0];
+    if (result.length === 0) {
+      // Intersection came up empty. Not one node appeared in every bucket.
+      return null;
+    }
+    return result;
+  }
+}
+
+/**
+ * If this returns undefined it means at least one cache was not found
+ */
+function getBucketsForFilters(filters, nodeTypeNames, filtersCache, sortFields, resolvedFields) {
+  const nodesPerValueArrs = [];
+
+  // Fail fast while trying to create and get the value-cache for each path
+  const every = filters.every(filter => {
+    const filterCacheKey = createFilterCacheKey(nodeTypeNames, filter);
+    if (filter.type === `query`) {
+      // (Let TS warn us if a new query type gets added)
+      const q = filter;
+      return getBucketsForQueryFilter(filterCacheKey, q, nodeTypeNames, filtersCache, nodesPerValueArrs, sortFields, resolvedFields);
+    } else {
+      // (Let TS warn us if a new query type gets added)
+      const q = filter;
+      return collectBucketForElemMatch(filterCacheKey, q, nodeTypeNames, filtersCache, nodesPerValueArrs, sortFields, resolvedFields);
+    }
+  });
+  if (every) {
+    return nodesPerValueArrs;
+  }
+
+  // "failed at least one"
+  return undefined;
+}
+
+/**
+ * Fetch all buckets for given query filter. That means it's not elemMatch.
+ * Returns `false` if it found none.
+ */
+function getBucketsForQueryFilter(filterCacheKey, filter, nodeTypeNames, filtersCache, nodesPerValueArrs, sortFields, resolvedFields) {
+  const {
+    path: filterPath,
+    query: {
+      comparator,
+      value: filterValue
+    }
+  } = filter;
+  if (!filtersCache.has(filterCacheKey)) {
+    // indexFields = sortFields
+    (0, _indexing.ensureIndexByQuery)(comparator, filterCacheKey, filterPath, nodeTypeNames, filtersCache, sortFields, resolvedFields);
+  }
+  const nodesPerValue = (0, _indexing.getNodesFromCacheByValue)(filterCacheKey, filterValue, filtersCache, false);
+  if (!nodesPerValue) {
+    return false;
+  }
+
+  // In all other cases this must be a non-empty arr because the indexing
+  // mechanism does not create an array unless there's a IGatsbyNode for it
+  nodesPerValueArrs.push(nodesPerValue);
+  return true;
+}
+
+/**
+ * Matching node arrs are put in given array by reference
+ */
+function collectBucketForElemMatch(filterCacheKey, filter, nodeTypeNames, filtersCache, nodesPerValueArrs, sortFields, resolvedFields) {
+  // Get comparator and target value for this elemMatch
+  let comparator = `$eq`; // (Must be overridden but TS requires init)
+  let targetValue = null;
+  let f = filter;
+  while (f) {
+    if (f.type === `elemMatch`) {
+      const q = f;
+      f = q.nestedQuery;
+    } else {
+      const q = f;
+      comparator = q.query.comparator;
+      targetValue = q.query.value;
+      break;
+    }
+  }
+  if (!filtersCache.has(filterCacheKey)) {
+    (0, _indexing.ensureIndexByElemMatch)(comparator, filterCacheKey, filter, nodeTypeNames, filtersCache, sortFields, resolvedFields);
+  }
+  const nodesByValue = (0, _indexing.getNodesFromCacheByValue)(filterCacheKey, targetValue, filtersCache, true);
+  if (!nodesByValue) {
+    return false;
+  }
+
+  // In all other cases this must be a non-empty arr because the indexing
+  // mechanism does not create an array unless there's a IGatsbyNode for it
+  nodesPerValueArrs.push(nodesByValue);
+  return true;
+}
+
+/**
+ * Filters and sorts a list of nodes using mongodb-like syntax.
+ *
+ * @param args raw graphql query filter/sort as an object
+ * @property {{filter?: Object, sort?: Object, skip?: number, limit?: number} | undefined} args.queryArgs
+ * @property {FiltersCache} args.filtersCache A cache of indexes where you can
+ *   look up Nodes grouped by a FilterCacheKey, which yields a Map which holds
+ *   an arr of Nodes for the value that the filter is trying to query against.
+ *   This object lives in query/query-runner.js and is passed down runQuery.
+ * @returns Collection of results. Collection will be sliced by `skip` and `limit`
+ */
+function runFastFiltersAndSort(args) {
+  const {
+    queryArgs: {
+      filter,
+      sort,
+      limit,
+      skip = 0
+    } = {},
+    resolvedFields = {},
+    nodeTypeNames,
+    filtersCache,
+    stats
+  } = args;
+  const result = convertAndApplyFastFilters(filter, nodeTypeNames, filtersCache, resolvedFields, stats, sort);
+  const sortedResult = sortNodes(result, sort, resolvedFields, stats);
+  const totalCount = async () => sortedResult.length;
+  const entries = skip || limit ? sortedResult.slice(skip, limit ? skip + (limit !== null && limit !== void 0 ? limit : 0) : undefined) : sortedResult;
+  const nodeObjects = entries.map(nodeIds => (0, _2.getNode)(nodeIds.id));
+  return {
+    entries: new _iterable.GatsbyIterable(nodeObjects),
+    totalCount
+  };
+}
+
+/**
+ * Return a collection of results.
+ */
+function convertAndApplyFastFilters(filterFields, nodeTypeNames, filtersCache, resolvedFields, stats, sort) {
+  const filters = filterFields ? (0, _query.prefixResolvedFields)((0, _query.createDbQueriesFromObject)((0, _query.prepareQueryArgs)(filterFields)), resolvedFields) : [];
+  if (stats) {
+    filters.forEach(filter => {
+      const filterStats = filterToStats(filter);
+      const comparatorPath = filterStats.comparatorPath.join(`.`);
+      stats.comparatorsUsed.set(comparatorPath, (stats.comparatorsUsed.get(comparatorPath) || 0) + 1);
+      stats.uniqueFilterPaths.add(filterStats.filterPath.join(`.`));
+    });
+    if (filters.length > 1) {
+      stats.totalNonSingleFilters++;
+    }
+  }
+  if (filters.length === 0) {
+    const filterCacheKey = createFilterCacheKey(nodeTypeNames, null);
+    if (!filtersCache.has(filterCacheKey)) {
+      (0, _indexing.ensureEmptyFilterCache)(filterCacheKey, nodeTypeNames, filtersCache, (sort === null || sort === void 0 ? void 0 : sort.fields) || [], resolvedFields);
+    }
+
+    // If there's a filter, there (now) must be an entry for this cache key
+    const filterCache = filtersCache.get(filterCacheKey);
+    // If there is no filter then the ensureCache step will populate this:
+    const cache = filterCache.meta.orderedByCounter;
+    return cache.slice(0);
+  }
+  const result = applyFastFilters(filters, nodeTypeNames, filtersCache, (sort === null || sort === void 0 ? void 0 : sort.fields) || [], resolvedFields);
+  if (result) {
+    if (stats) {
+      stats.totalIndexHits++;
+    }
+    return result;
+  }
+  if (stats) {
+    // to mean, "empty results"
+    stats.totalSiftHits++;
+  }
+  return [];
+}
+function filterToStats(filter, filterPath = [], comparatorPath = []) {
+  if (filter.type === `elemMatch`) {
+    return filterToStats(filter.nestedQuery, filterPath.concat(filter.path), comparatorPath.concat([`elemMatch`]));
+  } else {
+    return {
+      filterPath: filterPath.concat(filter.path),
+      comparatorPath: comparatorPath.concat(filter.query.comparator)
+    };
+  }
+}
+
+/**
+ * Given a list of filtered nodes and sorting parameters, sort the nodes
+ * Returns same reference as input, sorted inline
+ */
+function sortNodes(nodes, sort, resolvedFields, stats) {
+  var _sort$fields;
+  if (!sort || ((_sort$fields = sort.fields) === null || _sort$fields === void 0 ? void 0 : _sort$fields.length) === 0 || !nodes || nodes.length === 0) {
+    return nodes;
+  }
+
+  // create functions that return the item to compare on
+  const sortFields = (0, _indexing.getSortFieldIdentifierKeys)(sort.fields, resolvedFields);
+  const sortFns = sortFields.map(field => v => field in v ? v[field] : (0, _indexing.getGatsbyNodePartial)(v, sort.fields, resolvedFields)[field]);
+  const sortOrder = sort.order.map(order => typeof order === `boolean` ? order : order.toLowerCase());
+  if (stats) {
+    sortFields.forEach(sortField => {
+      stats.uniqueSorts.add(sortField);
+    });
+  }
+  return (0, _orderBy2.default)(nodes, sortFns, sortOrder);
+}
+//# sourceMappingURL=run-fast-filters.js.map

package/dist/datastore/in-memory/run-fast-filters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-fast-filters.js","names":["createFilterCacheKey","typeNames","filter","filterStep","comparator","paths","push","path","type","q","nestedQuery","query","join","applyFastFilters","filters","nodeTypeNames","filtersCache","sortFields","resolvedFields","nodesPerValueArrs","getBucketsForFilters","length","sort","a","b","pop","intersectNodesByCounter","result","every","filterCacheKey","getBucketsForQueryFilter","collectBucketForElemMatch","undefined","filterPath","value","filterValue","has","ensureIndexByQuery","nodesPerValue","getNodesFromCacheByValue","targetValue","f","ensureIndexByElemMatch","nodesByValue","runFastFiltersAndSort","args","queryArgs","limit","skip","stats","convertAndApplyFastFilters","sortedResult","sortNodes","totalCount","entries","slice","nodeObjects","map","nodeIds","getNode","id","GatsbyIterable","filterFields","prefixResolvedFields","createDbQueriesFromObject","prepareQueryArgs","forEach","filterStats","filterToStats","comparatorPath","comparatorsUsed","set","get","uniqueFilterPaths","add","totalNonSingleFilters","ensureEmptyFilterCache","fields","filterCache","cache","meta","orderedByCounter","totalIndexHits","totalSiftHits","concat","nodes","getSortFieldIdentifierKeys","sortFns","field","v","getGatsbyNodePartial","sortOrder","order","toLowerCase","sortField","uniqueSorts"],"sources":["../../../src/datastore/in-memory/run-fast-filters.ts"],"sourcesContent":["import _ from \"lodash\"\nimport {\n  DbQuery,\n  IDbQueryQuery,\n  IDbQueryElemMatch,\n  IInputQuery,\n  FilterValueNullable,\n  createDbQueriesFromObject,\n  prefixResolvedFields,\n  prepareQueryArgs,\n} from \"../common/query\"\nimport {\n  FilterOp,\n  FilterCacheKey,\n  FiltersCache,\n  ensureEmptyFilterCache,\n  ensureIndexByQuery,\n  ensureIndexByElemMatch,\n  getNodesFromCacheByValue,\n  intersectNodesByCounter,\n  IFilterCache,\n  IGatsbyNodePartial,\n  getSortFieldIdentifierKeys,\n  getGatsbyNodePartial,\n} from \"./indexing\"\nimport { IGraphQLRunnerStats } from \"../../query/types\"\nimport { IRunQueryArgs, IQueryResult } from \"../types\"\nimport { GatsbyIterable } from \"../common/iterable\"\nimport { getNode } from \"../\"\n\nexport interface IRunFilterArg extends IRunQueryArgs {\n  filtersCache: FiltersCache\n}\n\ntype ISortParameters =\n  | {\n      fields: Array<string>\n      order: Array<boolean | \"asc\" | \"desc\" | \"ASC\" | \"DESC\">\n    }\n  | undefined\n\n/**\n * Creates a key for one filterCache inside FiltersCache\n */\nfunction createFilterCacheKey(\n  typeNames: Array<string>,\n  filter: DbQuery | null\n): FilterCacheKey {\n  // Note: while `elemMatch` is a special case, in the key it's just `elemMatch`\n  // (This function is future proof for elemMatch support, won't receive it yet)\n  let filterStep = filter\n  let comparator = ``\n  const paths: Array<string> = []\n  while (filterStep) {\n    paths.push(...filterStep.path)\n    if (filterStep.type === `elemMatch`) {\n      const q: IDbQueryElemMatch = filterStep\n      filterStep = q.nestedQuery\n      // Make distinction between filtering `a.elemMatch.b.eq` and `a.b.eq`\n      // In practice this is unlikely to be an issue, but it might\n      paths.push(`elemMatch`)\n    } else {\n      const q: IDbQueryQuery = filterStep\n      comparator = q.query.comparator\n      break\n    }\n  }\n\n  // Note: the separators (`,` and `/`) are arbitrary but must be different\n  return typeNames.join(`,`) + `/` + paths.join(`,`) + `/` + comparator\n}\n\n/**\n * Given the path of a set of filters, return the sets of nodes that pass the\n * filter.\n * Only nodes of given node types will be considered\n * A fast index is created if one doesn't exist yet so cold call is slower.\n *\n * Note: Not a public API. Exported for tests.\n */\nexport function applyFastFilters(\n  filters: Array<DbQuery>,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  sortFields: Array<string>,\n  resolvedFields: any\n): Array<IGatsbyNodePartial> | null {\n  if (!filtersCache) {\n    // If no filter cache is passed on, explicitly don't use one\n    return null\n  }\n\n  const nodesPerValueArrs = getBucketsForFilters(\n    filters,\n    nodeTypeNames,\n    filtersCache,\n    sortFields,\n    resolvedFields\n  )\n\n  if (!nodesPerValueArrs) {\n    return null\n  }\n\n  if (nodesPerValueArrs.length === 0) {\n    return []\n  } else {\n    // Put smallest last (we'll pop it)\n    nodesPerValueArrs.sort((a, b) => b.length - a.length)\n\n    // All elements of nodesPerValueArrs should be sorted by counter and deduped\n    // So if there's only one bucket in this list the next loop is skipped\n\n    while (nodesPerValueArrs.length > 1) {\n      // TS limitation: cannot guard against .pop(), so we must double cast\n      const a = nodesPerValueArrs.pop() as unknown as Array<IGatsbyNodePartial>\n      const b = nodesPerValueArrs.pop() as unknown as Array<IGatsbyNodePartial>\n      nodesPerValueArrs.push(intersectNodesByCounter(a, b))\n    }\n\n    const result = nodesPerValueArrs[0]\n\n    if (result.length === 0) {\n      // Intersection came up empty. Not one node appeared in every bucket.\n      return null\n    }\n\n    return result\n  }\n}\n\n/**\n * If this returns undefined it means at least one cache was not found\n */\nfunction getBucketsForFilters(\n  filters: Array<DbQuery>,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  sortFields: Array<string>,\n  resolvedFields: any\n): Array<Array<IGatsbyNodePartial>> | undefined {\n  const nodesPerValueArrs: Array<Array<IGatsbyNodePartial>> = []\n\n  // Fail fast while trying to create and get the value-cache for each path\n  const every = filters.every(filter => {\n    const filterCacheKey = createFilterCacheKey(nodeTypeNames, filter)\n    if (filter.type === `query`) {\n      // (Let TS warn us if a new query type gets added)\n      const q: IDbQueryQuery = filter\n      return getBucketsForQueryFilter(\n        filterCacheKey,\n        q,\n        nodeTypeNames,\n        filtersCache,\n        nodesPerValueArrs,\n        sortFields,\n        resolvedFields\n      )\n    } else {\n      // (Let TS warn us if a new query type gets added)\n      const q: IDbQueryElemMatch = filter\n      return collectBucketForElemMatch(\n        filterCacheKey,\n        q,\n        nodeTypeNames,\n        filtersCache,\n        nodesPerValueArrs,\n        sortFields,\n        resolvedFields\n      )\n    }\n  })\n\n  if (every) {\n    return nodesPerValueArrs\n  }\n\n  // \"failed at least one\"\n  return undefined\n}\n\n/**\n * Fetch all buckets for given query filter. That means it's not elemMatch.\n * Returns `false` if it found none.\n */\nfunction getBucketsForQueryFilter(\n  filterCacheKey: FilterCacheKey,\n  filter: IDbQueryQuery,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  nodesPerValueArrs: Array<Array<IGatsbyNodePartial>>,\n  sortFields: Array<string>,\n  resolvedFields: any\n): boolean {\n  const {\n    path: filterPath,\n    query: { comparator, value: filterValue },\n  } = filter\n\n  if (!filtersCache.has(filterCacheKey)) {\n    // indexFields = sortFields\n    ensureIndexByQuery(\n      comparator as FilterOp,\n      filterCacheKey,\n      filterPath,\n      nodeTypeNames,\n      filtersCache,\n      sortFields,\n      resolvedFields\n    )\n  }\n\n  const nodesPerValue = getNodesFromCacheByValue(\n    filterCacheKey,\n    filterValue as FilterValueNullable,\n    filtersCache,\n    false\n  )\n\n  if (!nodesPerValue) {\n    return false\n  }\n\n  // In all other cases this must be a non-empty arr because the indexing\n  // mechanism does not create an array unless there's a IGatsbyNode for it\n  nodesPerValueArrs.push(nodesPerValue)\n\n  return true\n}\n\n/**\n * Matching node arrs are put in given array by reference\n */\nfunction collectBucketForElemMatch(\n  filterCacheKey: FilterCacheKey,\n  filter: IDbQueryElemMatch,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  nodesPerValueArrs: Array<Array<IGatsbyNodePartial>>,\n  sortFields: Array<string>,\n  resolvedFields: any\n): boolean {\n  // Get comparator and target value for this elemMatch\n  let comparator: FilterOp = `$eq` // (Must be overridden but TS requires init)\n  let targetValue: FilterValueNullable = null\n  let f: DbQuery = filter\n  while (f) {\n    if (f.type === `elemMatch`) {\n      const q: IDbQueryElemMatch = f\n      f = q.nestedQuery\n    } else {\n      const q: IDbQueryQuery = f\n      comparator = q.query.comparator as FilterOp\n      targetValue = q.query.value as FilterValueNullable\n      break\n    }\n  }\n  if (!filtersCache.has(filterCacheKey)) {\n    ensureIndexByElemMatch(\n      comparator,\n      filterCacheKey,\n      filter,\n      nodeTypeNames,\n      filtersCache,\n      sortFields,\n      resolvedFields\n    )\n  }\n\n  const nodesByValue = getNodesFromCacheByValue(\n    filterCacheKey,\n    targetValue,\n    filtersCache,\n    true\n  )\n\n  if (!nodesByValue) {\n    return false\n  }\n\n  // In all other cases this must be a non-empty arr because the indexing\n  // mechanism does not create an array unless there's a IGatsbyNode for it\n  nodesPerValueArrs.push(nodesByValue)\n\n  return true\n}\n\n/**\n * Filters and sorts a list of nodes using mongodb-like syntax.\n *\n * @param args raw graphql query filter/sort as an object\n * @property {{filter?: Object, sort?: Object, skip?: number, limit?: number} | undefined} args.queryArgs\n * @property {FiltersCache} args.filtersCache A cache of indexes where you can\n *   look up Nodes grouped by a FilterCacheKey, which yields a Map which holds\n *   an arr of Nodes for the value that the filter is trying to query against.\n *   This object lives in query/query-runner.js and is passed down runQuery.\n * @returns Collection of results. Collection will be sliced by `skip` and `limit`\n */\nexport function runFastFiltersAndSort(args: IRunFilterArg): IQueryResult {\n  const {\n    queryArgs: { filter, sort, limit, skip = 0 } = {},\n    resolvedFields = {},\n    nodeTypeNames,\n    filtersCache,\n    stats,\n  } = args\n\n  const result = convertAndApplyFastFilters(\n    filter,\n    nodeTypeNames,\n    filtersCache,\n    resolvedFields,\n    stats,\n    sort\n  )\n\n  const sortedResult = sortNodes(result, sort, resolvedFields, stats)\n  const totalCount = async (): Promise<number> => sortedResult.length\n\n  const entries =\n    skip || limit\n      ? sortedResult.slice(skip, limit ? skip + (limit ?? 0) : undefined)\n      : sortedResult\n\n  const nodeObjects = entries.map(nodeIds => getNode(nodeIds.id)!)\n  return { entries: new GatsbyIterable(nodeObjects), totalCount }\n}\n\n/**\n * Return a collection of results.\n */\nfunction convertAndApplyFastFilters(\n  filterFields: IInputQuery | undefined,\n  nodeTypeNames: Array<string>,\n  filtersCache: FiltersCache,\n  resolvedFields: Record<string, any>,\n  stats: IGraphQLRunnerStats,\n  sort: ISortParameters\n): Array<IGatsbyNodePartial> {\n  const filters = filterFields\n    ? prefixResolvedFields(\n        createDbQueriesFromObject(prepareQueryArgs(filterFields)),\n        resolvedFields\n      )\n    : []\n\n  if (stats) {\n    filters.forEach(filter => {\n      const filterStats = filterToStats(filter)\n      const comparatorPath = filterStats.comparatorPath.join(`.`)\n      stats.comparatorsUsed.set(\n        comparatorPath,\n        (stats.comparatorsUsed.get(comparatorPath) || 0) + 1\n      )\n      stats.uniqueFilterPaths.add(filterStats.filterPath.join(`.`))\n    })\n    if (filters.length > 1) {\n      stats.totalNonSingleFilters++\n    }\n  }\n\n  if (filters.length === 0) {\n    const filterCacheKey = createFilterCacheKey(nodeTypeNames, null)\n    if (!filtersCache.has(filterCacheKey)) {\n      ensureEmptyFilterCache(\n        filterCacheKey,\n        nodeTypeNames,\n        filtersCache,\n        sort?.fields || [],\n        resolvedFields\n      )\n    }\n\n    // If there's a filter, there (now) must be an entry for this cache key\n    const filterCache = filtersCache.get(filterCacheKey) as IFilterCache\n    // If there is no filter then the ensureCache step will populate this:\n    const cache = filterCache.meta.orderedByCounter as Array<IGatsbyNodePartial>\n\n    return cache.slice(0)\n  }\n\n  const result = applyFastFilters(\n    filters,\n    nodeTypeNames,\n    filtersCache,\n    sort?.fields || [],\n    resolvedFields\n  )\n\n  if (result) {\n    if (stats) {\n      stats.totalIndexHits++\n    }\n    return result\n  }\n\n  if (stats) {\n    // to mean, \"empty results\"\n    stats.totalSiftHits++\n  }\n\n  return []\n}\n\nfunction filterToStats(\n  filter: DbQuery,\n  filterPath: Array<string> = [],\n  comparatorPath: Array<string> = []\n): {\n  filterPath: Array<string>\n  comparatorPath: Array<string>\n} {\n  if (filter.type === `elemMatch`) {\n    return filterToStats(\n      filter.nestedQuery,\n      filterPath.concat(filter.path),\n      comparatorPath.concat([`elemMatch`])\n    )\n  } else {\n    return {\n      filterPath: filterPath.concat(filter.path),\n      comparatorPath: comparatorPath.concat(filter.query.comparator),\n    }\n  }\n}\n\n/**\n * Given a list of filtered nodes and sorting parameters, sort the nodes\n * Returns same reference as input, sorted inline\n */\nfunction sortNodes(\n  nodes: Array<IGatsbyNodePartial>,\n  sort: ISortParameters,\n  resolvedFields: any,\n  stats: IGraphQLRunnerStats\n): Array<IGatsbyNodePartial> {\n  if (!sort || sort.fields?.length === 0 || !nodes || nodes.length === 0) {\n    return nodes\n  }\n\n  // create functions that return the item to compare on\n  const sortFields = getSortFieldIdentifierKeys(sort.fields, resolvedFields)\n  const sortFns = sortFields.map(\n    field =>\n      (v): ((any) => any) =>\n        field in v\n          ? v[field]\n          : getGatsbyNodePartial(v, sort.fields, resolvedFields)[field]\n  )\n  const sortOrder = sort.order.map(order =>\n    typeof order === `boolean` ? order : order.toLowerCase()\n  ) as Array<boolean | \"asc\" | \"desc\">\n\n  if (stats) {\n    sortFields.forEach(sortField => {\n      stats.uniqueSorts.add(sortField)\n    })\n  }\n\n  return _.orderBy(nodes, sortFns, sortOrder)\n}\n"],"mappings":"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"}

package/dist/datastore/index.d.ts

@@ -0,0 +1,20 @@
+import { IGatsbyNode } from "../redux/types";
+export { getDataStore } from "./datastore";
+/**
+ * Get all nodes from datastore.
+ * @deprecated
+ */
+export declare const getNodes: () => Array<IGatsbyNode>;
+/**
+ * Get node by id from datastore.
+ */
+export declare const getNode: (id: string) => IGatsbyNode | undefined;
+/**
+ * Get all nodes of type from datastore.
+ * @deprecated
+ */
+export declare const getNodesByType: (type: string) => Array<IGatsbyNode>;
+/**
+ * Get all type names from datastore.
+ */
+export declare const getTypes: () => Array<string>;

package/dist/datastore/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getTypes = exports.getNodesByType = exports.getNodes = exports.getNode = void 0;
+var _datastore = require("./datastore");
+exports.getDataStore = _datastore.getDataStore;
+// Convenience accessor methods
+
+/**
+ * Get all nodes from datastore.
+ * @deprecated
+ */
+const getNodes = () => (0, _datastore.getDataStore)().getNodes();
+
+/**
+ * Get node by id from datastore.
+ */
+exports.getNodes = getNodes;
+const getNode = id => (0, _datastore.getDataStore)().getNode(id);
+
+/**
+ * Get all nodes of type from datastore.
+ * @deprecated
+ */
+exports.getNode = getNode;
+const getNodesByType = type => (0, _datastore.getDataStore)().getNodesByType(type);
+
+/**
+ * Get all type names from datastore.
+ */
+exports.getNodesByType = getNodesByType;
+const getTypes = () => (0, _datastore.getDataStore)().getTypes();
+exports.getTypes = getTypes;
+//# sourceMappingURL=index.js.map

package/dist/datastore/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["getNodes","getDataStore","getNode","id","getNodesByType","type","getTypes"],"sources":["../../src/datastore/index.ts"],"sourcesContent":["import { IGatsbyNode } from \"../redux/types\"\nimport { getDataStore } from \"./datastore\"\n\nexport { getDataStore } from \"./datastore\"\n\n// Convenience accessor methods\n\n/**\n * Get all nodes from datastore.\n * @deprecated\n */\nexport const getNodes = (): Array<IGatsbyNode> => getDataStore().getNodes()\n\n/**\n * Get node by id from datastore.\n */\nexport const getNode = (id: string): IGatsbyNode | undefined =>\n  getDataStore().getNode(id)\n\n/**\n * Get all nodes of type from datastore.\n * @deprecated\n */\nexport const getNodesByType = (type: string): Array<IGatsbyNode> =>\n  getDataStore().getNodesByType(type)\n\n/**\n * Get all type names from datastore.\n */\nexport const getTypes = (): Array<string> => getDataStore().getTypes()\n"],"mappings":";;;;AACA;AAA0C;AAI1C;;AAEA;AACA;AACA;AACA;AACO,MAAMA,QAAQ,GAAG,MAA0B,IAAAC,uBAAY,GAAE,CAACD,QAAQ,EAAE;;AAE3E;AACA;AACA;AAFA;AAGO,MAAME,OAAO,GAAIC,EAAU,IAChC,IAAAF,uBAAY,GAAE,CAACC,OAAO,CAACC,EAAE,CAAC;;AAE5B;AACA;AACA;AACA;AAHA;AAIO,MAAMC,cAAc,GAAIC,IAAY,IACzC,IAAAJ,uBAAY,GAAE,CAACG,cAAc,CAACC,IAAI,CAAC;;AAErC;AACA;AACA;AAFA;AAGO,MAAMC,QAAQ,GAAG,MAAqB,IAAAL,uBAAY,GAAE,CAACK,QAAQ,EAAE;AAAA"}

package/dist/datastore/lmdb/lmdb-datastore.d.ts

@@ -0,0 +1,14 @@
+import { RootDatabase } from "lmdb";
+import { IDataStore, ILmdbDatabases } from "../types";
+export declare function getDefaultDbPath(): string;
+declare global {
+    namespace NodeJS {
+        interface Global {
+            __GATSBY_OPEN_LMDBS?: Map<string, ILmdbDatabases>;
+            __GATSBY_OPEN_ROOT_LMDBS?: Map<string, RootDatabase>;
+        }
+    }
+}
+export declare function setupLmdbStore({ dbPath, }?: {
+    dbPath?: string;
+}): IDataStore;