@tidyjs/tidy 2.5.2 → 2.6.1

package/dist/umd/tidy.js

@@ -2,7 +2,7 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-array')) :
   typeof define === 'function' && define.amd ? define(['exports', 'd3-array'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Tidy = {}, global.d3));
-}(this, (function (exports, d3Array) { 'use strict';
+})(this, (function (exports, d3Array) { 'use strict';
 
   function tidy(items, ...fns) {
     if (typeof items === "function") {
@@ -25,8 +25,7 @@
   function when(predicate, fns) {
     const _when = (items) => {
       if (typeof predicate === "function") {
-        if (!predicate(items))
-          return items;
+        if (!predicate(items)) return items;
       } else if (!predicate) {
         return items;
       }
@@ -49,13 +48,13 @@
     const _distinct = (items) => {
       keys = singleOrArray(keys);
       if (!keys.length) {
-        const set = new Set();
+        const set = /* @__PURE__ */ new Set();
         for (const item of items) {
           set.add(item);
         }
         return Array.from(set);
       }
-      const rootMap = new Map();
+      const rootMap = /* @__PURE__ */ new Map();
       const distinctItems = [];
       const lastKey = keys[keys.length - 1];
       for (const item of items) {
@@ -72,7 +71,7 @@
             break;
           }
           if (!map.has(mapItemKey)) {
-            map.set(mapItemKey, new Map());
+            map.set(mapItemKey, /* @__PURE__ */ new Map());
           }
           map = map.get(mapItemKey);
         }
@@ -84,12 +83,16 @@
 
   function arrange(comparators) {
     const _arrange = (items) => {
-      const comparatorFns = singleOrArray(comparators).map((comp) => typeof comp === "function" ? comp.length === 1 ? asc(comp) : comp : asc(comp));
+      const comparatorFns = singleOrArray(comparators).map(
+        (comp) => typeof comp === "function" ? (
+          // length === 1 means it is an accessor (1 argument). convert to comparator via asc
+          comp.length === 1 ? asc(comp) : comp
+        ) : asc(comp)
+      );
       return items.slice().sort((a, b) => {
         for (const comparator of comparatorFns) {
           const result = comparator(a, b);
-          if (result)
-            return result;
+          if (result) return result;
         }
         return 0;
       });
@@ -109,9 +112,9 @@
     };
   }
   function fixedOrder(key, order, options) {
-    let {position = "start"} = options != null ? options : {};
+    let { position = "start" } = options != null ? options : {};
     const positionFactor = position === "end" ? -1 : 1;
-    const indexMap = new Map();
+    const indexMap = /* @__PURE__ */ new Map();
     for (let i = 0; i < order.length; ++i) {
       indexMap.set(order[i], i);
     }
@@ -162,9 +165,10 @@
         summarized[key] = summarizeSpec[key](items);
       }
       if (options.rest && items.length) {
+        const keysSet = new Set(keys);
         const objectKeys = Object.keys(items[0]);
         for (const objKey of objectKeys) {
-          if (keys.includes(objKey)) {
+          if (keysSet.has(objKey)) {
             continue;
           }
           summarized[objKey] = options.rest(objKey)(items);
@@ -175,8 +179,7 @@
     return _summarize;
   }
   function _summarizeHelper(items, summaryFn, predicateFn, keys) {
-    if (!items.length)
-      return [];
+    if (!items.length) return [];
     const summarized = {};
     let keysArr;
     if (keys == null) {
@@ -198,7 +201,9 @@
           continue;
         }
       }
-      summarized[key] = summaryFn(key)(items);
+      summarized[key] = summaryFn(key)(
+        items
+      );
     }
     return [summarized];
   }
@@ -217,7 +222,7 @@
 
   function mutate(mutateSpec) {
     const _mutate = (items) => {
-      const mutatedItems = items.map((d) => ({...d}));
+      const mutatedItems = items.map((d) => ({ ...d }));
       let i = 0;
       for (const mutatedItem of mutatedItems) {
         for (const key in mutateSpec) {
@@ -265,36 +270,37 @@
     return _totalAt;
   }
 
-  function assignGroupKeys(d, keys) {
-    if (d == null || typeof d !== "object" || Array.isArray(d))
-      return d;
-    const keysObj = Object.fromEntries(keys.filter((key) => typeof key[0] !== "function" && key[0] != null));
+  function assignGroupKeys(d, keys, filteredKeys) {
+    if (d == null || typeof d !== "object" || Array.isArray(d)) return d;
+    const validKeys = filteredKeys != null ? filteredKeys : keys.filter((key) => typeof key[0] !== "function" && key[0] != null);
+    const keysObj = Object.fromEntries(validKeys);
     return Object.assign(keysObj, d);
   }
 
   function groupTraversal(grouped, outputGrouped, keys, addSubgroup, addLeaves, level = 0) {
     for (const [key, value] of grouped.entries()) {
-      const keysHere = [...keys, key];
+      keys.push(key);
       if (value instanceof Map) {
-        const subgroup = addSubgroup(outputGrouped, keysHere, level);
-        groupTraversal(value, subgroup, keysHere, addSubgroup, addLeaves, level + 1);
+        const subgroup = addSubgroup(outputGrouped, keys, level);
+        groupTraversal(value, subgroup, keys, addSubgroup, addLeaves, level + 1);
       } else {
-        addLeaves(outputGrouped, keysHere, value, level);
+        addLeaves(outputGrouped, keys, value, level);
       }
+      keys.pop();
     }
     return outputGrouped;
   }
 
   function groupMap(grouped, groupFn, keyFn = (keys) => keys[keys.length - 1]) {
     function addSubgroup(parentGrouped, keys) {
-      const subgroup = new Map();
+      const subgroup = /* @__PURE__ */ new Map();
       parentGrouped.set(keyFn(keys), subgroup);
       return subgroup;
     }
     function addLeaves(parentGrouped, keys, values) {
       parentGrouped.set(keyFn(keys), groupFn(values, keys));
     }
-    const outputGrouped = new Map();
+    const outputGrouped = /* @__PURE__ */ new Map();
     groupTraversal(grouped, outputGrouped, [], addSubgroup, addLeaves);
     return outputGrouped;
   }
@@ -312,9 +318,13 @@
     } else if (arguments.length === 2 && fns != null && !Array.isArray(fns)) {
       options = fns;
     }
-    const _groupBy = (items) => {
+    const _groupBy = ((items) => {
       const grouped = makeGrouped(items, groupKeys);
-      const results = runFlow(grouped, fns, options == null ? void 0 : options.addGroupKeys);
+      const results = runFlow(
+        grouped,
+        fns,
+        options == null ? void 0 : options.addGroupKeys
+      );
       if (options == null ? void 0 : options.export) {
         switch (options.export) {
           case "grouped":
@@ -338,29 +348,33 @@
       }
       const ungrouped = ungroup(results, options == null ? void 0 : options.addGroupKeys);
       return ungrouped;
-    };
+    });
     return _groupBy;
   }
-  groupBy.grouped = (options) => ({...options, export: "grouped"});
-  groupBy.entries = (options) => ({...options, export: "entries"});
-  groupBy.entriesObject = (options) => ({...options, export: "entries-object"});
-  groupBy.object = (options) => ({...options, export: "object"});
-  groupBy.map = (options) => ({...options, export: "map"});
-  groupBy.keys = (options) => ({...options, export: "keys"});
-  groupBy.values = (options) => ({...options, export: "values"});
-  groupBy.levels = (options) => ({...options, export: "levels"});
+  groupBy.grouped = (options) => ({ ...options, export: "grouped" });
+  groupBy.entries = (options) => ({ ...options, export: "entries" });
+  groupBy.entriesObject = (options) => ({ ...options, export: "entries-object" });
+  groupBy.object = (options) => ({ ...options, export: "object" });
+  groupBy.map = (options) => ({ ...options, export: "map" });
+  groupBy.keys = (options) => ({ ...options, export: "keys" });
+  groupBy.values = (options) => ({ ...options, export: "values" });
+  groupBy.levels = (options) => ({ ...options, export: "levels" });
   function runFlow(items, fns, addGroupKeys) {
     let result = items;
-    if (!(fns == null ? void 0 : fns.length))
-      return result;
+    if (!(fns == null ? void 0 : fns.length)) return result;
     for (const fn of fns) {
-      if (!fn)
-        continue;
+      if (!fn) continue;
       result = groupMap(result, (items2, keys) => {
-        const context = {groupKeys: keys};
+        const keysSnapshot = keys.slice();
+        const context = { groupKeys: keysSnapshot };
         let leafItemsMapped = fn(items2, context);
         if (addGroupKeys !== false) {
-          leafItemsMapped = leafItemsMapped.map((item) => assignGroupKeys(item, keys));
+          const filteredKeys = keysSnapshot.filter(
+            (key) => typeof key[0] !== "function" && key[0] != null
+          );
+          leafItemsMapped = leafItemsMapped.map(
+            (item) => assignGroupKeys(item, keysSnapshot, filteredKeys)
+          );
         }
         return leafItemsMapped;
       });
@@ -368,9 +382,9 @@
     return result;
   }
   function makeGrouped(items, groupKeys) {
-    const groupKeyFns = singleOrArray(groupKeys).map((key, i) => {
+    const groupKeyFns = singleOrArray(groupKeys).map((key) => {
       const keyFn = typeof key === "function" ? key : (d) => d[key];
-      const keyCache = new Map();
+      const keyCache = /* @__PURE__ */ new Map();
       return (d) => {
         const keyValue = keyFn(d);
         const keyValueOf = isObject(keyValue) ? keyValue.valueOf() : keyValue;
@@ -390,7 +404,10 @@
     groupTraversal(grouped, items, [], identity, (root, keys, values) => {
       let valuesToAdd = values;
       if (addGroupKeys !== false) {
-        valuesToAdd = values.map((d) => assignGroupKeys(d, keys));
+        const filteredKeys = keys.filter(
+          (key) => typeof key[0] !== "function" && key[0] != null
+        );
+        valuesToAdd = values.map((d) => assignGroupKeys(d, keys, filteredKeys));
       }
       root.push(...valuesToAdd);
     });
@@ -411,23 +428,30 @@
       compositeKey = (_a = options.compositeKey) != null ? _a : defaultCompositeKey;
     }
     const groupFn = (values, keys) => {
-      return single ? mapLeaf(addGroupKeys === false ? values[0] : assignGroupKeys(values[0], keys)) : mapLeaves(values.map((d) => mapLeaf(addGroupKeys === false ? d : assignGroupKeys(d, keys))));
+      return single ? mapLeaf(
+        addGroupKeys === false ? values[0] : assignGroupKeys(values[0], keys)
+      ) : mapLeaves(
+        values.map(
+          (d) => mapLeaf(addGroupKeys === false ? d : assignGroupKeys(d, keys))
+        )
+      );
     };
     const keyFn = flat ? (keys) => compositeKey(keys.map((d) => d[1])) : (keys) => keys[keys.length - 1][1];
-    return {groupFn, keyFn};
+    return { groupFn, keyFn };
   }
   function exportLevels(grouped, options) {
-    const {groupFn, keyFn} = processFromGroupsOptions(options);
-    let {mapEntry = identity} = options;
-    const {levels = ["entries"]} = options;
+    const { groupFn, keyFn } = processFromGroupsOptions(options);
+    let { mapEntry = identity } = options;
+    const { levels = ["entries"] } = options;
     const levelSpecs = [];
     for (const levelOption of levels) {
       switch (levelOption) {
+        // entries / entries-object -----------------------------------------
         case "entries":
         case "entries-object":
         case "entries-obj":
         case "entriesObject": {
-          const levelMapEntry = (levelOption === "entries-object" || levelOption === "entries-obj" || levelOption === "entriesObject") && options.mapEntry == null ? ([key, values]) => ({key, values}) : mapEntry;
+          const levelMapEntry = (levelOption === "entries-object" || levelOption === "entries-obj" || levelOption === "entriesObject") && options.mapEntry == null ? ([key, values]) => ({ key, values }) : mapEntry;
           levelSpecs.push({
             id: "entries",
             createEmptySubgroup: () => [],
@@ -440,10 +464,11 @@
           });
           break;
         }
+        // map -------------------------------------------------------------
         case "map":
           levelSpecs.push({
             id: "map",
-            createEmptySubgroup: () => new Map(),
+            createEmptySubgroup: () => /* @__PURE__ */ new Map(),
             addSubgroup: (parentGrouped, newSubgroup, key) => {
               parentGrouped.set(key, newSubgroup);
             },
@@ -452,6 +477,7 @@
             }
           });
           break;
+        // object ----------------------------------------------------------
         case "object":
           levelSpecs.push({
             id: "object",
@@ -464,6 +490,7 @@
             }
           });
           break;
+        // keys ------------------------------------------------------------
         case "keys":
           levelSpecs.push({
             id: "keys",
@@ -476,6 +503,7 @@
             }
           });
           break;
+        // values ----------------------------------------------------------
         case "values":
           levelSpecs.push({
             id: "values",
@@ -488,6 +516,7 @@
             }
           });
           break;
+        // custom ----------------------------------------------------------
         default: {
           if (typeof levelOption === "object") {
             levelSpecs.push(levelOption);
@@ -509,7 +538,12 @@
     const addLeaf = (parentGrouped, keys, values, level) => {
       var _a;
       const levelSpec = (_a = levelSpecs[level]) != null ? _a : levelSpecs[levelSpecs.length - 1];
-      levelSpec.addLeaf(parentGrouped, keyFn(keys), groupFn(values, keys), level);
+      levelSpec.addLeaf(
+        parentGrouped,
+        keyFn(keys),
+        groupFn(values, keys),
+        level
+      );
     };
     const initialOutputObject = levelSpecs[0].createEmptySubgroup();
     return groupTraversal(grouped, initialOutputObject, [], addSubgroup, addLeaf);
@@ -535,8 +569,10 @@
 
   function tally(options) {
     const _tally = (items) => {
-      const {name = "n", wt} = options != null ? options : {};
-      const summarized = summarize({[name]: wt == null ? n() : sum(wt)})(items);
+      const { name = "n", wt } = options != null ? options : {};
+      const summarized = summarize({ [name]: wt == null ? n() : sum(wt) })(
+        items
+      );
       return summarized;
     };
     return _tally;
@@ -545,8 +581,12 @@
   function count(groupKeys, options) {
     const _count = (items) => {
       options = options != null ? options : {};
-      const {name = "n", sort} = options;
-      const results = tidy(items, groupBy(groupKeys, [tally(options)]), sort ? arrange(desc(name)) : identity);
+      const { name = "n", sort } = options;
+      const results = tidy(
+        items,
+        groupBy(groupKeys, [tally(options)]),
+        sort ? arrange(desc(name)) : identity
+      );
       return results;
     };
     return _count;
@@ -584,10 +624,9 @@
   }
   function sliceSample(n, options) {
     options = options != null ? options : {};
-    const {replace} = options;
+    const { replace } = options;
     const _sliceSample = (items) => {
-      if (!items.length)
-        return items.slice();
+      if (!items.length) return items.slice();
       if (replace) {
         const sliced = [];
         for (let i = 0; i < n; ++i) {
@@ -601,8 +640,7 @@
   }
 
   function autodetectByMap(itemsA, itemsB) {
-    if (itemsA.length === 0 || itemsB.length === 0)
-      return {};
+    if (itemsA.length === 0 || itemsB.length === 0) return {};
     const keysA = Object.keys(itemsA[0]);
     const keysB = Object.keys(itemsB[0]);
     const byMap = {};
@@ -623,23 +661,49 @@
     } else if (typeof by === "object") {
       return by;
     }
-    return {[by]: by};
-  }
-  function isMatch(d, j, byMap) {
-    for (const jKey in byMap) {
-      const dKey = byMap[jKey];
-      if (d[dKey] !== j[jKey]) {
-        return false;
+    return { [by]: by };
+  }
+  const KEY_DELIMITER = "\0";
+  const NULL_SENTINEL = "
N";
+  const UNDEF_SENTINEL = "
U";
+  function serializeValue(v) {
+    if (v === null) return NULL_SENTINEL;
+    if (v === void 0) return UNDEF_SENTINEL;
+    return String(v);
+  }
+  function computeKey(row, keys) {
+    if (keys.length === 1) return serializeValue(row[keys[0]]);
+    let key = "";
+    for (let i = 0; i < keys.length; i++) {
+      if (i > 0) key += KEY_DELIMITER;
+      key += serializeValue(row[keys[i]]);
+    }
+    return key;
+  }
+  function buildJoinIndex(itemsToJoin, joinKeys) {
+    const index = /* @__PURE__ */ new Map();
+    for (const j of itemsToJoin) {
+      const key = computeKey(j, joinKeys);
+      let bucket = index.get(key);
+      if (bucket === void 0) {
+        bucket = [];
+        index.set(key, bucket);
       }
+      bucket.push(j);
     }
-    return true;
+    return index;
   }
   function innerJoin(itemsToJoin, options) {
     const _innerJoin = (items) => {
       const byMap = (options == null ? void 0 : options.by) == null ? autodetectByMap(items, itemsToJoin) : makeByMap(options.by);
+      const joinKeys = Object.keys(byMap);
+      const itemKeys = joinKeys.map((jKey) => byMap[jKey]);
+      const index = buildJoinIndex(itemsToJoin, joinKeys);
       const joined = items.flatMap((d) => {
-        const matches = itemsToJoin.filter((j) => isMatch(d, j, byMap));
-        return matches.map((j) => ({...d, ...j}));
+        const key = computeKey(d, itemKeys);
+        const matches = index.get(key);
+        if (matches === void 0) return [];
+        return matches.map((j) => ({ ...d, ...j }));
       });
       return joined;
     };
@@ -648,17 +712,22 @@
 
   function leftJoin(itemsToJoin, options) {
     const _leftJoin = (items) => {
-      if (!itemsToJoin.length)
-        return items;
+      if (!itemsToJoin.length) return items;
       const byMap = (options == null ? void 0 : options.by) == null ? autodetectByMap(items, itemsToJoin) : makeByMap(options.by);
+      const joinKeys = Object.keys(byMap);
+      const itemKeys = joinKeys.map((jKey) => byMap[jKey]);
+      const index = buildJoinIndex(itemsToJoin, joinKeys);
       const joinObjectKeys = Object.keys(itemsToJoin[0]);
       const joined = items.flatMap((d) => {
-        const matches = itemsToJoin.filter((j) => isMatch(d, j, byMap));
-        if (matches.length) {
-          return matches.map((j) => ({...d, ...j}));
+        const key = computeKey(d, itemKeys);
+        const matches = index.get(key);
+        if (matches !== void 0) {
+          return matches.map((j) => ({ ...d, ...j }));
         }
-        const undefinedFill = Object.fromEntries(joinObjectKeys.filter((key) => d[key] == null).map((key) => [key, void 0]));
-        return {...d, ...undefinedFill};
+        const undefinedFill = Object.fromEntries(
+          joinObjectKeys.filter((key2) => d[key2] == null).map((key2) => [key2, void 0])
+        );
+        return { ...d, ...undefinedFill };
       });
       return joined;
     };
@@ -667,32 +736,35 @@
 
   function fullJoin(itemsToJoin, options) {
     const _fullJoin = (items) => {
-      if (!itemsToJoin.length)
-        return items;
-      if (!items.length)
-        return itemsToJoin;
+      if (!itemsToJoin.length) return items;
+      if (!items.length) return itemsToJoin;
       const byMap = (options == null ? void 0 : options.by) == null ? autodetectByMap(items, itemsToJoin) : makeByMap(options.by);
-      const matchMap = new Map();
+      const joinKeys = Object.keys(byMap);
+      const itemKeys = joinKeys.map((jKey) => byMap[jKey]);
+      const index = buildJoinIndex(itemsToJoin, joinKeys);
+      const matchedItems = /* @__PURE__ */ new Set();
       const joinObjectKeys = Object.keys(itemsToJoin[0]);
       const joined = items.flatMap((d) => {
-        const matches = itemsToJoin.filter((j) => {
-          const matched = isMatch(d, j, byMap);
-          if (matched) {
-            matchMap.set(j, true);
+        const key = computeKey(d, itemKeys);
+        const matches = index.get(key);
+        if (matches !== void 0) {
+          for (const j of matches) {
+            matchedItems.add(j);
           }
-          return matched;
-        });
-        if (matches.length) {
-          return matches.map((j) => ({...d, ...j}));
+          return matches.map((j) => ({ ...d, ...j }));
         }
-        const undefinedFill = Object.fromEntries(joinObjectKeys.filter((key) => d[key] == null).map((key) => [key, void 0]));
-        return {...d, ...undefinedFill};
+        const undefinedFill = Object.fromEntries(
+          joinObjectKeys.filter((key2) => d[key2] == null).map((key2) => [key2, void 0])
+        );
+        return { ...d, ...undefinedFill };
       });
-      if (matchMap.size < itemsToJoin.length) {
-        const leftEmptyObject = Object.fromEntries(Object.keys(items[0]).map((key) => [key, void 0]));
+      if (matchedItems.size < itemsToJoin.length) {
+        const leftEmptyObject = Object.fromEntries(
+          Object.keys(items[0]).map((key) => [key, void 0])
+        );
         for (const item of itemsToJoin) {
-          if (!matchMap.has(item)) {
-            joined.push({...leftEmptyObject, ...item});
+          if (!matchedItems.has(item)) {
+            joined.push({ ...leftEmptyObject, ...item });
           }
         }
       }
@@ -703,7 +775,7 @@
 
   function mutateWithSummary(mutateSpec) {
     const _mutate = (items) => {
-      const mutatedItems = items.map((d) => ({...d}));
+      const mutatedItems = items.map((d) => ({ ...d }));
       for (const key in mutateSpec) {
         const mutateSpecValue = mutateSpec[key];
         const mutatedResult = typeof mutateSpecValue === "function" ? mutateSpecValue(mutatedItems) : mutateSpecValue;
@@ -719,8 +791,7 @@
   }
 
   function keysFromItems(items) {
-    if (items.length < 1)
-      return [];
+    if (items.length < 1) return [];
     const keys = Object.keys(items[0]);
     return keys;
   }
@@ -756,16 +827,16 @@
         negationMap[key] = false;
         continue;
       }
-      keysWithoutNegations.unshift(key);
+      keysWithoutNegations.push(key);
     }
+    keysWithoutNegations.reverse();
     processedSelectKeys = Array.from(new Set(keysWithoutNegations));
     return processedSelectKeys;
   }
   function select(selectKeys) {
     const _select = (items) => {
       let processedSelectKeys = processSelectors(items, selectKeys);
-      if (!processedSelectKeys.length)
-        return items;
+      if (!processedSelectKeys.length) return items;
       return items.map((d) => {
         const mapped = {};
         for (const key of processedSelectKeys) {
@@ -808,9 +879,10 @@
       const namesFromKeys = Array.isArray(namesFrom) ? namesFrom : [namesFrom];
       const valuesFromKeys = Array.isArray(valuesFrom) ? valuesFrom : [valuesFrom];
       const wider = [];
-      if (!items.length)
-        return wider;
-      const idColumns = Object.keys(items[0]).filter((key) => !namesFromKeys.includes(key) && !valuesFromKeys.includes(key));
+      if (!items.length) return wider;
+      const idColumns = Object.keys(items[0]).filter(
+        (key) => !namesFromKeys.includes(key) && !valuesFromKeys.includes(key)
+      );
       const nameValuesMap = {};
       for (const item of items) {
         for (const nameKey of namesFromKeys) {
@@ -825,20 +897,19 @@
         nameValuesLists.push(Object.keys(nameValuesMap[nameKey]));
       }
       const baseWideObj = {};
-      const combos = makeCombinations(namesSep, nameValuesLists);
+      const combos = makeCombinations$1(namesSep, nameValuesLists);
       for (const nameKey of combos) {
         if (valuesFromKeys.length === 1) {
           baseWideObj[nameKey] = valuesFillMap != null ? valuesFillMap[valuesFromKeys[0]] : valuesFill;
           continue;
         }
         for (const valueKey of valuesFromKeys) {
-          baseWideObj[`${valueKey}${namesSep}${nameKey}`] = valuesFillMap != null ? valuesFillMap[valueKey] : valuesFill;
+          baseWideObj[`${String(valueKey)}${namesSep}${nameKey}`] = valuesFillMap != null ? valuesFillMap[valueKey] : valuesFill;
         }
       }
       function widenItems(items2) {
-        if (!items2.length)
-          return [];
-        const wide = {...baseWideObj};
+        if (!items2.length) return [];
+        const wide = { ...baseWideObj };
         for (const idKey of idColumns) {
           wide[idKey] = items2[0][idKey];
         }
@@ -849,7 +920,7 @@
             continue;
           }
           for (const valueKey of valuesFromKeys) {
-            wide[`${valueKey}${namesSep}${nameKey}`] = item[valueKey];
+            wide[`${String(valueKey)}${namesSep}${nameKey}`] = item[valueKey];
           }
         }
         return [wide];
@@ -862,27 +933,32 @@
     };
     return _pivotWider;
   }
-  function makeCombinations(separator = "_", arrays) {
-    function combine(accum, prefix, remainingArrays) {
-      if (!remainingArrays.length && prefix != null) {
-        accum.push(prefix);
-        return;
-      }
-      const array = remainingArrays[0];
-      const newRemainingArrays = remainingArrays.slice(1);
-      for (const item of array) {
-        combine(accum, prefix == null ? item : `${prefix}${separator}${item}`, newRemainingArrays);
+  const PIVOT_WARN_THRESHOLD = 1e5;
+  function makeCombinations$1(separator = "_", arrays) {
+    if (!arrays.length) return [];
+    const totalSize = arrays.reduce((acc, v) => acc * v.length, 1);
+    if (totalSize > PIVOT_WARN_THRESHOLD) {
+      console.warn(
+        `tidy pivotWider: generating ${totalSize.toLocaleString()} column combinations. This may be slow or use excessive memory.`
+      );
+    }
+    let result = [null];
+    for (const array of arrays) {
+      const next = [];
+      for (const prefix of result) {
+        for (const item of array) {
+          next.push(prefix == null ? item : `${prefix}${separator}${item}`);
+        }
       }
+      result = next;
     }
-    const result = [];
-    combine(result, null, arrays);
     return result;
   }
 
   function pivotLonger(options) {
     const _pivotLonger = (items) => {
       var _a;
-      const {namesTo, valuesTo, namesSep = "_"} = options;
+      const { namesTo, valuesTo, namesSep = "_" } = options;
       const cols = (_a = options.cols) != null ? _a : [];
       const colsKeys = processSelectors(items, cols);
       const namesToKeys = Array.isArray(namesTo) ? namesTo : [namesTo];
@@ -890,18 +966,42 @@
       const hasMultipleNamesTo = namesToKeys.length > 1;
       const hasMultipleValuesTo = valuesToKeys.length > 1;
       const longer = [];
+      if (!items.length) return longer;
+      const colsKeysSet = new Set(colsKeys);
+      const remainingKeys = Object.keys(items[0]).filter(
+        (key) => !colsKeysSet.has(key)
+      );
+      const nameValueKeysWithoutValuePrefix = hasMultipleValuesTo ? Array.from(
+        new Set(
+          colsKeys.map(
+            (key) => key.substring(key.indexOf(namesSep) + 1)
+          )
+        )
+      ) : colsKeys;
+      const nameValuePartsMap = hasMultipleNamesTo ? new Map(
+        nameValueKeysWithoutValuePrefix.map((nv) => [
+          nv,
+          nv.split(namesSep)
+        ])
+      ) : null;
+      const itemKeysMap = hasMultipleValuesTo ? new Map(
+        nameValueKeysWithoutValuePrefix.map((nv) => [
+          nv,
+          valuesToKeys.map((vk) => `${String(vk)}${namesSep}${String(nv)}`)
+        ])
+      ) : null;
       for (const item of items) {
-        const remainingKeys = Object.keys(item).filter((key) => !colsKeys.includes(key));
         const baseObj = {};
         for (const key of remainingKeys) {
           baseObj[key] = item[key];
         }
-        const nameValueKeysWithoutValuePrefix = hasMultipleValuesTo ? Array.from(new Set(colsKeys.map((key) => key.substring(key.indexOf(namesSep) + 1)))) : colsKeys;
         for (const nameValue of nameValueKeysWithoutValuePrefix) {
-          const entryObj = {...baseObj};
-          for (const valueKey of valuesToKeys) {
-            const itemKey = hasMultipleValuesTo ? `${valueKey}${namesSep}${nameValue}` : nameValue;
-            const nameValueParts = hasMultipleNamesTo ? nameValue.split(namesSep) : [nameValue];
+          const entryObj = { ...baseObj };
+          const nameValueParts = nameValuePartsMap ? nameValuePartsMap.get(nameValue) : [nameValue];
+          const itemKeys = itemKeysMap ? itemKeysMap.get(nameValue) : null;
+          for (let vi = 0; vi < valuesToKeys.length; vi++) {
+            const valueKey = valuesToKeys[vi];
+            const itemKey = itemKeys ? itemKeys[vi] : nameValue;
             let i = 0;
             for (const nameKey of namesToKeys) {
               const nameValuePart = nameValueParts[i++];
@@ -931,26 +1031,31 @@
         } else {
           values = Array.from(new Set(items.map((d) => d[key])));
         }
-        vectors.push(values.map((value) => ({[key]: value})));
+        vectors.push(values.map((value) => ({ [key]: value })));
       }
-      return makeCombinations$1(vectors);
+      return makeCombinations(vectors);
     };
     return _expand;
   }
-  function makeCombinations$1(vectors) {
-    function combine(accum, baseObj, remainingVectors) {
-      if (!remainingVectors.length && baseObj != null) {
-        accum.push(baseObj);
-        return;
-      }
-      const vector = remainingVectors[0];
-      const newRemainingArrays = remainingVectors.slice(1);
-      for (const item of vector) {
-        combine(accum, {...baseObj, ...item}, newRemainingArrays);
+  const EXPAND_WARN_THRESHOLD = 1e5;
+  function makeCombinations(vectors) {
+    if (!vectors.length) return [];
+    const totalSize = vectors.reduce((acc, v) => acc * v.length, 1);
+    if (totalSize > EXPAND_WARN_THRESHOLD) {
+      console.warn(
+        `tidy expand: generating ${totalSize.toLocaleString()} combinations. This may be slow or use excessive memory.`
+      );
+    }
+    let result = [null];
+    for (const vector of vectors) {
+      const next = [];
+      for (const baseObj of result) {
+        for (const item of vector) {
+          next.push(baseObj == null ? item : { ...baseObj, ...item });
+        }
       }
+      result = next;
     }
-    const result = [];
-    combine(result, null, vectors);
     return result;
   }
   function makeKeyMap(keys) {
@@ -963,7 +1068,7 @@
     } else if (typeof keys === "object") {
       return keys;
     }
-    return {[keys]: keys};
+    return { [keys]: keys };
   }
 
   function vectorSeq(values, period = 1) {
@@ -1020,7 +1125,11 @@
       granularity = granularity != null ? granularity : "day";
       period = period != null ? period : 1;
       const keyFn = typeof key === "function" ? key : (d) => d[key];
-      return vectorSeqDate(items.map((d) => new Date(keyFn(d))), granularity, period).map((date) => date.toISOString());
+      return vectorSeqDate(
+        items.map((d) => new Date(keyFn(d))),
+        granularity,
+        period
+      ).map((date) => date.toISOString());
     };
   }
 
@@ -1028,7 +1137,7 @@
     const _replaceNully = (items) => {
       const replacedItems = [];
       for (const d of items) {
-        const obj = {...d};
+        const obj = { ...d };
         for (const key in replaceSpec) {
           if (obj[key] == null) {
             obj[key] = replaceSpec[key];
@@ -1055,11 +1164,18 @@
       const keysArray = singleOrArray(keys);
       const replaceMap = {};
       return items.map((d) => {
-        const obj = {...d};
+        let needsCopy = false;
         for (const key of keysArray) {
-          if (obj[key] != null) {
-            replaceMap[key] = obj[key];
+          if (d[key] != null) {
+            replaceMap[key] = d[key];
           } else if (replaceMap[key] != null) {
+            needsCopy = true;
+          }
+        }
+        if (!needsCopy) return d;
+        const obj = { ...d };
+        for (const key of keysArray) {
+          if (obj[key] == null && replaceMap[key] != null) {
             obj[key] = replaceMap[key];
           }
         }
@@ -1081,19 +1197,21 @@
         }
       }
       options = options != null ? options : {};
-      const {limit = 10, output = "table"} = options;
+      const { limit = 10, output = "table" } = options;
       const dashString = "--------------------------------------------------------------------------------";
       let numDashes = dashString.length;
       const prefixedLabel = prefix + "]" + (label == null ? "" : " " + label);
       numDashes = Math.max(0, numDashes - (prefixedLabel.length + 2));
       console.log(`${prefixedLabel} ${dashString.substring(0, numDashes)}`);
-      console[output](limit == null || limit >= items.length ? items : items.slice(0, limit));
+      console[output](
+        limit == null || limit >= items.length ? items : items.slice(0, limit)
+      );
       return items;
     };
     return _debug;
   }
 
-  function rate(numerator, denominator, allowDivideByZero) {
+  function rate$1(numerator, denominator, allowDivideByZero) {
     return numerator == null || denominator == null ? void 0 : denominator === 0 && numerator === 0 ? 0 : !allowDivideByZero && denominator === 0 ? void 0 : numerator / denominator;
   }
   function subtract(a, b, nullyZero) {
@@ -1105,41 +1223,48 @@
 
   var math = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    rate: rate,
-    subtract: subtract,
-    add: add
+    add: add,
+    rate: rate$1,
+    subtract: subtract
   });
 
-  function rate$1(numerator, denominator, options) {
+  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 : {};
+    const { predicate, allowDivideByZero } = options != null ? options : {};
     return predicate == null ? (d, index, array) => {
       const denom = denominatorFn(d, index, array);
       const numer = numeratorFn(d, index, array);
-      return rate(numer, denom, allowDivideByZero);
+      return rate$1(numer, denom, allowDivideByZero);
     } : (d, index, array) => {
-      if (!predicate(d, index, array))
-        return void 0;
+      if (!predicate(d, index, array)) return void 0;
       const denom = denominatorFn(d, index, array);
       const numer = numeratorFn(d, index, array);
-      return rate(numer, denom, allowDivideByZero);
+      return rate$1(numer, denom, allowDivideByZero);
     };
   }
 
   function fcumsum(items, accessor) {
     let sum = new d3Array.Adder(), i = 0;
-    return Float64Array.from(items, (value) => sum.add(+(accessor(value, i++, items) || 0)));
-  }
-  function mean(items, accessor) {
+    return Float64Array.from(
+      items,
+      // we do not actually need to coerce the Adder to number,
+      // as @Fil demonstrated here: https://github.com/pbeshai/tidy/pull/5
+      // so we can just tell typescript to be quiet.
+      (value) => sum.add(+(accessor(value, i++, items) || 0))
+    );
+  }
+  function mean$1(items, accessor) {
     let n = 0;
+    const sum = new d3Array.Adder();
     for (let i = 0; i < items.length; ++i) {
       const value = accessor(items[i], i, items);
       if (+value === value) {
+        sum.add(+value);
         n += 1;
       }
     }
-    return n ? d3Array.fsum(items, accessor) / n : void 0;
+    return n ? +sum / n : void 0;
   }
 
   function cumsum(key) {
@@ -1148,7 +1273,7 @@
   }
 
   function roll(width, rollFn, options) {
-    const {partial = false, align = "right"} = options != null ? options : {};
+    const { partial = false, align = "right" } = options != null ? options : {};
     const halfWidth = Math.floor(width / 2);
     return (items) => {
       return items.map((_, i) => {
@@ -1165,7 +1290,7 @@
 
   function lag(key, options) {
     const keyFn = typeof key === "function" ? key : (d) => d[key];
-    const {n = 1, default: defaultValue} = options != null ? options : {};
+    const { n = 1, default: defaultValue } = options != null ? options : {};
     return (items) => {
       return items.map((_, i) => {
         const lagItem = items[i - n];
@@ -1176,7 +1301,7 @@
 
   function lead(key, options) {
     const keyFn = typeof key === "function" ? key : (d) => d[key];
-    const {n = 1, default: defaultValue} = options != null ? options : {};
+    const { n = 1, default: defaultValue } = options != null ? options : {};
     return (items) => {
       return items.map((_, i) => {
         const leadItem = items[i + n];
@@ -1203,9 +1328,9 @@
     return (items) => d3Array.max(items, keyFn);
   }
 
-  function mean$1(key) {
+  function mean(key) {
     const keyFn = typeof key === "function" ? key : (d) => d[key];
-    return (items) => mean(items, keyFn);
+    return (items) => mean$1(items, keyFn);
   }
 
   function meanRate(numerator, denominator) {
@@ -1214,7 +1339,7 @@
     return (items) => {
       const numerator2 = d3Array.fsum(items, numeratorFn);
       const denominator2 = d3Array.fsum(items, denominatorFn);
-      return rate(numerator2, denominator2);
+      return rate$1(numerator2, denominator2);
     };
   }
 
@@ -1236,7 +1361,7 @@
   function nDistinct(key, options = {}) {
     const keyFn = typeof key === "function" ? key : (d) => d[key];
     return (items) => {
-      const uniques = new Map();
+      const uniques = /* @__PURE__ */ new Set();
       let count = 0;
       let i = 0;
       for (const item of items) {
@@ -1246,7 +1371,7 @@
             continue;
           }
           count += 1;
-          uniques.set(value, true);
+          uniques.add(value);
         }
       }
       return count;
@@ -1308,7 +1433,7 @@
 
   function negate(selectors) {
     return (items) => {
-      let keySet = new Set();
+      let keySet = /* @__PURE__ */ new Set();
       for (const selector of singleOrArray(selectors)) {
         if (typeof selector === "function") {
           const keys2 = selector(items);
@@ -1319,7 +1444,7 @@
           keySet.add(selector);
         }
       }
-      const keys = Array.from(keySet).map((key) => `-${key}`);
+      const keys = Array.from(keySet).map((key) => `-${String(key)}`);
       return keys;
     };
   }
@@ -1357,7 +1482,7 @@
   exports.map = map;
   exports.matches = matches;
   exports.max = max;
-  exports.mean = mean$1;
+  exports.mean = mean;
   exports.meanRate = meanRate;
   exports.median = median;
   exports.min = min;
@@ -1370,7 +1495,7 @@
   exports.pick = select;
   exports.pivotLonger = pivotLonger;
   exports.pivotWider = pivotWider;
-  exports.rate = rate$1;
+  exports.rate = rate;
   exports.rename = rename;
   exports.replaceNully = replaceNully;
   exports.roll = roll;
@@ -1401,7 +1526,5 @@
   exports.vectorSeqDate = vectorSeqDate;
   exports.when = when;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
+}));
 //# sourceMappingURL=tidy.js.map