@tidyjs/tidy 2.4.6 → 2.5.0

package/dist/es/index.js

@@ -32,6 +32,7 @@ export { cumsum } from './vector/cumsum.js';
 export { roll } from './vector/roll.js';
 export { lag } from './vector/lag.js';
 export { lead } from './vector/lead.js';
+export { rowNumber } from './vector/rowNumber.js';
 export { sum } from './summary/sum.js';
 export { min } from './summary/min.js';
 export { max } from './summary/max.js';

package/dist/es/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/es/item/rate.js

@@ -4,15 +4,15 @@ function rate(numerator, denominator, options) {
   const numeratorFn = typeof numerator === "function" ? numerator : (d) => d[numerator];
   const denominatorFn = typeof denominator === "function" ? denominator : (d) => d[denominator];
   const {predicate, allowDivideByZero} = options != null ? options : {};
-  return predicate == null ? (d) => {
-    const denom = denominatorFn(d);
-    const numer = numeratorFn(d);
+  return predicate == null ? (d, index, array) => {
+    const denom = denominatorFn(d, index, array);
+    const numer = numeratorFn(d, index, array);
     return rate$1(numer, denom, allowDivideByZero);
-  } : (d) => {
-    if (!predicate(d))
+  } : (d, index, array) => {
+    if (!predicate(d, index, array))
       return void 0;
-    const denom = denominatorFn(d);
-    const numer = numeratorFn(d);
+    const denom = denominatorFn(d, index, array);
+    const numer = numeratorFn(d, index, array);
     return rate$1(numer, denom, allowDivideByZero);
   };
 }

package/dist/es/item/rate.js.map

@@ -1 +1 @@
-{"version":3,"file":"rate.js","sources":["../../../src/item/rate.ts"],"sourcesContent":["import { rate as mathRate } from '../math/math';\n\ntype RateOptions<T> = {\n  predicate?: (d: T) => boolean;\n  allowDivideByZero?: boolean;\n};\n\n/**\n * Returns a function that computes a rate (numerator / denominator), setting the value to\n * 0 if denominator = 0 and numerator = 0.\n */\nexport function rate<T extends object>(\n  numerator: keyof T | ((d: T) => number),\n  denominator: keyof T | ((d: T) => number),\n  options?: RateOptions<T>\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  const { predicate, allowDivideByZero } = options ?? {};\n  return predicate == null\n    ? (d: T) => {\n        const denom = denominatorFn(d);\n        const numer = numeratorFn(d);\n        return mathRate(numer, denom, allowDivideByZero);\n      }\n    : (d: T) => {\n        if (!predicate(d)) return undefined;\n\n        const denom = denominatorFn(d);\n        const numer = numeratorFn(d);\n        return mathRate(numer, denom, allowDivideByZero);\n      };\n}\n"],"names":["mathRate"],"mappings":";;cAYE,WACA,aACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,QAAM,CAAE,WAAW,qBAAsB,4BAAW;AACpD,SAAO,aAAa,OAChB,CAAC;AACC,UAAM,QAAQ,cAAc;AAC5B,UAAM,QAAQ,YAAY;AAC1B,WAAOA,OAAS,OAAO,OAAO;AAAA,MAEhC,CAAC;AACC,QAAI,CAAC,UAAU;AAAI,aAAO;AAE1B,UAAM,QAAQ,cAAc;AAC5B,UAAM,QAAQ,YAAY;AAC1B,WAAOA,OAAS,OAAO,OAAO;AAAA;AAAA;;;;"}
+{"version":3,"file":"rate.js","sources":["../../../src/item/rate.ts"],"sourcesContent":["import { rate as mathRate } from '../math/math';\n\ntype RateOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n  allowDivideByZero?: boolean;\n};\n\n/**\n * Returns a function that computes a rate (numerator / denominator), setting the value to\n * 0 if denominator = 0 and numerator = 0.\n */\nexport function rate<T extends object>(\n  numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  options?: RateOptions<T>\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  const { predicate, allowDivideByZero } = options ?? {};\n  return predicate == null\n    ? (d: T, index: number, array: Iterable<T>) => {\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      }\n    : (d: T, index: number, array: Iterable<T>) => {\n        if (!predicate(d, index, array)) return undefined;\n\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      };\n}\n"],"names":["mathRate"],"mappings":";;cAYE,WACA,aACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,QAAM,CAAE,WAAW,qBAAsB,4BAAW;AACpD,SAAO,aAAa,OAChB,CAAC,GAAM,OAAe;AACpB,UAAM,QAAQ,cAAc,GAAG,OAAO;AACtC,UAAM,QAAQ,YAAY,GAAG,OAAO;AACpC,WAAOA,OAAS,OAAO,OAAO;AAAA,MAEhC,CAAC,GAAM,OAAe;AACpB,QAAI,CAAC,UAAU,GAAG,OAAO;AAAQ,aAAO;AAExC,UAAM,QAAQ,cAAc,GAAG,OAAO;AACtC,UAAM,QAAQ,YAAY,GAAG,OAAO;AACpC,WAAOA,OAAS,OAAO,OAAO;AAAA;AAAA;;;;"}

package/dist/es/mutate.js

@@ -1,14 +1,14 @@
 function mutate(mutateSpec) {
   const _mutate = (items) => {
-    const mutatedItems = [];
-    for (const item of items) {
-      const mutatedItem = {...item};
+    const mutatedItems = items.map((d) => ({...d}));
+    let i = 0;
+    for (const mutatedItem of mutatedItems) {
       for (const key in mutateSpec) {
         const mutateSpecValue = mutateSpec[key];
-        const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItem) : mutateSpecValue;
+        const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItem, i, mutatedItems) : mutateSpecValue;
         mutatedItem[key] = mutatedResult;
       }
-      mutatedItems.push(mutatedItem);
+      ++i;
     }
     return mutatedItems;
   };

package/dist/es/mutate.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutate.js","sources":["../../src/mutate.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { A } from 'ts-toolbelt';\n\ntype MutateSpecValue<T, O = any> = ((item: T) => O) | NonFunctionValue;\nexport type MutateSpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T, MSpec extends MutateSpec<T>> = T & ResolvedObj<MSpec>;\n\ntype Compute<T> = A.Compute<T>;\n\n/**\n * Mutates items, one item at a time. For mutating across multiple items,\n * use mutateWithSummary.\n * @param mutateSpec\n */\nexport function mutate<T extends object, MSpec extends MutateSpec<T>>(\n  mutateSpec: MSpec\n): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    const mutatedItems: MutatedT[] = [];\n\n    // we can update each item completely one at a time, since mutate doesn't\n    // support looking across items. Use mutateWithSummary for that.\n    for (const item of items) {\n      const mutatedItem = { ...item } as MutatedT;\n\n      for (const key in mutateSpec) {\n        // get the mutated value for this item (either run the fn or use the constant)\n        const mutateSpecValue = mutateSpec[key];\n        const mutatedResult =\n          typeof mutateSpecValue === 'function'\n            ? mutateSpecValue(mutatedItem)\n            : mutateSpecValue;\n\n        mutatedItem[key as keyof MutatedT] = mutatedResult;\n      }\n\n      mutatedItems.push(mutatedItem);\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":"gBAuBE;AAIA,QAAM,UAAwC,CAC5C;AAGA,UAAM,eAA2B;AAIjC,eAAW,QAAQ;AACjB,YAAM,cAAc,IAAK;AAEzB,iBAAW,OAAO;AAEhB,cAAM,kBAAkB,WAAW;AACnC,cAAM,gBACJ,OAAO,oBAAoB,aACvB,gBAAgB,eAChB;AAEN,oBAAY,OAAyB;AAAA;AAGvC,mBAAa,KAAK;AAAA;AAGpB,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}
+{"version":3,"file":"mutate.js","sources":["../../src/mutate.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { A } from 'ts-toolbelt';\n\ntype MutateSpecValue<T, O = any> =\n  | ((item: T, index: number, array: Iterable<T>) => O)\n  | NonFunctionValue;\nexport type MutateSpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T, MSpec extends MutateSpec<T>> = T & ResolvedObj<MSpec>;\n\ntype Compute<T> = A.Compute<T>;\n\n/**\n * Mutates items, one item at a time. For mutating across multiple items,\n * use mutateWithSummary.\n * @param mutateSpec\n */\nexport function mutate<T extends object, MSpec extends MutateSpec<T>>(\n  mutateSpec: MSpec\n): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    // note we start with the original array so when we pass it as the third argument\n    // to a mutate function, you get the values that have been changed so far\n    const mutatedItems: MutatedT[] = items.map((d) => ({ ...d })) as MutatedT[];\n\n    // we can update each item completely one at a time, since mutate doesn't\n    // support looking across items. Use mutateWithSummary for that.\n    let i = 0;\n    for (const mutatedItem of mutatedItems) {\n      for (const key in mutateSpec) {\n        // get the mutated value for this item (either run the fn or use the constant)\n        const mutateSpecValue = mutateSpec[key];\n        const mutatedResult =\n          typeof mutateSpecValue === 'function'\n            ? mutateSpecValue(mutatedItem, i, mutatedItems)\n            : mutateSpecValue;\n\n        mutatedItem[key as keyof MutatedT] = mutatedResult;\n      }\n\n      ++i;\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":"gBAyBE;AAIA,QAAM,UAAwC,CAC5C;AAKA,UAAM,eAA2B,MAAM,IAAI,CAAC,WAAY;AAIxD,QAAI,IAAI;AACR,eAAW,eAAe;AACxB,iBAAW,OAAO;AAEhB,cAAM,kBAAkB,WAAW;AACnC,cAAM,gBACJ,OAAO,oBAAoB,aACvB,gBAAgB,aAAa,GAAG,gBAChC;AAEN,oBAAY,OAAyB;AAAA;AAGvC,QAAE;AAAA;AAGJ,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}

package/dist/es/summary/deviation.js.map

@@ -1 +1 @@
-{"version":3,"file":"deviation.js","sources":["../../../src/summary/deviation.ts"],"sourcesContent":["import { deviation as d3deviation } from 'd3-array';\n\n/**\n * Returns a function that computes the deviation over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function deviation<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3deviation(items, keyFn);\n}\n"],"names":["d3deviation"],"mappings":";;mBAM4C;AAC1C,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,YAAY,OAAO;AAAA;;;;"}
+{"version":3,"file":"deviation.js","sources":["../../../src/summary/deviation.ts"],"sourcesContent":["import { deviation as d3deviation } from 'd3-array';\n\n/**\n * Returns a function that computes the deviation over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function deviation<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3deviation(items, keyFn);\n}\n"],"names":["d3deviation"],"mappings":";;mBAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,YAAY,OAAO;AAAA;;;;"}

package/dist/es/summary/max.js.map

@@ -1 +1 @@
-{"version":3,"file":"max.js","sources":["../../../src/summary/max.ts"],"sourcesContent":["import { max as d3max } from 'd3-array';\n\n/**\n * Returns a function that computes the max over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function max<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3max(items, keyFn);\n}\n"],"names":["d3max"],"mappings":";;aAMsC;AACpC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,MAAM,OAAO;AAAA;;;;"}
+{"version":3,"file":"max.js","sources":["../../../src/summary/max.ts"],"sourcesContent":["import { max as d3max } from 'd3-array';\n\n/**\n * Returns a function that computes the max over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function max<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3max(items, keyFn);\n}\n"],"names":["d3max"],"mappings":";;aAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,MAAM,OAAO;AAAA;;;;"}

package/dist/es/summary/mean.js.map

@@ -1 +1 @@
-{"version":3,"file":"mean.js","sources":["../../../src/summary/mean.ts"],"sourcesContent":["import { mean as meanInternal } from '../helpers/summation';\n\n/**\n * Returns a function that computes the mean over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function mean<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => meanInternal(items, keyFn);\n}\n"],"names":["meanInternal"],"mappings":";;cAMuC;AACrC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,OAAa,OAAO;AAAA;;;;"}
+{"version":3,"file":"mean.js","sources":["../../../src/summary/mean.ts"],"sourcesContent":["import { mean as meanInternal } from '../helpers/summation';\n\n/**\n * Returns a function that computes the mean over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function mean<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => meanInternal(items, keyFn);\n}\n"],"names":["meanInternal"],"mappings":";;cAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,OAAa,OAAO;AAAA;;;;"}

package/dist/es/summary/meanRate.js.map

@@ -1 +1 @@
-{"version":3,"file":"meanRate.js","sources":["../../../src/summary/meanRate.ts"],"sourcesContent":["import { fsum } from 'd3-array';\nimport { rate } from '../math/math';\n\n/**\n * Returns a function that computes the mean of a rate over an array of items\n * @param numerator A string key of the object or an accessor converting the object to a number\n * @param denominator A string key of the object or an accessor converting the object to a number\n */\nexport function meanRate<T extends object>(\n  numerator: keyof T | ((d: T) => number),\n  denominator: keyof T | ((d: T) => number)\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  return (items: T[]) => {\n    const numerator = fsum(items, numeratorFn);\n    const denominator = fsum(items, denominatorFn);\n    return rate(numerator, denominator);\n  };\n}\n"],"names":[],"mappings":";;;kBASE,WACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,SAAO,CAAC;AACN,UAAM,aAAY,KAAK,OAAO;AAC9B,UAAM,eAAc,KAAK,OAAO;AAChC,WAAO,KAAK,YAAW;AAAA;AAAA;;;;"}
+{"version":3,"file":"meanRate.js","sources":["../../../src/summary/meanRate.ts"],"sourcesContent":["import { fsum } from 'd3-array';\nimport { rate } from '../math/math';\n\n/**\n * Returns a function that computes the mean of a rate over an array of items\n * @param numerator A string key of the object or an accessor converting the object to a number\n * @param denominator A string key of the object or an accessor converting the object to a number\n */\nexport function meanRate<T extends object>(\n  numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  return (items: T[]) => {\n    const numerator = fsum(items, numeratorFn);\n    const denominator = fsum(items, denominatorFn);\n    return rate(numerator, denominator);\n  };\n}\n"],"names":[],"mappings":";;;kBASE,WACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,SAAO,CAAC;AACN,UAAM,aAAY,KAAK,OAAO;AAC9B,UAAM,eAAc,KAAK,OAAO;AAChC,WAAO,KAAK,YAAW;AAAA;AAAA;;;;"}

package/dist/es/summary/median.js.map

@@ -1 +1 @@
-{"version":3,"file":"median.js","sources":["../../../src/summary/median.ts"],"sourcesContent":["import { median as d3median } from 'd3-array';\n\n/**\n * Returns a function that computes the median over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function median<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3median(items, keyFn);\n}\n"],"names":["d3median"],"mappings":";;gBAMyC;AACvC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,SAAS,OAAO;AAAA;;;;"}
+{"version":3,"file":"median.js","sources":["../../../src/summary/median.ts"],"sourcesContent":["import { median as d3median } from 'd3-array';\n\n/**\n * Returns a function that computes the median over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function median<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3median(items, keyFn);\n}\n"],"names":["d3median"],"mappings":";;gBAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,SAAS,OAAO;AAAA;;;;"}

package/dist/es/summary/min.js.map

@@ -1 +1 @@
-{"version":3,"file":"min.js","sources":["../../../src/summary/min.ts"],"sourcesContent":["import { min as d3min } from 'd3-array';\n\n/**\n * Returns a function that computes the min over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function min<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3min(items, keyFn);\n}\n"],"names":["d3min"],"mappings":";;aAMsC;AACpC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,MAAM,OAAO;AAAA;;;;"}
+{"version":3,"file":"min.js","sources":["../../../src/summary/min.ts"],"sourcesContent":["import { min as d3min } from 'd3-array';\n\n/**\n * Returns a function that computes the min over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function min<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3min(items, keyFn);\n}\n"],"names":["d3min"],"mappings":";;aAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,MAAM,OAAO;AAAA;;;;"}

package/dist/es/summary/n.js

@@ -1,4 +1,8 @@
-function n() {
+function n(options) {
+  if (options == null ? void 0 : options.predicate) {
+    const predicate = options.predicate;
+    return (items) => items.reduce((n2, d, i) => predicate(d, i, items) ? n2 + 1 : n2, 0);
+  }
   return (items) => items.length;
 }
 

package/dist/es/summary/n.js.map

@@ -1 +1 @@
-{"version":3,"file":"n.js","sources":["../../../src/summary/n.ts"],"sourcesContent":["/**\n * Returns a function that computes the count over an array of items\n */\nexport function n() {\n  return (items: any[]) => items.length;\n}\n"],"names":[],"mappings":";AAIE,SAAO,CAAC,UAAiB,MAAM;AAAA;;;;"}
+{"version":3,"file":"n.js","sources":["../../../src/summary/n.ts"],"sourcesContent":["type NOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n};\n\n/**\n * Returns a function that computes the count over an array of items\n */\nexport function n<T>(options?: NOptions<T>) {\n  if (options?.predicate) {\n    const predicate = options.predicate;\n    return (items: T[]) =>\n      items.reduce((n, d, i) => (predicate(d, i, items) ? n + 1 : n), 0);\n  }\n\n  return (items: T[]) => items.length;\n}\n"],"names":[],"mappings":"WAOqB;AACnB,MAAI,mCAAS;AACX,UAAM,YAAY,QAAQ;AAC1B,WAAO,CAAC,UACN,MAAM,OAAO,CAAC,IAAG,GAAG,MAAO,UAAU,GAAG,GAAG,SAAS,KAAI,IAAI,IAAI;AAAA;AAGpE,SAAO,CAAC,UAAe,MAAM;AAAA;;;;"}

package/dist/es/summary/nDistinct.js

@@ -3,8 +3,9 @@ function nDistinct(key, options = {}) {
   return (items) => {
     const uniques = new Map();
     let count = 0;
+    let i = 0;
     for (const item of items) {
-      const value = keyFn(item);
+      const value = keyFn(item, i++, items);
       if (!uniques.has(value)) {
         if (!options.includeUndefined && value === void 0 || options.includeNull === false && value === null) {
           continue;

package/dist/es/summary/nDistinct.js.map

@@ -1 +1 @@
-{"version":3,"file":"nDistinct.js","sources":["../../../src/summary/nDistinct.ts"],"sourcesContent":["/**\n * Returns a function that computes the distinct count for a key\n * over an array of items. By default it counts nulls but not undefined\n */\nexport function nDistinct<T extends object>(\n  key: keyof T | ((d: T) => any),\n  options: { includeNull?: boolean; includeUndefined?: boolean } = {}\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  return (items: T[]) => {\n    const uniques = new Map();\n    let count = 0;\n\n    for (const item of items) {\n      const value = keyFn(item);\n\n      if (!uniques.has(value)) {\n        // default includes null but not undefined\n        if (\n          (!options.includeUndefined && value === undefined) ||\n          (options.includeNull === false && value === null)\n        ) {\n          continue;\n        }\n\n        count += 1;\n        uniques.set(value, true);\n      }\n    }\n\n    return count;\n  };\n}\n"],"names":[],"mappings":"mBAKE,KACA,UAAiE;AAEjE,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,SAAO,CAAC;AACN,UAAM,UAAU,IAAI;AACpB,QAAI,QAAQ;AAEZ,eAAW,QAAQ;AACjB,YAAM,QAAQ,MAAM;AAEpB,UAAI,CAAC,QAAQ,IAAI;AAEf,YACG,CAAC,QAAQ,oBAAoB,UAAU,UACvC,QAAQ,gBAAgB,SAAS,UAAU;AAE5C;AAAA;AAGF,iBAAS;AACT,gBAAQ,IAAI,OAAO;AAAA;AAAA;AAIvB,WAAO;AAAA;AAAA;;;;"}
+{"version":3,"file":"nDistinct.js","sources":["../../../src/summary/nDistinct.ts"],"sourcesContent":["/**\n * Returns a function that computes the distinct count for a key\n * over an array of items. By default it counts nulls but not undefined\n */\nexport function nDistinct<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => any),\n  options: { includeNull?: boolean; includeUndefined?: boolean } = {}\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  return (items: T[]) => {\n    const uniques = new Map();\n    let count = 0;\n\n    let i = 0;\n    for (const item of items) {\n      const value = keyFn(item, i++, items);\n\n      if (!uniques.has(value)) {\n        // default includes null but not undefined\n        if (\n          (!options.includeUndefined && value === undefined) ||\n          (options.includeNull === false && value === null)\n        ) {\n          continue;\n        }\n\n        count += 1;\n        uniques.set(value, true);\n      }\n    }\n\n    return count;\n  };\n}\n"],"names":[],"mappings":"mBAKE,KACA,UAAiE;AAEjE,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,SAAO,CAAC;AACN,UAAM,UAAU,IAAI;AACpB,QAAI,QAAQ;AAEZ,QAAI,IAAI;AACR,eAAW,QAAQ;AACjB,YAAM,QAAQ,MAAM,MAAM,KAAK;AAE/B,UAAI,CAAC,QAAQ,IAAI;AAEf,YACG,CAAC,QAAQ,oBAAoB,UAAU,UACvC,QAAQ,gBAAgB,SAAS,UAAU;AAE5C;AAAA;AAGF,iBAAS;AACT,gBAAQ,IAAI,OAAO;AAAA;AAAA;AAIvB,WAAO;AAAA;AAAA;;;;"}

package/dist/es/summary/sum.js

@@ -1,7 +1,12 @@
 import { fsum } from 'd3-array';
 
-function sum(key) {
-  const keyFn = typeof key === "function" ? key : (d) => d[key];
+function sum(key, options) {
+  let keyFn = typeof key === "function" ? key : (d) => d[key];
+  if (options == null ? void 0 : options.predicate) {
+    const originalKeyFn = keyFn;
+    const predicate = options.predicate;
+    keyFn = (d, index, array) => predicate(d, index, array) ? originalKeyFn(d, index, array) : 0;
+  }
   return (items) => fsum(items, keyFn);
 }
 

package/dist/es/summary/sum.js.map

@@ -1 +1 @@
-{"version":3,"file":"sum.js","sources":["../../../src/summary/sum.ts"],"sourcesContent":["import { fsum } from 'd3-array';\n\n/**\n * Returns a function that computes the sum over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function sum<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => fsum(items, keyFn);\n}\n"],"names":[],"mappings":";;aAMsC;AACpC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAe,KAAK,OAAO;AAAA;;;;"}
+{"version":3,"file":"sum.js","sources":["../../../src/summary/sum.ts"],"sourcesContent":["import { fsum } from 'd3-array';\n\ntype SumOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n};\n\n/**\n * Returns a function that computes the sum over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function sum<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  options?: SumOptions<T>\n) {\n  let keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  if (options?.predicate) {\n    const originalKeyFn = keyFn;\n    const predicate = options.predicate;\n    keyFn = (d: T, index: number, array: Iterable<T>) =>\n      predicate(d, index, array) ? originalKeyFn(d, index, array) : 0;\n  }\n\n  return (items: T[]) => fsum(items, keyFn);\n}\n"],"names":[],"mappings":";;aAWE,KACA;AAEA,MAAI,QACF,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,MAAI,mCAAS;AACX,UAAM,gBAAgB;AACtB,UAAM,YAAY,QAAQ;AAC1B,YAAQ,CAAC,GAAM,OAAe,UAC5B,UAAU,GAAG,OAAO,SAAS,cAAc,GAAG,OAAO,SAAS;AAAA;AAGlE,SAAO,CAAC,UAAe,KAAK,OAAO;AAAA;;;;"}

package/dist/es/summary/variance.js.map

@@ -1 +1 @@
-{"version":3,"file":"variance.js","sources":["../../../src/summary/variance.ts"],"sourcesContent":["import { variance as d3variance } from 'd3-array';\n\n/**\n * Returns a function that computes the variance over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function variance<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3variance(items, keyFn);\n}\n"],"names":["d3variance"],"mappings":";;kBAM2C;AACzC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,WAAW,OAAO;AAAA;;;;"}
+{"version":3,"file":"variance.js","sources":["../../../src/summary/variance.ts"],"sourcesContent":["import { variance as d3variance } from 'd3-array';\n\n/**\n * Returns a function that computes the variance over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function variance<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3variance(items, keyFn);\n}\n"],"names":["d3variance"],"mappings":";;kBAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,WAAW,OAAO;AAAA;;;;"}

package/dist/es/vector/cumsum.js.map

@@ -1 +1 @@
-{"version":3,"file":"cumsum.js","sources":["../../../src/vector/cumsum.ts"],"sourcesContent":["import { fcumsum } from '../helpers/summation';\n\nexport function cumsum<T extends object>(\n  key: keyof T | ((d: T) => number | null | undefined)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  // note returns Float64Array not a normal array\n  return (items: T[]) => fcumsum(items, keyFn);\n}\n"],"names":[],"mappings":";;gBAGE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAGjD,SAAO,CAAC,UAAe,QAAQ,OAAO;AAAA;;;;"}
+{"version":3,"file":"cumsum.js","sources":["../../../src/vector/cumsum.ts"],"sourcesContent":["import { fcumsum } from '../helpers/summation';\n\nexport function cumsum<T extends object>(\n  key:\n    | keyof T\n    | ((d: T, index: number, array: Iterable<T>) => number | null | undefined)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  // note returns Float64Array not a normal array\n  return (items: T[]) => fcumsum(items, keyFn);\n}\n"],"names":[],"mappings":";;gBAGE;AAIA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAGjD,SAAO,CAAC,UAAe,QAAQ,OAAO;AAAA;;;;"}

package/dist/es/vector/lag.js

@@ -4,7 +4,7 @@ function lag(key, options) {
   return (items) => {
     return items.map((_, i) => {
       const lagItem = items[i - n];
-      return lagItem == null ? defaultValue : keyFn(lagItem);
+      return lagItem == null ? defaultValue : keyFn(lagItem, i, items);
     });
   };
 }

package/dist/es/vector/lag.js.map

@@ -1 +1 @@
-{"version":3,"file":"lag.js","sources":["../../../src/vector/lag.ts"],"sourcesContent":["type LagOptions = {\n  /** Number of positions to lag by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a function that lags a vector by a specified offset (n). Useful for\n * finding previous values to compute deltas with later.\n * @param key The key or accessor to lag\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lag<T extends object>(\n  key: keyof T | ((d: T) => any),\n  options?: LagOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: any[]) => {\n    return items.map((_, i) => {\n      const lagItem = items[i - n];\n      return lagItem == null ? defaultValue : keyFn(lagItem);\n    });\n  };\n}\n"],"names":[],"mappings":"aAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,UAAU,MAAM,IAAI;AAC1B,aAAO,WAAW,OAAO,eAAe,MAAM;AAAA;AAAA;AAAA;;;;"}
+{"version":3,"file":"lag.js","sources":["../../../src/vector/lag.ts"],"sourcesContent":["type LagOptions = {\n  /** Number of positions to lag by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a function that lags a vector by a specified offset (n). Useful for\n * finding previous values to compute deltas with later.\n * @param key The key or accessor to lag\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lag<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => any),\n  options?: LagOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: T[]) => {\n    return items.map((_, i) => {\n      const lagItem = items[i - n];\n      return lagItem == null ? defaultValue : keyFn(lagItem, i, items);\n    });\n  };\n}\n"],"names":[],"mappings":"aAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,UAAU,MAAM,IAAI;AAC1B,aAAO,WAAW,OAAO,eAAe,MAAM,SAAS,GAAG;AAAA;AAAA;AAAA;;;;"}

package/dist/es/vector/lead.js

@@ -4,7 +4,7 @@ function lead(key, options) {
   return (items) => {
     return items.map((_, i) => {
       const leadItem = items[i + n];
-      return leadItem == null ? defaultValue : keyFn(leadItem);
+      return leadItem == null ? defaultValue : keyFn(leadItem, i, items);
     });
   };
 }

package/dist/es/vector/lead.js.map

@@ -1 +1 @@
-{"version":3,"file":"lead.js","sources":["../../../src/vector/lead.ts"],"sourcesContent":["type LeadOptions = {\n  /** Number of positions to lead by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a functions that leads a vector by a specified offset (n). Useful for\n * finding next values for computing deltas with.\n * @param key The key or accessor to lead\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lead<T extends object>(\n  key: keyof T | ((d: T) => any),\n  options?: LeadOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: any[]) => {\n    return items.map((_, i) => {\n      const leadItem = items[i + n];\n      return leadItem == null ? defaultValue : keyFn(leadItem);\n    });\n  };\n}\n"],"names":[],"mappings":"cAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,WAAW,MAAM,IAAI;AAC3B,aAAO,YAAY,OAAO,eAAe,MAAM;AAAA;AAAA;AAAA;;;;"}
+{"version":3,"file":"lead.js","sources":["../../../src/vector/lead.ts"],"sourcesContent":["type LeadOptions = {\n  /** Number of positions to lead by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a functions that leads a vector by a specified offset (n). Useful for\n * finding next values for computing deltas with.\n * @param key The key or accessor to lead\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lead<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => any),\n  options?: LeadOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: T[]) => {\n    return items.map((_, i) => {\n      const leadItem = items[i + n];\n      return leadItem == null ? defaultValue : keyFn(leadItem, i, items);\n    });\n  };\n}\n"],"names":[],"mappings":"cAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,WAAW,MAAM,IAAI;AAC3B,aAAO,YAAY,OAAO,eAAe,MAAM,UAAU,GAAG;AAAA;AAAA;AAAA;;;;"}

package/dist/es/vector/rowNumber.js

@@ -0,0 +1,10 @@
+function rowNumber(options) {
+  var _a;
+  const startAt = (_a = options == null ? void 0 : options.startAt) != null ? _a : 0;
+  return (items) => {
+    return items.map((_, i) => i + startAt);
+  };
+}
+
+export { rowNumber };
+//# sourceMappingURL=rowNumber.js.map

package/dist/es/vector/rowNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowNumber.js","sources":["../../../src/vector/rowNumber.ts"],"sourcesContent":["type RowNumberOptions = {\n  /** what to start row numbers at, default is 0 */\n  startAt?: number;\n};\n\n/**\n * Returns a vector of row numbers, starting at 0\n */\nexport function rowNumber<T>(options?: RowNumberOptions) {\n  const startAt = options?.startAt ?? 0;\n  return (items: T[]) => {\n    return items.map((_, i) => i + startAt);\n  };\n}\n"],"names":[],"mappings":"mBAQ6B;AAR7B;AASE,QAAM,UAAU,yCAAS,YAAT,YAAoB;AACpC,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG,MAAM,IAAI;AAAA;AAAA;;;;"}

package/dist/lib/index.js

@@ -36,6 +36,7 @@ var cumsum = require('./vector/cumsum.js');
 var roll = require('./vector/roll.js');
 var lag = require('./vector/lag.js');
 var lead = require('./vector/lead.js');
+var rowNumber = require('./vector/rowNumber.js');
 var sum = require('./summary/sum.js');
 var min = require('./summary/min.js');
 var max = require('./summary/max.js');
@@ -114,6 +115,7 @@ exports.cumsum = cumsum.cumsum;
 exports.roll = roll.roll;
 exports.lag = lag.lag;
 exports.lead = lead.lead;
+exports.rowNumber = rowNumber.rowNumber;
 exports.sum = sum.sum;
 exports.min = min.min;
 exports.max = max.max;

package/dist/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/lib/item/rate.js

@@ -8,15 +8,15 @@ function rate(numerator, denominator, options) {
   const numeratorFn = typeof numerator === "function" ? numerator : (d) => d[numerator];
   const denominatorFn = typeof denominator === "function" ? denominator : (d) => d[denominator];
   const {predicate, allowDivideByZero} = options != null ? options : {};
-  return predicate == null ? (d) => {
-    const denom = denominatorFn(d);
-    const numer = numeratorFn(d);
+  return predicate == null ? (d, index, array) => {
+    const denom = denominatorFn(d, index, array);
+    const numer = numeratorFn(d, index, array);
     return math.rate(numer, denom, allowDivideByZero);
-  } : (d) => {
-    if (!predicate(d))
+  } : (d, index, array) => {
+    if (!predicate(d, index, array))
       return void 0;
-    const denom = denominatorFn(d);
-    const numer = numeratorFn(d);
+    const denom = denominatorFn(d, index, array);
+    const numer = numeratorFn(d, index, array);
     return math.rate(numer, denom, allowDivideByZero);
   };
 }

package/dist/lib/item/rate.js.map

@@ -1 +1 @@
-{"version":3,"file":"rate.js","sources":["../../../src/item/rate.ts"],"sourcesContent":["import { rate as mathRate } from '../math/math';\n\ntype RateOptions<T> = {\n  predicate?: (d: T) => boolean;\n  allowDivideByZero?: boolean;\n};\n\n/**\n * Returns a function that computes a rate (numerator / denominator), setting the value to\n * 0 if denominator = 0 and numerator = 0.\n */\nexport function rate<T extends object>(\n  numerator: keyof T | ((d: T) => number),\n  denominator: keyof T | ((d: T) => number),\n  options?: RateOptions<T>\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  const { predicate, allowDivideByZero } = options ?? {};\n  return predicate == null\n    ? (d: T) => {\n        const denom = denominatorFn(d);\n        const numer = numeratorFn(d);\n        return mathRate(numer, denom, allowDivideByZero);\n      }\n    : (d: T) => {\n        if (!predicate(d)) return undefined;\n\n        const denom = denominatorFn(d);\n        const numer = numeratorFn(d);\n        return mathRate(numer, denom, allowDivideByZero);\n      };\n}\n"],"names":["mathRate"],"mappings":";;;;;;cAYE,WACA,aACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,QAAM,CAAE,WAAW,qBAAsB,4BAAW;AACpD,SAAO,aAAa,OAChB,CAAC;AACC,UAAM,QAAQ,cAAc;AAC5B,UAAM,QAAQ,YAAY;AAC1B,WAAOA,UAAS,OAAO,OAAO;AAAA,MAEhC,CAAC;AACC,QAAI,CAAC,UAAU;AAAI,aAAO;AAE1B,UAAM,QAAQ,cAAc;AAC5B,UAAM,QAAQ,YAAY;AAC1B,WAAOA,UAAS,OAAO,OAAO;AAAA;AAAA;;;;"}
+{"version":3,"file":"rate.js","sources":["../../../src/item/rate.ts"],"sourcesContent":["import { rate as mathRate } from '../math/math';\n\ntype RateOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n  allowDivideByZero?: boolean;\n};\n\n/**\n * Returns a function that computes a rate (numerator / denominator), setting the value to\n * 0 if denominator = 0 and numerator = 0.\n */\nexport function rate<T extends object>(\n  numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  options?: RateOptions<T>\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  const { predicate, allowDivideByZero } = options ?? {};\n  return predicate == null\n    ? (d: T, index: number, array: Iterable<T>) => {\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      }\n    : (d: T, index: number, array: Iterable<T>) => {\n        if (!predicate(d, index, array)) return undefined;\n\n        const denom = denominatorFn(d, index, array);\n        const numer = numeratorFn(d, index, array);\n        return mathRate(numer, denom, allowDivideByZero);\n      };\n}\n"],"names":["mathRate"],"mappings":";;;;;;cAYE,WACA,aACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,QAAM,CAAE,WAAW,qBAAsB,4BAAW;AACpD,SAAO,aAAa,OAChB,CAAC,GAAM,OAAe;AACpB,UAAM,QAAQ,cAAc,GAAG,OAAO;AACtC,UAAM,QAAQ,YAAY,GAAG,OAAO;AACpC,WAAOA,UAAS,OAAO,OAAO;AAAA,MAEhC,CAAC,GAAM,OAAe;AACpB,QAAI,CAAC,UAAU,GAAG,OAAO;AAAQ,aAAO;AAExC,UAAM,QAAQ,cAAc,GAAG,OAAO;AACtC,UAAM,QAAQ,YAAY,GAAG,OAAO;AACpC,WAAOA,UAAS,OAAO,OAAO;AAAA;AAAA;;;;"}

package/dist/lib/mutate.js

@@ -4,15 +4,15 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function mutate(mutateSpec) {
   const _mutate = (items) => {
-    const mutatedItems = [];
-    for (const item of items) {
-      const mutatedItem = {...item};
+    const mutatedItems = items.map((d) => ({...d}));
+    let i = 0;
+    for (const mutatedItem of mutatedItems) {
       for (const key in mutateSpec) {
         const mutateSpecValue = mutateSpec[key];
-        const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItem) : mutateSpecValue;
+        const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItem, i, mutatedItems) : mutateSpecValue;
         mutatedItem[key] = mutatedResult;
       }
-      mutatedItems.push(mutatedItem);
+      ++i;
     }
     return mutatedItems;
   };

package/dist/lib/mutate.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutate.js","sources":["../../src/mutate.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { A } from 'ts-toolbelt';\n\ntype MutateSpecValue<T, O = any> = ((item: T) => O) | NonFunctionValue;\nexport type MutateSpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T, MSpec extends MutateSpec<T>> = T & ResolvedObj<MSpec>;\n\ntype Compute<T> = A.Compute<T>;\n\n/**\n * Mutates items, one item at a time. For mutating across multiple items,\n * use mutateWithSummary.\n * @param mutateSpec\n */\nexport function mutate<T extends object, MSpec extends MutateSpec<T>>(\n  mutateSpec: MSpec\n): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    const mutatedItems: MutatedT[] = [];\n\n    // we can update each item completely one at a time, since mutate doesn't\n    // support looking across items. Use mutateWithSummary for that.\n    for (const item of items) {\n      const mutatedItem = { ...item } as MutatedT;\n\n      for (const key in mutateSpec) {\n        // get the mutated value for this item (either run the fn or use the constant)\n        const mutateSpecValue = mutateSpec[key];\n        const mutatedResult =\n          typeof mutateSpecValue === 'function'\n            ? mutateSpecValue(mutatedItem)\n            : mutateSpecValue;\n\n        mutatedItem[key as keyof MutatedT] = mutatedResult;\n      }\n\n      mutatedItems.push(mutatedItem);\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":";;;;gBAuBE;AAIA,QAAM,UAAwC,CAC5C;AAGA,UAAM,eAA2B;AAIjC,eAAW,QAAQ;AACjB,YAAM,cAAc,IAAK;AAEzB,iBAAW,OAAO;AAEhB,cAAM,kBAAkB,WAAW;AACnC,cAAM,gBACJ,OAAO,oBAAoB,aACvB,gBAAgB,eAChB;AAEN,oBAAY,OAAyB;AAAA;AAGvC,mBAAa,KAAK;AAAA;AAGpB,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}
+{"version":3,"file":"mutate.js","sources":["../../src/mutate.ts"],"sourcesContent":["import { TidyFn, NonFunctionValue, Key } from './types';\nimport { A } from 'ts-toolbelt';\n\ntype MutateSpecValue<T, O = any> =\n  | ((item: T, index: number, array: Iterable<T>) => O)\n  | NonFunctionValue;\nexport type MutateSpec<T> = Record<Key, MutateSpecValue<T>>;\nexport type ResolvedObj<Obj extends Record<Key, MutateSpecValue<any>>> = {\n  [K in keyof Obj]: Obj[K] extends (...args: any) => any\n    ? ReturnType<Obj[K]> extends any[]\n      ? ReturnType<Obj[K]>[number]\n      : ReturnType<Obj[K]>\n    : Obj[K];\n};\n\ntype Mutated<T, MSpec extends MutateSpec<T>> = T & ResolvedObj<MSpec>;\n\ntype Compute<T> = A.Compute<T>;\n\n/**\n * Mutates items, one item at a time. For mutating across multiple items,\n * use mutateWithSummary.\n * @param mutateSpec\n */\nexport function mutate<T extends object, MSpec extends MutateSpec<T>>(\n  mutateSpec: MSpec\n): TidyFn<T, Compute<Mutated<T, MSpec>>> {\n  type MutatedT = Mutated<T, MSpec>;\n  // use Compute for better intellisense (reveals all keys in obj)\n  const _mutate: TidyFn<T, Compute<MutatedT>> = (\n    items: T[]\n  ): Compute<MutatedT>[] => {\n    // create the base items to merge mutated values into\n    // note we start with the original array so when we pass it as the third argument\n    // to a mutate function, you get the values that have been changed so far\n    const mutatedItems: MutatedT[] = items.map((d) => ({ ...d })) as MutatedT[];\n\n    // we can update each item completely one at a time, since mutate doesn't\n    // support looking across items. Use mutateWithSummary for that.\n    let i = 0;\n    for (const mutatedItem of mutatedItems) {\n      for (const key in mutateSpec) {\n        // get the mutated value for this item (either run the fn or use the constant)\n        const mutateSpecValue = mutateSpec[key];\n        const mutatedResult =\n          typeof mutateSpecValue === 'function'\n            ? mutateSpecValue(mutatedItem, i, mutatedItems)\n            : mutateSpecValue;\n\n        mutatedItem[key as keyof MutatedT] = mutatedResult;\n      }\n\n      ++i;\n    }\n\n    return mutatedItems as Compute<MutatedT>[];\n  };\n\n  return _mutate;\n}\n"],"names":[],"mappings":";;;;gBAyBE;AAIA,QAAM,UAAwC,CAC5C;AAKA,UAAM,eAA2B,MAAM,IAAI,CAAC,WAAY;AAIxD,QAAI,IAAI;AACR,eAAW,eAAe;AACxB,iBAAW,OAAO;AAEhB,cAAM,kBAAkB,WAAW;AACnC,cAAM,gBACJ,OAAO,oBAAoB,aACvB,gBAAgB,aAAa,GAAG,gBAChC;AAEN,oBAAY,OAAyB;AAAA;AAGvC,QAAE;AAAA;AAGJ,WAAO;AAAA;AAGT,SAAO;AAAA;;;;"}

package/dist/lib/summary/deviation.js.map

@@ -1 +1 @@
-{"version":3,"file":"deviation.js","sources":["../../../src/summary/deviation.ts"],"sourcesContent":["import { deviation as d3deviation } from 'd3-array';\n\n/**\n * Returns a function that computes the deviation over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function deviation<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3deviation(items, keyFn);\n}\n"],"names":["d3deviation"],"mappings":";;;;;;mBAM4C;AAC1C,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,kBAAY,OAAO;AAAA;;;;"}
+{"version":3,"file":"deviation.js","sources":["../../../src/summary/deviation.ts"],"sourcesContent":["import { deviation as d3deviation } from 'd3-array';\n\n/**\n * Returns a function that computes the deviation over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function deviation<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3deviation(items, keyFn);\n}\n"],"names":["d3deviation"],"mappings":";;;;;;mBAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,kBAAY,OAAO;AAAA;;;;"}

package/dist/lib/summary/max.js.map

@@ -1 +1 @@
-{"version":3,"file":"max.js","sources":["../../../src/summary/max.ts"],"sourcesContent":["import { max as d3max } from 'd3-array';\n\n/**\n * Returns a function that computes the max over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function max<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3max(items, keyFn);\n}\n"],"names":["d3max"],"mappings":";;;;;;aAMsC;AACpC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,YAAM,OAAO;AAAA;;;;"}
+{"version":3,"file":"max.js","sources":["../../../src/summary/max.ts"],"sourcesContent":["import { max as d3max } from 'd3-array';\n\n/**\n * Returns a function that computes the max over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function max<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3max(items, keyFn);\n}\n"],"names":["d3max"],"mappings":";;;;;;aAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,YAAM,OAAO;AAAA;;;;"}

package/dist/lib/summary/mean.js.map

@@ -1 +1 @@
-{"version":3,"file":"mean.js","sources":["../../../src/summary/mean.ts"],"sourcesContent":["import { mean as meanInternal } from '../helpers/summation';\n\n/**\n * Returns a function that computes the mean over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function mean<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => meanInternal(items, keyFn);\n}\n"],"names":["meanInternal"],"mappings":";;;;;;cAMuC;AACrC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,eAAa,OAAO;AAAA;;;;"}
+{"version":3,"file":"mean.js","sources":["../../../src/summary/mean.ts"],"sourcesContent":["import { mean as meanInternal } from '../helpers/summation';\n\n/**\n * Returns a function that computes the mean over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function mean<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => meanInternal(items, keyFn);\n}\n"],"names":["meanInternal"],"mappings":";;;;;;cAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,eAAa,OAAO;AAAA;;;;"}

package/dist/lib/summary/meanRate.js.map

@@ -1 +1 @@
-{"version":3,"file":"meanRate.js","sources":["../../../src/summary/meanRate.ts"],"sourcesContent":["import { fsum } from 'd3-array';\nimport { rate } from '../math/math';\n\n/**\n * Returns a function that computes the mean of a rate over an array of items\n * @param numerator A string key of the object or an accessor converting the object to a number\n * @param denominator A string key of the object or an accessor converting the object to a number\n */\nexport function meanRate<T extends object>(\n  numerator: keyof T | ((d: T) => number),\n  denominator: keyof T | ((d: T) => number)\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  return (items: T[]) => {\n    const numerator = fsum(items, numeratorFn);\n    const denominator = fsum(items, denominatorFn);\n    return rate(numerator, denominator);\n  };\n}\n"],"names":["fsum","rate"],"mappings":";;;;;;;kBASE,WACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,SAAO,CAAC;AACN,UAAM,aAAYA,aAAK,OAAO;AAC9B,UAAM,eAAcA,aAAK,OAAO;AAChC,WAAOC,UAAK,YAAW;AAAA;AAAA;;;;"}
+{"version":3,"file":"meanRate.js","sources":["../../../src/summary/meanRate.ts"],"sourcesContent":["import { fsum } from 'd3-array';\nimport { rate } from '../math/math';\n\n/**\n * Returns a function that computes the mean of a rate over an array of items\n * @param numerator A string key of the object or an accessor converting the object to a number\n * @param denominator A string key of the object or an accessor converting the object to a number\n */\nexport function meanRate<T extends object>(\n  numerator: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  denominator: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const numeratorFn =\n    typeof numerator === 'function'\n      ? numerator\n      : (d: T) => (d[numerator] as unknown) as number;\n  const denominatorFn =\n    typeof denominator === 'function'\n      ? denominator\n      : (d: T) => (d[denominator] as unknown) as number;\n\n  return (items: T[]) => {\n    const numerator = fsum(items, numeratorFn);\n    const denominator = fsum(items, denominatorFn);\n    return rate(numerator, denominator);\n  };\n}\n"],"names":["fsum","rate"],"mappings":";;;;;;;kBASE,WACA;AAEA,QAAM,cACJ,OAAO,cAAc,aACjB,YACA,CAAC,MAAU,EAAE;AACnB,QAAM,gBACJ,OAAO,gBAAgB,aACnB,cACA,CAAC,MAAU,EAAE;AAEnB,SAAO,CAAC;AACN,UAAM,aAAYA,aAAK,OAAO;AAC9B,UAAM,eAAcA,aAAK,OAAO;AAChC,WAAOC,UAAK,YAAW;AAAA;AAAA;;;;"}

package/dist/lib/summary/median.js.map

@@ -1 +1 @@
-{"version":3,"file":"median.js","sources":["../../../src/summary/median.ts"],"sourcesContent":["import { median as d3median } from 'd3-array';\n\n/**\n * Returns a function that computes the median over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function median<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3median(items, keyFn);\n}\n"],"names":["d3median"],"mappings":";;;;;;gBAMyC;AACvC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,eAAS,OAAO;AAAA;;;;"}
+{"version":3,"file":"median.js","sources":["../../../src/summary/median.ts"],"sourcesContent":["import { median as d3median } from 'd3-array';\n\n/**\n * Returns a function that computes the median over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function median<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3median(items, keyFn);\n}\n"],"names":["d3median"],"mappings":";;;;;;gBAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,eAAS,OAAO;AAAA;;;;"}

package/dist/lib/summary/min.js.map

@@ -1 +1 @@
-{"version":3,"file":"min.js","sources":["../../../src/summary/min.ts"],"sourcesContent":["import { min as d3min } from 'd3-array';\n\n/**\n * Returns a function that computes the min over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function min<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3min(items, keyFn);\n}\n"],"names":["d3min"],"mappings":";;;;;;aAMsC;AACpC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,YAAM,OAAO;AAAA;;;;"}
+{"version":3,"file":"min.js","sources":["../../../src/summary/min.ts"],"sourcesContent":["import { min as d3min } from 'd3-array';\n\n/**\n * Returns a function that computes the min over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function min<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3min(items, keyFn);\n}\n"],"names":["d3min"],"mappings":";;;;;;aAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,YAAM,OAAO;AAAA;;;;"}

package/dist/lib/summary/n.js

@@ -2,7 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function n() {
+function n(options) {
+  if (options == null ? void 0 : options.predicate) {
+    const predicate = options.predicate;
+    return (items) => items.reduce((n2, d, i) => predicate(d, i, items) ? n2 + 1 : n2, 0);
+  }
   return (items) => items.length;
 }
 

package/dist/lib/summary/n.js.map

@@ -1 +1 @@
-{"version":3,"file":"n.js","sources":["../../../src/summary/n.ts"],"sourcesContent":["/**\n * Returns a function that computes the count over an array of items\n */\nexport function n() {\n  return (items: any[]) => items.length;\n}\n"],"names":[],"mappings":";;;;;AAIE,SAAO,CAAC,UAAiB,MAAM;AAAA;;;;"}
+{"version":3,"file":"n.js","sources":["../../../src/summary/n.ts"],"sourcesContent":["type NOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n};\n\n/**\n * Returns a function that computes the count over an array of items\n */\nexport function n<T>(options?: NOptions<T>) {\n  if (options?.predicate) {\n    const predicate = options.predicate;\n    return (items: T[]) =>\n      items.reduce((n, d, i) => (predicate(d, i, items) ? n + 1 : n), 0);\n  }\n\n  return (items: T[]) => items.length;\n}\n"],"names":[],"mappings":";;;;WAOqB;AACnB,MAAI,mCAAS;AACX,UAAM,YAAY,QAAQ;AAC1B,WAAO,CAAC,UACN,MAAM,OAAO,CAAC,IAAG,GAAG,MAAO,UAAU,GAAG,GAAG,SAAS,KAAI,IAAI,IAAI;AAAA;AAGpE,SAAO,CAAC,UAAe,MAAM;AAAA;;;;"}

package/dist/lib/summary/nDistinct.js

@@ -7,8 +7,9 @@ function nDistinct(key, options = {}) {
   return (items) => {
     const uniques = new Map();
     let count = 0;
+    let i = 0;
     for (const item of items) {
-      const value = keyFn(item);
+      const value = keyFn(item, i++, items);
       if (!uniques.has(value)) {
         if (!options.includeUndefined && value === void 0 || options.includeNull === false && value === null) {
           continue;

package/dist/lib/summary/nDistinct.js.map

@@ -1 +1 @@
-{"version":3,"file":"nDistinct.js","sources":["../../../src/summary/nDistinct.ts"],"sourcesContent":["/**\n * Returns a function that computes the distinct count for a key\n * over an array of items. By default it counts nulls but not undefined\n */\nexport function nDistinct<T extends object>(\n  key: keyof T | ((d: T) => any),\n  options: { includeNull?: boolean; includeUndefined?: boolean } = {}\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  return (items: T[]) => {\n    const uniques = new Map();\n    let count = 0;\n\n    for (const item of items) {\n      const value = keyFn(item);\n\n      if (!uniques.has(value)) {\n        // default includes null but not undefined\n        if (\n          (!options.includeUndefined && value === undefined) ||\n          (options.includeNull === false && value === null)\n        ) {\n          continue;\n        }\n\n        count += 1;\n        uniques.set(value, true);\n      }\n    }\n\n    return count;\n  };\n}\n"],"names":[],"mappings":";;;;mBAKE,KACA,UAAiE;AAEjE,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,SAAO,CAAC;AACN,UAAM,UAAU,IAAI;AACpB,QAAI,QAAQ;AAEZ,eAAW,QAAQ;AACjB,YAAM,QAAQ,MAAM;AAEpB,UAAI,CAAC,QAAQ,IAAI;AAEf,YACG,CAAC,QAAQ,oBAAoB,UAAU,UACvC,QAAQ,gBAAgB,SAAS,UAAU;AAE5C;AAAA;AAGF,iBAAS;AACT,gBAAQ,IAAI,OAAO;AAAA;AAAA;AAIvB,WAAO;AAAA;AAAA;;;;"}
+{"version":3,"file":"nDistinct.js","sources":["../../../src/summary/nDistinct.ts"],"sourcesContent":["/**\n * Returns a function that computes the distinct count for a key\n * over an array of items. By default it counts nulls but not undefined\n */\nexport function nDistinct<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => any),\n  options: { includeNull?: boolean; includeUndefined?: boolean } = {}\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  return (items: T[]) => {\n    const uniques = new Map();\n    let count = 0;\n\n    let i = 0;\n    for (const item of items) {\n      const value = keyFn(item, i++, items);\n\n      if (!uniques.has(value)) {\n        // default includes null but not undefined\n        if (\n          (!options.includeUndefined && value === undefined) ||\n          (options.includeNull === false && value === null)\n        ) {\n          continue;\n        }\n\n        count += 1;\n        uniques.set(value, true);\n      }\n    }\n\n    return count;\n  };\n}\n"],"names":[],"mappings":";;;;mBAKE,KACA,UAAiE;AAEjE,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,SAAO,CAAC;AACN,UAAM,UAAU,IAAI;AACpB,QAAI,QAAQ;AAEZ,QAAI,IAAI;AACR,eAAW,QAAQ;AACjB,YAAM,QAAQ,MAAM,MAAM,KAAK;AAE/B,UAAI,CAAC,QAAQ,IAAI;AAEf,YACG,CAAC,QAAQ,oBAAoB,UAAU,UACvC,QAAQ,gBAAgB,SAAS,UAAU;AAE5C;AAAA;AAGF,iBAAS;AACT,gBAAQ,IAAI,OAAO;AAAA;AAAA;AAIvB,WAAO;AAAA;AAAA;;;;"}

package/dist/lib/summary/sum.js

@@ -4,8 +4,13 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var d3Array = require('d3-array');
 
-function sum(key) {
-  const keyFn = typeof key === "function" ? key : (d) => d[key];
+function sum(key, options) {
+  let keyFn = typeof key === "function" ? key : (d) => d[key];
+  if (options == null ? void 0 : options.predicate) {
+    const originalKeyFn = keyFn;
+    const predicate = options.predicate;
+    keyFn = (d, index, array) => predicate(d, index, array) ? originalKeyFn(d, index, array) : 0;
+  }
   return (items) => d3Array.fsum(items, keyFn);
 }
 

package/dist/lib/summary/sum.js.map

@@ -1 +1 @@
-{"version":3,"file":"sum.js","sources":["../../../src/summary/sum.ts"],"sourcesContent":["import { fsum } from 'd3-array';\n\n/**\n * Returns a function that computes the sum over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function sum<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => fsum(items, keyFn);\n}\n"],"names":["fsum"],"mappings":";;;;;;aAMsC;AACpC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,aAAK,OAAO;AAAA;;;;"}
+{"version":3,"file":"sum.js","sources":["../../../src/summary/sum.ts"],"sourcesContent":["import { fsum } from 'd3-array';\n\ntype SumOptions<T> = {\n  predicate?: (d: T, index: number, array: Iterable<T>) => boolean;\n};\n\n/**\n * Returns a function that computes the sum over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function sum<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number),\n  options?: SumOptions<T>\n) {\n  let keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  if (options?.predicate) {\n    const originalKeyFn = keyFn;\n    const predicate = options.predicate;\n    keyFn = (d: T, index: number, array: Iterable<T>) =>\n      predicate(d, index, array) ? originalKeyFn(d, index, array) : 0;\n  }\n\n  return (items: T[]) => fsum(items, keyFn);\n}\n"],"names":["fsum"],"mappings":";;;;;;aAWE,KACA;AAEA,MAAI,QACF,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,MAAI,mCAAS;AACX,UAAM,gBAAgB;AACtB,UAAM,YAAY,QAAQ;AAC1B,YAAQ,CAAC,GAAM,OAAe,UAC5B,UAAU,GAAG,OAAO,SAAS,cAAc,GAAG,OAAO,SAAS;AAAA;AAGlE,SAAO,CAAC,UAAeA,aAAK,OAAO;AAAA;;;;"}

package/dist/lib/summary/variance.js.map

@@ -1 +1 @@
-{"version":3,"file":"variance.js","sources":["../../../src/summary/variance.ts"],"sourcesContent":["import { variance as d3variance } from 'd3-array';\n\n/**\n * Returns a function that computes the variance over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function variance<T extends object>(key: keyof T | ((d: T) => number)) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3variance(items, keyFn);\n}\n"],"names":["d3variance"],"mappings":";;;;;;kBAM2C;AACzC,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,iBAAW,OAAO;AAAA;;;;"}
+{"version":3,"file":"variance.js","sources":["../../../src/summary/variance.ts"],"sourcesContent":["import { variance as d3variance } from 'd3-array';\n\n/**\n * Returns a function that computes the variance over an array of items\n * @param key A string key of the object or an accessor converting the object to a number\n */\nexport function variance<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => number)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  return (items: T[]) => d3variance(items, keyFn);\n}\n"],"names":["d3variance"],"mappings":";;;;;;kBAOE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAEjD,SAAO,CAAC,UAAeA,iBAAW,OAAO;AAAA;;;;"}

package/dist/lib/vector/cumsum.js.map

@@ -1 +1 @@
-{"version":3,"file":"cumsum.js","sources":["../../../src/vector/cumsum.ts"],"sourcesContent":["import { fcumsum } from '../helpers/summation';\n\nexport function cumsum<T extends object>(\n  key: keyof T | ((d: T) => number | null | undefined)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  // note returns Float64Array not a normal array\n  return (items: T[]) => fcumsum(items, keyFn);\n}\n"],"names":["fcumsum"],"mappings":";;;;;;gBAGE;AAEA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAGjD,SAAO,CAAC,UAAeA,kBAAQ,OAAO;AAAA;;;;"}
+{"version":3,"file":"cumsum.js","sources":["../../../src/vector/cumsum.ts"],"sourcesContent":["import { fcumsum } from '../helpers/summation';\n\nexport function cumsum<T extends object>(\n  key:\n    | keyof T\n    | ((d: T, index: number, array: Iterable<T>) => number | null | undefined)\n) {\n  const keyFn =\n    typeof key === 'function' ? key : (d: T) => (d[key] as unknown) as number;\n\n  // note returns Float64Array not a normal array\n  return (items: T[]) => fcumsum(items, keyFn);\n}\n"],"names":["fcumsum"],"mappings":";;;;;;gBAGE;AAIA,QAAM,QACJ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAU,EAAE;AAGjD,SAAO,CAAC,UAAeA,kBAAQ,OAAO;AAAA;;;;"}

package/dist/lib/vector/lag.js

@@ -8,7 +8,7 @@ function lag(key, options) {
   return (items) => {
     return items.map((_, i) => {
       const lagItem = items[i - n];
-      return lagItem == null ? defaultValue : keyFn(lagItem);
+      return lagItem == null ? defaultValue : keyFn(lagItem, i, items);
     });
   };
 }

package/dist/lib/vector/lag.js.map

@@ -1 +1 @@
-{"version":3,"file":"lag.js","sources":["../../../src/vector/lag.ts"],"sourcesContent":["type LagOptions = {\n  /** Number of positions to lag by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a function that lags a vector by a specified offset (n). Useful for\n * finding previous values to compute deltas with later.\n * @param key The key or accessor to lag\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lag<T extends object>(\n  key: keyof T | ((d: T) => any),\n  options?: LagOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: any[]) => {\n    return items.map((_, i) => {\n      const lagItem = items[i - n];\n      return lagItem == null ? defaultValue : keyFn(lagItem);\n    });\n  };\n}\n"],"names":[],"mappings":";;;;aAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,UAAU,MAAM,IAAI;AAC1B,aAAO,WAAW,OAAO,eAAe,MAAM;AAAA;AAAA;AAAA;;;;"}
+{"version":3,"file":"lag.js","sources":["../../../src/vector/lag.ts"],"sourcesContent":["type LagOptions = {\n  /** Number of positions to lag by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a function that lags a vector by a specified offset (n). Useful for\n * finding previous values to compute deltas with later.\n * @param key The key or accessor to lag\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lag<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => any),\n  options?: LagOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: T[]) => {\n    return items.map((_, i) => {\n      const lagItem = items[i - n];\n      return lagItem == null ? defaultValue : keyFn(lagItem, i, items);\n    });\n  };\n}\n"],"names":[],"mappings":";;;;aAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,UAAU,MAAM,IAAI;AAC1B,aAAO,WAAW,OAAO,eAAe,MAAM,SAAS,GAAG;AAAA;AAAA;AAAA;;;;"}

package/dist/lib/vector/lead.js

@@ -8,7 +8,7 @@ function lead(key, options) {
   return (items) => {
     return items.map((_, i) => {
       const leadItem = items[i + n];
-      return leadItem == null ? defaultValue : keyFn(leadItem);
+      return leadItem == null ? defaultValue : keyFn(leadItem, i, items);
     });
   };
 }

package/dist/lib/vector/lead.js.map

@@ -1 +1 @@
-{"version":3,"file":"lead.js","sources":["../../../src/vector/lead.ts"],"sourcesContent":["type LeadOptions = {\n  /** Number of positions to lead by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a functions that leads a vector by a specified offset (n). Useful for\n * finding next values for computing deltas with.\n * @param key The key or accessor to lead\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lead<T extends object>(\n  key: keyof T | ((d: T) => any),\n  options?: LeadOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: any[]) => {\n    return items.map((_, i) => {\n      const leadItem = items[i + n];\n      return leadItem == null ? defaultValue : keyFn(leadItem);\n    });\n  };\n}\n"],"names":[],"mappings":";;;;cAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,WAAW,MAAM,IAAI;AAC3B,aAAO,YAAY,OAAO,eAAe,MAAM;AAAA;AAAA;AAAA;;;;"}
+{"version":3,"file":"lead.js","sources":["../../../src/vector/lead.ts"],"sourcesContent":["type LeadOptions = {\n  /** Number of positions to lead by (default: 1) */\n  n?: number;\n  /** The default value for non-existent rows. */\n  default?: any;\n};\n\n/**\n * Returns a functions that leads a vector by a specified offset (n). Useful for\n * finding next values for computing deltas with.\n * @param key The key or accessor to lead\n * @param options Options to configure roll. e.g. whether to run on partial windows.\n */\nexport function lead<T extends object>(\n  key: keyof T | ((d: T, index: number, array: Iterable<T>) => any),\n  options?: LeadOptions | undefined | null\n) {\n  const keyFn = typeof key === 'function' ? key : (d: T) => d[key];\n\n  const { n = 1, default: defaultValue } = options ?? {};\n\n  return (items: T[]) => {\n    return items.map((_, i) => {\n      const leadItem = items[i + n];\n      return leadItem == null ? defaultValue : keyFn(leadItem, i, items);\n    });\n  };\n}\n"],"names":[],"mappings":";;;;cAcE,KACA;AAEA,QAAM,QAAQ,OAAO,QAAQ,aAAa,MAAM,CAAC,MAAS,EAAE;AAE5D,QAAM,CAAE,IAAI,GAAG,SAAS,gBAAiB,4BAAW;AAEpD,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG;AACnB,YAAM,WAAW,MAAM,IAAI;AAC3B,aAAO,YAAY,OAAO,eAAe,MAAM,UAAU,GAAG;AAAA;AAAA;AAAA;;;;"}

package/dist/lib/vector/rowNumber.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function rowNumber(options) {
+  var _a;
+  const startAt = (_a = options == null ? void 0 : options.startAt) != null ? _a : 0;
+  return (items) => {
+    return items.map((_, i) => i + startAt);
+  };
+}
+
+exports.rowNumber = rowNumber;
+//# sourceMappingURL=rowNumber.js.map

package/dist/lib/vector/rowNumber.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rowNumber.js","sources":["../../../src/vector/rowNumber.ts"],"sourcesContent":["type RowNumberOptions = {\n  /** what to start row numbers at, default is 0 */\n  startAt?: number;\n};\n\n/**\n * Returns a vector of row numbers, starting at 0\n */\nexport function rowNumber<T>(options?: RowNumberOptions) {\n  const startAt = options?.startAt ?? 0;\n  return (items: T[]) => {\n    return items.map((_, i) => i + startAt);\n  };\n}\n"],"names":[],"mappings":";;;;mBAQ6B;AAR7B;AASE,QAAM,UAAU,yCAAS,YAAT,YAAoB;AACpC,SAAO,CAAC;AACN,WAAO,MAAM,IAAI,CAAC,GAAG,MAAM,IAAI;AAAA;AAAA;;;;"}