@buildcanada/charts 0.3.6 → 0.3.8

package/dist/core-table/CoreTableUtils.js

@@ -0,0 +1,498 @@
+import * as _ from "lodash-es";
+import * as Papa from "papaparse";
+import * as R from "remeda";
+import { sampleFrom, slugifySameCase } from "../utils/index.js";
+import {
+  ColumnTypeNames,
+  EntityCodeColumnDef,
+  EntityIdColumnDef,
+  EntityNameColumnDef,
+  ChartsTableSlugs
+} from "../types/index.js";
+import { ErrorValueTypes } from "./ErrorValues.js";
+const columnStoreToRows = (columnStore) => {
+  const firstCol = Object.values(columnStore)[0];
+  if (!firstCol) return [];
+  const slugs = Object.keys(columnStore);
+  return firstCol.map((val, index) => {
+    const newRow = {};
+    slugs.forEach((slug) => {
+      newRow[slug] = columnStore[slug][index];
+    });
+    return newRow;
+  });
+};
+const truncate = (str, maxLength) => str.length > maxLength ? `${str.substr(0, maxLength - 3)}...` : str;
+const numberOnly = /^-?\d+\.?\d*$/;
+const makeAutoTypeFn = (numericSlugs) => {
+  const slugToType = {};
+  numericSlugs?.forEach((slug) => {
+    slugToType[slug] = "number";
+  });
+  return (object) => {
+    for (const columnSlug in object) {
+      const value = object[columnSlug];
+      const type = slugToType[columnSlug];
+      if (type === "string") {
+        object[columnSlug] = value;
+        continue;
+      }
+      const number = parseFloat(value);
+      if (type === "number") {
+        object[columnSlug] = isNaN(number) ? ErrorValueTypes.NaNButShouldBeNumber : number;
+        continue;
+      }
+      if (isNaN(number) || !numberOnly.test(value)) {
+        object[columnSlug] = value;
+        slugToType[columnSlug] = "string";
+        continue;
+      }
+      object[columnSlug] = number;
+      slugToType[columnSlug] = "number";
+    }
+    return object;
+  };
+};
+const standardizeSlugs = (rows) => {
+  const firstRow = rows[0] ?? {};
+  const colsToRename = Object.keys(firstRow).map((name) => {
+    return {
+      name,
+      slug: slugifySameCase(name)
+    };
+  }).filter((col) => col.name !== col.slug);
+  if (!colsToRename.length) return void 0;
+  rows.forEach((row) => {
+    colsToRename.forEach((col) => {
+      row[col.slug] = row[col.name];
+      delete row[col.name];
+    });
+  });
+  return { rows, defs: colsToRename };
+};
+const guessColumnDefFromSlugAndRow = (slug, sampleValue) => {
+  const valueType = typeof sampleValue;
+  const name = slug;
+  if (slug === "Entity")
+    return {
+      slug,
+      type: ColumnTypeNames.EntityName,
+      name
+    };
+  if (slug === "day")
+    return {
+      slug,
+      type: ColumnTypeNames.Day,
+      name: "Day"
+    };
+  if (slug === "year" || slug === "Year")
+    return {
+      slug,
+      type: ColumnTypeNames.Year,
+      name: "Year"
+    };
+  if (slug === ChartsTableSlugs.entityName) return EntityNameColumnDef;
+  if (slug === ChartsTableSlugs.entityCode) return EntityCodeColumnDef;
+  if (slug === ChartsTableSlugs.entityId) return EntityIdColumnDef;
+  if (slug === "date")
+    return {
+      slug,
+      type: ColumnTypeNames.Date,
+      name: "Date"
+    };
+  if (valueType === "number")
+    return {
+      slug,
+      type: ColumnTypeNames.Numeric,
+      name
+    };
+  if (valueType === "string") {
+    if (String(sampleValue).match(/^\d+$/))
+      return {
+        slug,
+        type: ColumnTypeNames.Numeric,
+        name
+      };
+  }
+  return { slug, type: ColumnTypeNames.String, name };
+};
+const makeRowFromColumnStore = (rowIndex, columnStore) => {
+  const row = {};
+  Object.entries(columnStore).forEach(([slug, col]) => {
+    if (col.length <= rowIndex) row[slug] = void 0;
+    else row[slug] = col[rowIndex];
+  });
+  return row;
+};
+function linearInterpolation(valuesSortedByTimeAsc, timesAsc, validIndices, context, start = 0, end = valuesSortedByTimeAsc.length) {
+  if (!valuesSortedByTimeAsc.length) return;
+  const startIndexInValidIndices = R.sortedIndex(validIndices, start);
+  const endIndexInValidIndices = R.sortedIndex(validIndices, end);
+  const distBetweenStartAndEnd = endIndexInValidIndices - startIndexInValidIndices;
+  if (distBetweenStartAndEnd === 0) {
+    for (let index = start; index < end; index++) {
+      valuesSortedByTimeAsc[index] = ErrorValueTypes.NoValueForInterpolation;
+    }
+    return;
+  } else if (distBetweenStartAndEnd === end - start) {
+    return;
+  }
+  let currentValidIndexPointer = startIndexInValidIndices;
+  let prevNonBlankIndex = void 0;
+  let nextNonBlankIndex = void 0;
+  for (let index = start; index < end; index++) {
+    if (nextNonBlankIndex !== -1 && (nextNonBlankIndex === void 0 || nextNonBlankIndex <= index)) {
+      nextNonBlankIndex = validIndices[currentValidIndexPointer] ?? -1;
+      if (nextNonBlankIndex >= end) {
+        nextNonBlankIndex = -1;
+      }
+    }
+    if (index === nextNonBlankIndex) {
+      prevNonBlankIndex = index;
+      currentValidIndexPointer++;
+      continue;
+    }
+    const timeOfCurrent = timesAsc[index];
+    const timeOfPrevIndex = prevNonBlankIndex !== void 0 ? timesAsc[prevNonBlankIndex] ?? -Infinity : -Infinity;
+    const timeOfNextIndex = timesAsc[nextNonBlankIndex] ?? Infinity;
+    const prevValue = prevNonBlankIndex !== void 0 ? valuesSortedByTimeAsc[prevNonBlankIndex] : void 0;
+    const nextValue = valuesSortedByTimeAsc[nextNonBlankIndex];
+    let value;
+    if (typeof prevValue === "number" && typeof nextValue === "number") {
+      const distLeft = timeOfCurrent - timeOfPrevIndex;
+      const distRight = timeOfNextIndex - timeOfCurrent;
+      value = (prevValue * distRight + nextValue * distLeft) / (distLeft + distRight);
+    } else if (typeof prevValue === "number" && context.extrapolateAtEnd)
+      value = prevValue;
+    else if (typeof nextValue === "number" && context.extrapolateAtStart)
+      value = nextValue;
+    else value = ErrorValueTypes.NoValueForInterpolation;
+    valuesSortedByTimeAsc[index] = value;
+  }
+}
+function toleranceInterpolation(valuesSortedByTimeAsc, timesAsc, validIndices, context, start = 0, end = valuesSortedByTimeAsc.length) {
+  if (!valuesSortedByTimeAsc.length) return;
+  const startIndexInValidIndices = R.sortedIndex(validIndices, start);
+  const endIndexInValidIndices = R.sortedIndex(validIndices, end);
+  const distBetweenStartAndEnd = endIndexInValidIndices - startIndexInValidIndices;
+  if (distBetweenStartAndEnd === 0) {
+    for (let index = start; index < end; index++) {
+      valuesSortedByTimeAsc[index] = ErrorValueTypes.NoValueWithinTolerance;
+    }
+    return;
+  } else if (distBetweenStartAndEnd === end - start) {
+    return;
+  } else if (distBetweenStartAndEnd === 1) {
+    const onlyValidIndex = validIndices[startIndexInValidIndices];
+    const timeOfOnlyValid = timesAsc[onlyValidIndex];
+    for (let index = start; index < end; index++) {
+      if (index === onlyValidIndex) continue;
+      const timeOfCurrent = timesAsc[index];
+      const timeDiff = timeOfOnlyValid - timeOfCurrent;
+      if (timeDiff < 0 && Math.abs(timeDiff) <= context.timeToleranceBackwards || timeDiff > 0 && Math.abs(timeDiff) <= context.timeToleranceForwards) {
+        valuesSortedByTimeAsc[index] = valuesSortedByTimeAsc[onlyValidIndex];
+        timesAsc[index] = timeOfOnlyValid;
+      } else {
+        valuesSortedByTimeAsc[index] = ErrorValueTypes.NoValueWithinTolerance;
+      }
+    }
+    return;
+  }
+  let currentValidIndexPointer = startIndexInValidIndices;
+  let prevNonBlankIndex = void 0;
+  let nextNonBlankIndex = void 0;
+  for (let index = start; index < end; index++) {
+    if (nextNonBlankIndex !== -1 && (nextNonBlankIndex === void 0 || nextNonBlankIndex <= index)) {
+      nextNonBlankIndex = validIndices[currentValidIndexPointer] ?? -1;
+      if (nextNonBlankIndex >= end) {
+        nextNonBlankIndex = -1;
+      }
+    }
+    if (index === nextNonBlankIndex) {
+      prevNonBlankIndex = index;
+      currentValidIndexPointer++;
+      continue;
+    }
+    const timeOfCurrent = timesAsc[index];
+    const timeOfPrevIndex = prevNonBlankIndex !== void 0 ? timesAsc[prevNonBlankIndex] ?? -Infinity : -Infinity;
+    const timeOfNextIndex = timesAsc[nextNonBlankIndex] ?? Infinity;
+    const prevTimeDiff = timeOfCurrent - timeOfPrevIndex;
+    const nextTimeDiff = timeOfNextIndex - timeOfCurrent;
+    if (nextNonBlankIndex !== void 0 && nextNonBlankIndex !== -1 && nextTimeDiff <= prevTimeDiff && nextTimeDiff <= context.timeToleranceForwards) {
+      valuesSortedByTimeAsc[index] = valuesSortedByTimeAsc[nextNonBlankIndex];
+      timesAsc[index] = timesAsc[nextNonBlankIndex];
+    } else if (prevNonBlankIndex !== void 0 && prevTimeDiff <= context.timeToleranceBackwards) {
+      valuesSortedByTimeAsc[index] = valuesSortedByTimeAsc[prevNonBlankIndex];
+      timesAsc[index] = timesAsc[prevNonBlankIndex];
+    } else
+      valuesSortedByTimeAsc[index] = ErrorValueTypes.NoValueWithinTolerance;
+  }
+}
+const makeKeyFn = (columnStore, columnSlugs) => {
+  const cols = columnSlugs.map((slug) => columnStore[slug]);
+  const toStr = (val) => val === null || val === void 0 ? "" : typeof val === "string" ? val : val + "";
+  if (cols.length === 0) return () => "";
+  if (cols.length === 1) {
+    const col = cols[0];
+    return (rowIndex) => toStr(col[rowIndex]);
+  }
+  if (cols.length === 2) {
+    const col0 = cols[0], col1 = cols[1];
+    return (rowIndex) => `${toStr(col0[rowIndex])} ${toStr(col1[rowIndex])}`;
+  }
+  if (cols.length === 3) {
+    const col0 = cols[0], col1 = cols[1], col2 = cols[2];
+    return (rowIndex) => `${toStr(col0[rowIndex])} ${toStr(col1[rowIndex])} ${toStr(
+      col2[rowIndex]
+    )}`;
+  }
+  return (rowIndex) => (
+    // toString() handles `undefined` and `null` values, which can be in the table.
+    cols.map((col) => toStr(col[rowIndex])).join(" ")
+  );
+};
+const getColumnStoreLength = (store) => {
+  return _.max(Object.values(store).map((v) => v.length)) ?? 0;
+};
+const concatColumnStores = (stores, slugsToKeep) => {
+  if (!stores.length) return {};
+  const lengths = stores.map(getColumnStoreLength);
+  const slugs = slugsToKeep ?? Object.keys(R.first(stores));
+  const newColumnStore = {};
+  slugs.forEach((slug) => {
+    let newColumnValues = [];
+    for (const [i, store] of stores.entries()) {
+      const values = store[slug] ?? [];
+      const toFill = Math.max(0, lengths[i] - values.length);
+      newColumnValues = newColumnValues.concat(values);
+      if (toFill > 0) {
+        newColumnValues = newColumnValues.concat(
+          new Array(toFill).fill(
+            ErrorValueTypes.MissingValuePlaceholder
+          )
+        );
+      }
+    }
+    newColumnStore[slug] = newColumnValues;
+  });
+  return newColumnStore;
+};
+const rowsToColumnStore = (rows) => {
+  const columnsObject = {};
+  if (!rows.length) return columnsObject;
+  Object.keys(rows[0]).forEach((slug) => {
+    columnsObject[slug] = rows.map((row) => row[slug]);
+  });
+  return columnsObject;
+};
+const guessColumnDefsFromRows = (rows, definedSlugs) => {
+  if (!rows[0]) return [];
+  return Object.keys(rows[0]).filter((slug) => !definedSlugs.has(slug)).map((slug) => {
+    const firstRowWithValue = rows.find(
+      (row) => row[slug] !== void 0 && row[slug] !== null && row[slug] !== ""
+    );
+    const firstValue = firstRowWithValue ? firstRowWithValue[slug] : void 0;
+    return guessColumnDefFromSlugAndRow(slug, firstValue);
+  });
+};
+const autodetectColumnDefs = (rowsOrColumnStore, definedSlugs) => {
+  if (!Array.isArray(rowsOrColumnStore)) {
+    const columnStore = rowsOrColumnStore;
+    return Object.keys(columnStore).filter((slug) => !definedSlugs.has(slug)).map((slug) => {
+      return guessColumnDefFromSlugAndRow(
+        slug,
+        columnStore[slug].find(
+          (val) => val !== void 0 && val !== null
+        )
+      );
+    });
+  }
+  return guessColumnDefsFromRows(rowsOrColumnStore, definedSlugs);
+};
+const replaceDef = (defs, newDefs) => defs.map((def) => {
+  const newDef = newDefs.find((newDef2) => newDef2.slug === def.slug);
+  return newDef ?? def;
+});
+const renameColumnStore = (columnStore, columnRenameMap) => {
+  const newStore = {};
+  Object.keys(columnStore).forEach((slug) => {
+    if (columnRenameMap[slug])
+      newStore[columnRenameMap[slug]] = columnStore[slug];
+    else newStore[slug] = columnStore[slug];
+  });
+  return newStore;
+};
+const getDropIndexes = (arrayLength, howMany, seed = Date.now()) => new Set(sampleFrom(_.range(0, arrayLength), howMany, seed));
+const replaceRandomCellsInColumnStore = (columnStore, howMany = 1, columnSlugs = [], seed = Date.now(), replacementGenerator = () => ErrorValueTypes.DroppedForTesting) => {
+  const newStore = Object.assign({}, columnStore);
+  columnSlugs.forEach((slug) => {
+    const values = newStore[slug];
+    const indexesToDrop = getDropIndexes(values.length, howMany, seed);
+    newStore[slug] = values.map(
+      (value, index) => indexesToDrop.has(index) ? replacementGenerator() : value
+    );
+  });
+  return newStore;
+};
+class Timer {
+  constructor() {
+    this._tickTime = Date.now();
+    this._firstTickTime = this._tickTime;
+  }
+  tick(msg) {
+    const elapsed = Date.now() - this._tickTime;
+    if (msg) console.log(`${elapsed}ms ${msg}`);
+    this._tickTime = Date.now();
+    return elapsed;
+  }
+  getTotalElapsedTime() {
+    return Date.now() - this._firstTickTime;
+  }
+}
+const rowsFromMatrix = (matrix) => {
+  const table = trimMatrix(matrix);
+  const header = table[0];
+  return table.slice(1).map((row) => {
+    const newRow = {};
+    header.forEach((col, index) => {
+      newRow[col] = row[index];
+    });
+    return newRow;
+  });
+};
+const trimEmptyColumns = (matrix) => matrix.map(trimArray);
+const trimMatrix = (matrix) => trimEmptyColumns(trimEmptyRows(matrix));
+const matrixToDelimited = (table, delimiter = "	") => {
+  return table.map(
+    (row) => row.map(
+      (cell) => cell === null || cell === void 0 ? "" : cell
+    ).join(delimiter)
+  ).join("\n");
+};
+const parseDelimited = (str, delimiter, parseFn) => {
+  const papaParseToD3 = ({
+    data,
+    meta
+  }) => {
+    const dsvParsed = data;
+    dsvParsed.columns = meta.fields || [];
+    for (const row of dsvParsed) {
+      for (const col of dsvParsed.columns) {
+        if (!(col in row)) row[col] = "";
+      }
+    }
+    return dsvParsed;
+  };
+  const result = Papa.parse(str, {
+    delimiter: delimiter ?? detectDelimiter(str),
+    header: true,
+    skipEmptyLines: true,
+    transformHeader: (header) => header.trim(),
+    transform: (value) => value.trim()
+  });
+  if (parseFn) {
+    result.data = result.data.map((rawRow) => parseFn(rawRow));
+  }
+  return papaParseToD3(result);
+};
+const detectDelimiter = (str) => str.includes("	") ? "	" : str.includes(",") ? "," : " ";
+const rowsToMatrix = (rows) => rows.length ? [Object.keys(rows[0]), ...rows.map((row) => Object.values(row))] : void 0;
+const isRowEmpty = (row) => row.every(isCellEmpty);
+const isCellEmpty = (cell) => cell === null || cell === void 0 || cell === "";
+const trimEmptyRows = (matrix) => {
+  let trimAt = void 0;
+  for (let rowIndex = matrix.length - 1; rowIndex >= 0; rowIndex--) {
+    if (!isRowEmpty(matrix[rowIndex])) break;
+    trimAt = rowIndex;
+  }
+  return trimAt === void 0 ? matrix : matrix.slice(0, trimAt);
+};
+const trimArray = (arr) => {
+  let rightIndex;
+  for (rightIndex = arr.length - 1; rightIndex >= 0; rightIndex--) {
+    if (!isCellEmpty(arr[rightIndex])) break;
+  }
+  return arr.slice(0, rightIndex + 1);
+};
+const applyNewSortOrder = (arr, newOrder) => {
+  const newArr = new Array(arr.length);
+  for (let i = 0; i < newOrder.length; i++) {
+    const index = newOrder[i];
+    newArr[i] = arr[index];
+  }
+  return newArr;
+};
+const sortColumnStore = (columnStore, slugs) => {
+  const firstCol = Object.values(columnStore)[0];
+  if (!firstCol) return {};
+  const len = firstCol.length;
+  const sortFn = makeSortByFn(columnStore, slugs);
+  let isSorted = true;
+  for (let i = 0; i < len - 1; i++) {
+    if (sortFn(i, i + 1) > 0) {
+      isSorted = false;
+      break;
+    }
+  }
+  if (isSorted) return columnStore;
+  const newStore = {};
+  const newOrder = _.range(0, len).sort(sortFn);
+  Object.entries(columnStore).forEach(([slug, colValues]) => {
+    newStore[slug] = applyNewSortOrder(colValues, newOrder);
+  });
+  return newStore;
+};
+const makeSortByFn = (columnStore, columnSlugs) => {
+  const cols = columnSlugs.map((slug) => columnStore[slug]);
+  return (indexA, indexB) => {
+    const nodeAFirst = -1;
+    const nodeBFirst = 1;
+    for (let colIndex = 0; colIndex < cols.length; colIndex++) {
+      const col = cols[colIndex];
+      const av = col[indexA];
+      const bv = col[indexB];
+      if (av < bv) return nodeAFirst;
+      if (av > bv) return nodeBFirst;
+    }
+    return 0;
+  };
+};
+const emptyColumnsInFirstRowInDelimited = (str) => {
+  const shortCsv = parseDelimited(str.split("\n").slice(0, 2).join("\n"));
+  const firstRow = shortCsv[0] ?? {};
+  const emptySlugs = [];
+  Object.keys(firstRow).forEach((slug) => {
+    if (firstRow[slug] === "") emptySlugs.push(slug);
+  });
+  return emptySlugs;
+};
+export {
+  Timer,
+  autodetectColumnDefs,
+  columnStoreToRows,
+  concatColumnStores,
+  detectDelimiter,
+  emptyColumnsInFirstRowInDelimited,
+  getDropIndexes,
+  guessColumnDefFromSlugAndRow,
+  isCellEmpty,
+  linearInterpolation,
+  makeAutoTypeFn,
+  makeKeyFn,
+  makeRowFromColumnStore,
+  matrixToDelimited,
+  parseDelimited,
+  renameColumnStore,
+  replaceDef,
+  replaceRandomCellsInColumnStore,
+  rowsFromMatrix,
+  rowsToColumnStore,
+  rowsToMatrix,
+  sortColumnStore,
+  standardizeSlugs,
+  toleranceInterpolation,
+  trimArray,
+  trimEmptyRows,
+  trimMatrix,
+  truncate
+};

package/dist/core-table/CoreTableUtils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/core-table/CoreTableUtils.ts"],
+  "sourcesContent": ["// @ts-nocheck\nimport * as _ from \"lodash-es\"\nimport * as Papa from \"papaparse\"\nimport * as R from \"remeda\"\nimport { sampleFrom, slugifySameCase, ColumnSlug } from \"../utils/index.js\"\nimport {\n    CoreColumnStore,\n    CoreRow,\n    CoreMatrix,\n    Time,\n    CoreValueType,\n    ColumnTypeNames,\n    CoreColumnDef,\n    ErrorValue,\n    EntityCodeColumnDef,\n    EntityIdColumnDef,\n    EntityNameColumnDef,\n    ChartsTableSlugs,\n} from \"../types/index.js\"\nimport { ErrorValueTypes, DroppedForTesting } from \"./ErrorValues.js\"\n\nexport const columnStoreToRows = (\n    columnStore: CoreColumnStore\n): Record<string, CoreValueType>[] => {\n    const firstCol = Object.values(columnStore)[0]\n    if (!firstCol) return []\n    const slugs = Object.keys(columnStore)\n    return firstCol.map((val, index) => {\n        const newRow: Record<string, CoreValueType> = {}\n        slugs.forEach((slug) => {\n            newRow[slug] = columnStore[slug][index]\n        })\n        return newRow\n    })\n}\n\n// If string exceeds maxLength, will replace the end char with a ... and drop the rest\nexport const truncate = (str: string, maxLength: number): string =>\n    str.length > maxLength ? `${str.substr(0, maxLength - 3)}...` : str\n\n// Picks a type for each column from the first row then autotypes all rows after that so all values in\n// a column will have the same type. Only chooses between strings and numbers.\nconst numberOnly = /^-?\\d+\\.?\\d*$/\ntype RawRow = Record<string, unknown> | undefined\ntype ParsedRow = Record<string, string | number | ErrorValue> | undefined | null\nexport const makeAutoTypeFn = (\n    numericSlugs?: ColumnSlug[]\n): ((object?: RawRow) => ParsedRow) => {\n    const slugToType: any = {}\n    numericSlugs?.forEach((slug) => {\n        slugToType[slug] = \"number\"\n    })\n    return (object: RawRow): ParsedRow => {\n        for (const columnSlug in object) {\n            const value = object[columnSlug]\n            const type = slugToType[columnSlug]\n            if (type === \"string\") {\n                object[columnSlug] = value\n                continue\n            }\n\n            const number = parseFloat(value as string) // The \"+\" type casting that d3 does for perf converts \"\" to 0, so use parseFloat.\n            if (type === \"number\") {\n                object[columnSlug] = isNaN(number)\n                    ? ErrorValueTypes.NaNButShouldBeNumber\n                    : number\n                continue\n            }\n\n            if (isNaN(number) || !numberOnly.test(value as string)) {\n                object[columnSlug] = value\n                slugToType[columnSlug] = \"string\"\n                continue\n            }\n\n            object[columnSlug] = number\n            slugToType[columnSlug] = \"number\"\n        }\n        return object as ParsedRow\n    }\n}\n\n// Removes whitespace and non-word characters from column slugs if any exist.\n// The original names are moved to the name property on the column def.\nexport const standardizeSlugs = (\n    rows: CoreRow[]\n): { rows: CoreRow[]; defs: { name: string; slug: string }[] } | undefined => {\n    const firstRow = rows[0] ?? {}\n    const colsToRename = Object.keys(firstRow)\n        .map((name) => {\n            return {\n                name,\n                slug: slugifySameCase(name),\n            }\n        })\n        .filter((col) => col.name !== col.slug)\n    if (!colsToRename.length) return undefined\n\n    rows.forEach((row: CoreRow) => {\n        colsToRename.forEach((col) => {\n            row[col.slug] = row[col.name]\n            delete row[col.name]\n        })\n    })\n\n    return { rows, defs: colsToRename }\n}\n\nexport const guessColumnDefFromSlugAndRow = (\n    slug: string,\n    sampleValue: unknown\n): CoreColumnDef => {\n    const valueType = typeof sampleValue\n\n    const name = slug\n\n    if (slug === \"Entity\")\n        return {\n            slug,\n            type: ColumnTypeNames.EntityName,\n            name,\n        }\n\n    if (slug === \"day\")\n        return {\n            slug,\n            type: ColumnTypeNames.Day,\n            name: \"Day\",\n        }\n\n    if (slug === \"year\" || slug === \"Year\")\n        return {\n            slug,\n            type: ColumnTypeNames.Year,\n            name: \"Year\",\n        }\n\n    if (slug === ChartsTableSlugs.entityName) return EntityNameColumnDef\n    if (slug === ChartsTableSlugs.entityCode) return EntityCodeColumnDef\n    if (slug === ChartsTableSlugs.entityId) return EntityIdColumnDef\n\n    if (slug === \"date\")\n        return {\n            slug,\n            type: ColumnTypeNames.Date,\n            name: \"Date\",\n        }\n\n    if (valueType === \"number\")\n        return {\n            slug,\n            type: ColumnTypeNames.Numeric,\n            name,\n        }\n\n    if (valueType === \"string\") {\n        if (String(sampleValue).match(/^\\d+$/))\n            return {\n                slug,\n                type: ColumnTypeNames.Numeric,\n                name,\n            }\n    }\n\n    return { slug, type: ColumnTypeNames.String, name }\n}\n\nexport const makeRowFromColumnStore = (\n    rowIndex: number,\n    columnStore: CoreColumnStore\n): CoreRow => {\n    const row: CoreRow = {}\n    Object.entries(columnStore).forEach(([slug, col]) => {\n        if (col.length <= rowIndex) row[slug] = undefined\n        else row[slug] = col[rowIndex]\n    })\n    return row\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface, @typescript-eslint/no-empty-object-type\nexport interface InterpolationContext {}\n\nexport interface LinearInterpolationContext extends InterpolationContext {\n    // whether to extrapolate a variable at the start or end, where we cannot do linear interpolation\n    // but need to just copy over the first/last value present over to empty fields.\n    // e.g. [Error, Error, 2, 3, 4] would become [2, 2, 2, 3, 4] with extrapolateAtStart=true.\n    extrapolateAtStart?: boolean\n    extrapolateAtEnd?: boolean\n}\n\nexport interface ToleranceInterpolationContext extends InterpolationContext {\n    timeToleranceForwards: number\n    timeToleranceBackwards: number\n}\n\nexport type InterpolationProvider<C extends InterpolationContext> = (\n    valuesSortedByTimeAsc: CoreValueType[],\n    timesAsc: Time[],\n    validIndices: number[],\n    context: C,\n    start: number,\n    end: number\n) => void\n\nexport function linearInterpolation(\n    valuesSortedByTimeAsc: CoreValueType[],\n    timesAsc: Time[],\n    validIndices: number[],\n    context: LinearInterpolationContext,\n    start: number = 0,\n    end: number = valuesSortedByTimeAsc.length\n): void {\n    if (!valuesSortedByTimeAsc.length) return\n\n    const startIndexInValidIndices = R.sortedIndex(validIndices, start)\n    const endIndexInValidIndices = R.sortedIndex(validIndices, end)\n\n    const distBetweenStartAndEnd =\n        endIndexInValidIndices - startIndexInValidIndices\n\n    if (distBetweenStartAndEnd === 0) {\n        // No valid values in this range, we can short-circuit\n        for (let index = start; index < end; index++) {\n            valuesSortedByTimeAsc[index] =\n                ErrorValueTypes.NoValueForInterpolation\n        }\n        return\n    }\n    // All values in this range are already valid, we don't need to do anything\n    else if (distBetweenStartAndEnd === end - start) {\n        return\n    }\n\n    let currentValidIndexPointer = startIndexInValidIndices\n    let prevNonBlankIndex: number | undefined = undefined\n    let nextNonBlankIndex: number | undefined = undefined\n\n    for (let index = start; index < end; index++) {\n        if (\n            nextNonBlankIndex !== -1 &&\n            (nextNonBlankIndex === undefined || nextNonBlankIndex <= index)\n        ) {\n            nextNonBlankIndex = validIndices[currentValidIndexPointer] ?? -1\n            if (nextNonBlankIndex >= end) {\n                nextNonBlankIndex = -1\n            }\n        }\n\n        // Check whether the current index has a valid value\n        if (index === nextNonBlankIndex) {\n            prevNonBlankIndex = index\n            currentValidIndexPointer++\n            continue\n        }\n\n        const timeOfCurrent = timesAsc[index]\n\n        const timeOfPrevIndex =\n            prevNonBlankIndex !== undefined\n                ? (timesAsc[prevNonBlankIndex] ?? -Infinity)\n                : -Infinity\n        const timeOfNextIndex = timesAsc[nextNonBlankIndex] ?? Infinity\n\n        const prevValue: number | undefined =\n            prevNonBlankIndex !== undefined\n                ? (valuesSortedByTimeAsc[prevNonBlankIndex] as\n                      | number\n                      | undefined)\n                : undefined\n        const nextValue: number | undefined = valuesSortedByTimeAsc[\n            nextNonBlankIndex\n        ] as number | undefined\n\n        let value\n        if (typeof prevValue === \"number\" && typeof nextValue === \"number\") {\n            const distLeft = timeOfCurrent - timeOfPrevIndex\n            const distRight = timeOfNextIndex - timeOfCurrent\n            value =\n                (prevValue * distRight + nextValue * distLeft) /\n                (distLeft + distRight)\n        } else if (typeof prevValue === \"number\" && context.extrapolateAtEnd)\n            value = prevValue\n        else if (typeof nextValue === \"number\" && context.extrapolateAtStart)\n            value = nextValue\n        else value = ErrorValueTypes.NoValueForInterpolation\n\n        valuesSortedByTimeAsc[index] = value\n    }\n}\n\nexport function toleranceInterpolation(\n    valuesSortedByTimeAsc: CoreValueType[],\n    timesAsc: Time[],\n    validIndices: number[],\n    context: ToleranceInterpolationContext,\n    start: number = 0,\n    end: number = valuesSortedByTimeAsc.length\n): void {\n    if (!valuesSortedByTimeAsc.length) return\n\n    // `validIndices` contains the indexes of all non-error values in `valuesSortedByTimeAsc`.\n    // Here, we find the *indexes* of where `start` and `end` appear in `validIndices` (note that\n    // `start` and `end` themselves are indexes into `valuesSortedByTimeAsc`).\n    const startIndexInValidIndices = R.sortedIndex(validIndices, start)\n    const endIndexInValidIndices = R.sortedIndex(validIndices, end)\n\n    const distBetweenStartAndEnd =\n        endIndexInValidIndices - startIndexInValidIndices\n\n    // If the two indices are the same, then there are no valid values in this range.\n    if (distBetweenStartAndEnd === 0) {\n        // No valid values in this range, we can short-circuit\n        for (let index = start; index < end; index++) {\n            valuesSortedByTimeAsc[index] =\n                ErrorValueTypes.NoValueWithinTolerance\n        }\n        return\n    }\n    // All values in this range are valid, we can short-circuit\n    else if (distBetweenStartAndEnd === end - start) {\n        return\n    }\n    // If the two indices differ by 1, then there is only one valid value in this range.\n    else if (distBetweenStartAndEnd === 1) {\n        // Only one valid value in this range, we can short-circuit\n        const onlyValidIndex = validIndices[startIndexInValidIndices]\n        const timeOfOnlyValid = timesAsc[onlyValidIndex]\n\n        for (let index = start; index < end; index++) {\n            if (index === onlyValidIndex) continue\n\n            const timeOfCurrent = timesAsc[index]\n            const timeDiff = timeOfOnlyValid - timeOfCurrent\n            if (\n                (timeDiff < 0 &&\n                    Math.abs(timeDiff) <= context.timeToleranceBackwards) ||\n                (timeDiff > 0 &&\n                    Math.abs(timeDiff) <= context.timeToleranceForwards)\n            ) {\n                valuesSortedByTimeAsc[index] =\n                    valuesSortedByTimeAsc[onlyValidIndex]\n                timesAsc[index] = timeOfOnlyValid\n            } else {\n                valuesSortedByTimeAsc[index] =\n                    ErrorValueTypes.NoValueWithinTolerance\n            }\n        }\n        return\n    }\n\n    let currentValidIndexPointer = startIndexInValidIndices\n    let prevNonBlankIndex: number | undefined = undefined\n    let nextNonBlankIndex: number | undefined = undefined\n\n    for (let index = start; index < end; index++) {\n        if (\n            nextNonBlankIndex !== -1 &&\n            (nextNonBlankIndex === undefined || nextNonBlankIndex <= index)\n        ) {\n            nextNonBlankIndex = validIndices[currentValidIndexPointer] ?? -1\n            if (nextNonBlankIndex >= end) {\n                nextNonBlankIndex = -1\n            }\n        }\n\n        // Check whether the current index has a valid value\n        if (index === nextNonBlankIndex) {\n            prevNonBlankIndex = index\n            currentValidIndexPointer++\n            continue\n        }\n\n        const timeOfCurrent = timesAsc[index]\n\n        const timeOfPrevIndex =\n            prevNonBlankIndex !== undefined\n                ? (timesAsc[prevNonBlankIndex] ?? -Infinity)\n                : -Infinity\n        const timeOfNextIndex = timesAsc[nextNonBlankIndex] ?? Infinity\n\n        const prevTimeDiff = timeOfCurrent - timeOfPrevIndex\n        const nextTimeDiff = timeOfNextIndex - timeOfCurrent\n\n        if (\n            nextNonBlankIndex !== undefined &&\n            nextNonBlankIndex !== -1 &&\n            nextTimeDiff <= prevTimeDiff &&\n            nextTimeDiff <= context.timeToleranceForwards\n        ) {\n            valuesSortedByTimeAsc[index] =\n                valuesSortedByTimeAsc[nextNonBlankIndex]\n            timesAsc[index] = timesAsc[nextNonBlankIndex]\n        } else if (\n            prevNonBlankIndex !== undefined &&\n            prevTimeDiff <= context.timeToleranceBackwards\n        ) {\n            valuesSortedByTimeAsc[index] =\n                valuesSortedByTimeAsc[prevNonBlankIndex]\n            timesAsc[index] = timesAsc[prevNonBlankIndex]\n        } else\n            valuesSortedByTimeAsc[index] =\n                ErrorValueTypes.NoValueWithinTolerance\n    }\n}\n\n// A dumb function for making a function that makes a key for a row given certain columns.\nexport const makeKeyFn = (\n    columnStore: CoreColumnStore,\n    columnSlugs: ColumnSlug[]\n): ((rowIndex: number) => string) => {\n    const cols = columnSlugs.map((slug) => columnStore[slug])\n\n    const toStr = (val: CoreValueType): string =>\n        val === null || val === undefined\n            ? \"\"\n            : typeof val === \"string\"\n              ? val\n              : (val as any) + \"\"\n\n    // perf: this function is performance-critical, and so for the common cases of 1, 2, or 3 columns, we can provide a\n    // faster implementation.\n    if (cols.length === 0) return () => \"\"\n    if (cols.length === 1) {\n        const col = cols[0]\n        return (rowIndex: number): string => toStr(col[rowIndex])\n    }\n    if (cols.length === 2) {\n        const col0 = cols[0],\n            col1 = cols[1]\n        return (rowIndex: number): string =>\n            `${toStr(col0[rowIndex])} ${toStr(col1[rowIndex])}`\n    }\n    if (cols.length === 3) {\n        const col0 = cols[0],\n            col1 = cols[1],\n            col2 = cols[2]\n        return (rowIndex: number): string =>\n            `${toStr(col0[rowIndex])} ${toStr(col1[rowIndex])} ${toStr(\n                col2[rowIndex]\n            )}`\n    }\n\n    return (rowIndex: number): string =>\n        // toString() handles `undefined` and `null` values, which can be in the table.\n        cols.map((col) => toStr(col[rowIndex])).join(\" \")\n}\n\nconst getColumnStoreLength = (store: CoreColumnStore): number => {\n    return _.max(Object.values(store).map((v) => v.length)) ?? 0\n}\n\nexport const concatColumnStores = (\n    stores: CoreColumnStore[],\n    slugsToKeep?: ColumnSlug[]\n): CoreColumnStore => {\n    if (!stores.length) return {}\n\n    const lengths = stores.map(getColumnStoreLength)\n    const slugs = slugsToKeep ?? Object.keys(R.first(stores)!)\n\n    const newColumnStore: CoreColumnStore = {}\n\n    // The below code is performance-critical.\n    // That's why it's written using for loops and mutable arrays rather than using map or flatMap:\n    // To this day, that's still faster in JS.\n    slugs.forEach((slug) => {\n        let newColumnValues: CoreValueType[] = []\n        for (const [i, store] of stores.entries()) {\n            const values = store[slug] ?? []\n            const toFill = Math.max(0, lengths[i] - values.length)\n\n            newColumnValues = newColumnValues.concat(values)\n            if (toFill > 0) {\n                newColumnValues = newColumnValues.concat(\n                    new Array(toFill).fill(\n                        ErrorValueTypes.MissingValuePlaceholder\n                    )\n                )\n            }\n        }\n        newColumnStore[slug] = newColumnValues\n    })\n    return newColumnStore\n}\n\nexport const rowsToColumnStore = (rows: CoreRow[]): CoreColumnStore => {\n    const columnsObject: CoreColumnStore = {}\n    if (!rows.length) return columnsObject\n\n    Object.keys(rows[0]).forEach((slug) => {\n        columnsObject[slug] = rows.map((row) => row[slug])\n    })\n    return columnsObject\n}\n\nconst guessColumnDefsFromRows = (\n    rows: CoreRow[],\n    definedSlugs: Map<ColumnSlug, any>\n): CoreColumnDef[] => {\n    if (!rows[0]) return []\n    return Object.keys(rows[0])\n        .filter((slug) => !definedSlugs.has(slug))\n        .map((slug) => {\n            const firstRowWithValue = rows.find(\n                (row) =>\n                    row[slug] !== undefined &&\n                    row[slug] !== null &&\n                    row[slug] !== \"\"\n            )\n            const firstValue = firstRowWithValue\n                ? firstRowWithValue[slug]\n                : undefined\n\n            return guessColumnDefFromSlugAndRow(slug, firstValue)\n        })\n}\n\nexport const autodetectColumnDefs = (\n    rowsOrColumnStore: CoreColumnStore | CoreRow[],\n    definedSlugs: Map<ColumnSlug, any>\n): CoreColumnDef[] => {\n    if (!Array.isArray(rowsOrColumnStore)) {\n        const columnStore = rowsOrColumnStore as CoreColumnStore\n        return Object.keys(columnStore)\n            .filter((slug) => !definedSlugs.has(slug))\n            .map((slug) => {\n                return guessColumnDefFromSlugAndRow(\n                    slug,\n                    columnStore[slug].find(\n                        (val) => val !== undefined && val !== null\n                    )\n                )\n            })\n    }\n    return guessColumnDefsFromRows(rowsOrColumnStore, definedSlugs)\n}\n\n// Convenience method when you are replacing columns\nexport const replaceDef = <ColumnDef extends CoreColumnDef>(\n    defs: ColumnDef[],\n    newDefs: ColumnDef[]\n): ColumnDef[] =>\n    defs.map((def) => {\n        const newDef = newDefs.find((newDef) => newDef.slug === def.slug)\n        return newDef ?? def\n    })\n\nexport const renameColumnStore = (\n    columnStore: CoreColumnStore,\n    columnRenameMap: { [columnSlug: string]: ColumnSlug }\n): CoreColumnStore => {\n    const newStore: CoreColumnStore = {}\n    Object.keys(columnStore).forEach((slug) => {\n        if (columnRenameMap[slug])\n            newStore[columnRenameMap[slug]] = columnStore[slug]\n        else newStore[slug] = columnStore[slug]\n    })\n    return newStore\n}\n\n// Returns a Set of random indexes to drop in an array, preserving the order of the array\nexport const getDropIndexes = (\n    arrayLength: number,\n    howMany: number,\n    seed = Date.now()\n): Set<number> => new Set(sampleFrom(_.range(0, arrayLength), howMany, seed))\n\nexport const replaceRandomCellsInColumnStore = (\n    columnStore: CoreColumnStore,\n    howMany = 1,\n    columnSlugs: ColumnSlug[] = [],\n    seed = Date.now(),\n    replacementGenerator: () => any = (): DroppedForTesting =>\n        ErrorValueTypes.DroppedForTesting\n): CoreColumnStore => {\n    const newStore: CoreColumnStore = Object.assign({}, columnStore)\n    columnSlugs.forEach((slug) => {\n        const values = newStore[slug]\n        const indexesToDrop = getDropIndexes(values.length, howMany, seed)\n        newStore[slug] = values.map((value, index) =>\n            indexesToDrop.has(index) ? replacementGenerator() : value\n        )\n    })\n    return newStore\n}\n\nexport class Timer {\n    constructor() {\n        this._tickTime = Date.now()\n        this._firstTickTime = this._tickTime\n    }\n\n    private _tickTime: number\n    private _firstTickTime: number\n\n    tick(msg?: string): number {\n        const elapsed = Date.now() - this._tickTime\n        // eslint-disable-next-line no-console\n        if (msg) console.log(`${elapsed}ms ${msg}`)\n        this._tickTime = Date.now()\n        return elapsed\n    }\n\n    getTotalElapsedTime(): number {\n        return Date.now() - this._firstTickTime\n    }\n}\n\nexport const rowsFromMatrix = (matrix: CoreMatrix): any[] => {\n    const table = trimMatrix(matrix)\n    const header = table[0]\n    return table.slice(1).map((row) => {\n        const newRow: any = {}\n        header.forEach((col, index) => {\n            newRow[col] = row[index]\n        })\n        return newRow\n    })\n}\n\nconst trimEmptyColumns = (matrix: CoreMatrix): CoreMatrix =>\n    matrix.map(trimArray)\nexport const trimMatrix = (matrix: CoreMatrix): CoreMatrix =>\n    trimEmptyColumns(trimEmptyRows(matrix))\n\nexport const matrixToDelimited = (\n    table: CoreMatrix,\n    delimiter = \"\\t\"\n): string => {\n    return table\n        .map((row: any) =>\n            row\n                .map((cell: any) =>\n                    cell === null || cell === undefined ? \"\" : cell\n                )\n                .join(delimiter)\n        )\n        .join(\"\\n\")\n}\n\n/**\n * An array object representing all parsed rows. The array is enhanced with a property listing\n * the names of the parsed columns.\n */\nexport interface DSVParsedArray<T> extends Array<T> {\n    /**\n     * List of column names.\n     */\n    columns: Array<keyof T>\n}\n\nexport const parseDelimited = (\n    str: string,\n    delimiter?: string,\n    parseFn?: (rawRow: RawRow) => ParsedRow\n): DSVParsedArray<Record<string, any>> => {\n    // Convert PapaParse result to D3 format for backwards compatibility\n    const papaParseToD3 = ({\n        data,\n        meta,\n    }: Papa.ParseResult<any>): DSVParsedArray<Record<string, any>> => {\n        const dsvParsed = data as DSVParsedArray<Record<string, any>>\n        dsvParsed.columns = meta.fields || []\n\n        // Some downstream methods expect all rows to have fields for all columns,\n        // even if they are missing in that row. This loop ensures that.\n        for (const row of dsvParsed) {\n            for (const col of dsvParsed.columns) {\n                if (!(col in row)) row[col] = \"\"\n            }\n        }\n\n        return dsvParsed\n    }\n\n    const result = Papa.parse(str, {\n        delimiter: delimiter ?? detectDelimiter(str),\n        header: true,\n        skipEmptyLines: true,\n        transformHeader: (header: string) => header.trim(),\n        transform: (value: string) => value.trim(),\n    })\n\n    if (parseFn) {\n        result.data = result.data.map((rawRow) => parseFn(rawRow as RawRow))\n    }\n\n    return papaParseToD3(result)\n}\n\nexport const detectDelimiter = (str: string): \"\\t\" | \",\" | \" \" =>\n    str.includes(\"\\t\") ? \"\\t\" : str.includes(\",\") ? \",\" : \" \"\n\nexport const rowsToMatrix = (rows: any[]): CoreMatrix | undefined =>\n    rows.length\n        ? [Object.keys(rows[0]), ...rows.map((row) => Object.values(row))]\n        : undefined\n\nconst isRowEmpty = (row: any[]): boolean => row.every(isCellEmpty)\n\nexport const isCellEmpty = (cell: unknown): boolean =>\n    cell === null || cell === undefined || cell === \"\"\n\nexport const trimEmptyRows = (matrix: CoreMatrix): CoreMatrix => {\n    let trimAt = undefined\n    for (let rowIndex = matrix.length - 1; rowIndex >= 0; rowIndex--) {\n        if (!isRowEmpty(matrix[rowIndex])) break\n        trimAt = rowIndex\n    }\n    return trimAt === undefined ? matrix : matrix.slice(0, trimAt)\n}\n\nexport const trimArray = (arr: any[]): any[] => {\n    let rightIndex: number\n    for (rightIndex = arr.length - 1; rightIndex >= 0; rightIndex--) {\n        if (!isCellEmpty(arr[rightIndex])) break\n    }\n    return arr.slice(0, rightIndex + 1)\n}\n\nconst applyNewSortOrder = (arr: any[], newOrder: number[]): any[] => {\n    const newArr = new Array(arr.length)\n    for (let i = 0; i < newOrder.length; i++) {\n        const index = newOrder[i]\n        newArr[i] = arr[index]\n    }\n    return newArr\n}\n\nexport const sortColumnStore = (\n    columnStore: CoreColumnStore,\n    slugs: ColumnSlug[]\n): CoreColumnStore => {\n    const firstCol = Object.values(columnStore)[0]\n    if (!firstCol) return {}\n    const len = firstCol.length\n    const sortFn = makeSortByFn(columnStore, slugs)\n\n    // Check if column store is already sorted.\n    // If it's not sorted, we will detect that within the first few iterations usually.\n    let isSorted = true\n    for (let i = 0; i < len - 1; i++) {\n        if (sortFn(i, i + 1) > 0) {\n            isSorted = false\n            break\n        }\n    }\n    // Column store is already sorted; return existing store unchanged\n    if (isSorted) return columnStore\n\n    const newStore: CoreColumnStore = {}\n    // Compute an array of the new sort order, i.e. [0, 1, 2, ...] -> [2, 0, 1]\n    const newOrder = _.range(0, len).sort(sortFn)\n    Object.entries(columnStore).forEach(([slug, colValues]) => {\n        newStore[slug] = applyNewSortOrder(colValues, newOrder)\n    })\n\n    return newStore\n}\n\nconst makeSortByFn = (\n    columnStore: CoreColumnStore,\n    columnSlugs: ColumnSlug[]\n): ((indexA: number, indexB: number) => 1 | 0 | -1) => {\n    const cols = columnSlugs.map((slug) => columnStore[slug])\n\n    return (indexA: number, indexB: number): 1 | 0 | -1 => {\n        const nodeAFirst = -1\n        const nodeBFirst = 1\n\n        // eslint-disable-next-line @typescript-eslint/prefer-for-of\n        for (let colIndex = 0; colIndex < cols.length; colIndex++) {\n            const col = cols[colIndex]\n            const av = col[indexA]\n            const bv = col[indexB]\n            if (av < bv) return nodeAFirst\n            if (av > bv) return nodeBFirst\n            // todo: handle ErrorValues\n        }\n        return 0\n    }\n}\n\nexport const emptyColumnsInFirstRowInDelimited = (str: string): string[] => {\n    // todo: don't split a big string here, just do a faster first line scan\n    const shortCsv = parseDelimited(str.split(\"\\n\").slice(0, 2).join(\"\\n\"))\n    const firstRow: any = shortCsv[0] ?? {}\n    const emptySlugs: string[] = []\n    Object.keys(firstRow).forEach((slug) => {\n        if (firstRow[slug] === \"\") emptySlugs.push(slug)\n    })\n    return emptySlugs\n}\n"],
+  "mappings": "AACA,YAAY,OAAO;AACnB,YAAY,UAAU;AACtB,YAAY,OAAO;AACnB,SAAS,YAAY,uBAAmC;AACxD;AAAA,EAMI;AAAA,EAGA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACG;AACP,SAAS,uBAA0C;AAE5C,MAAM,oBAAoB,CAC7B,gBACkC;AAClC,QAAM,WAAW,OAAO,OAAO,WAAW,EAAE,CAAC;AAC7C,MAAI,CAAC,SAAU,QAAO,CAAC;AACvB,QAAM,QAAQ,OAAO,KAAK,WAAW;AACrC,SAAO,SAAS,IAAI,CAAC,KAAK,UAAU;AAChC,UAAM,SAAwC,CAAC;AAC/C,UAAM,QAAQ,CAAC,SAAS;AACpB,aAAO,IAAI,IAAI,YAAY,IAAI,EAAE,KAAK;AAAA,IAC1C,CAAC;AACD,WAAO;AAAA,EACX,CAAC;AACL;AAGO,MAAM,WAAW,CAAC,KAAa,cAClC,IAAI,SAAS,YAAY,GAAG,IAAI,OAAO,GAAG,YAAY,CAAC,CAAC,QAAQ;AAIpE,MAAM,aAAa;AAGZ,MAAM,iBAAiB,CAC1B,iBACmC;AACnC,QAAM,aAAkB,CAAC;AACzB,gBAAc,QAAQ,CAAC,SAAS;AAC5B,eAAW,IAAI,IAAI;AAAA,EACvB,CAAC;AACD,SAAO,CAAC,WAA8B;AAClC,eAAW,cAAc,QAAQ;AAC7B,YAAM,QAAQ,OAAO,UAAU;AAC/B,YAAM,OAAO,WAAW,UAAU;AAClC,UAAI,SAAS,UAAU;AACnB,eAAO,UAAU,IAAI;AACrB;AAAA,MACJ;AAEA,YAAM,SAAS,WAAW,KAAe;AACzC,UAAI,SAAS,UAAU;AACnB,eAAO,UAAU,IAAI,MAAM,MAAM,IAC3B,gBAAgB,uBAChB;AACN;AAAA,MACJ;AAEA,UAAI,MAAM,MAAM,KAAK,CAAC,WAAW,KAAK,KAAe,GAAG;AACpD,eAAO,UAAU,IAAI;AACrB,mBAAW,UAAU,IAAI;AACzB;AAAA,MACJ;AAEA,aAAO,UAAU,IAAI;AACrB,iBAAW,UAAU,IAAI;AAAA,IAC7B;AACA,WAAO;AAAA,EACX;AACJ;AAIO,MAAM,mBAAmB,CAC5B,SAC0E;AAC1E,QAAM,WAAW,KAAK,CAAC,KAAK,CAAC;AAC7B,QAAM,eAAe,OAAO,KAAK,QAAQ,EACpC,IAAI,CAAC,SAAS;AACX,WAAO;AAAA,MACH;AAAA,MACA,MAAM,gBAAgB,IAAI;AAAA,IAC9B;AAAA,EACJ,CAAC,EACA,OAAO,CAAC,QAAQ,IAAI,SAAS,IAAI,IAAI;AAC1C,MAAI,CAAC,aAAa,OAAQ,QAAO;AAEjC,OAAK,QAAQ,CAAC,QAAiB;AAC3B,iBAAa,QAAQ,CAAC,QAAQ;AAC1B,UAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AAC5B,aAAO,IAAI,IAAI,IAAI;AAAA,IACvB,CAAC;AAAA,EACL,CAAC;AAED,SAAO,EAAE,MAAM,MAAM,aAAa;AACtC;AAEO,MAAM,+BAA+B,CACxC,MACA,gBACgB;AAChB,QAAM,YAAY,OAAO;AAEzB,QAAM,OAAO;AAEb,MAAI,SAAS;AACT,WAAO;AAAA,MACH;AAAA,MACA,MAAM,gBAAgB;AAAA,MACtB;AAAA,IACJ;AAEJ,MAAI,SAAS;AACT,WAAO;AAAA,MACH;AAAA,MACA,MAAM,gBAAgB;AAAA,MACtB,MAAM;AAAA,IACV;AAEJ,MAAI,SAAS,UAAU,SAAS;AAC5B,WAAO;AAAA,MACH;AAAA,MACA,MAAM,gBAAgB;AAAA,MACtB,MAAM;AAAA,IACV;AAEJ,MAAI,SAAS,iBAAiB,WAAY,QAAO;AACjD,MAAI,SAAS,iBAAiB,WAAY,QAAO;AACjD,MAAI,SAAS,iBAAiB,SAAU,QAAO;AAE/C,MAAI,SAAS;AACT,WAAO;AAAA,MACH;AAAA,MACA,MAAM,gBAAgB;AAAA,MACtB,MAAM;AAAA,IACV;AAEJ,MAAI,cAAc;AACd,WAAO;AAAA,MACH;AAAA,MACA,MAAM,gBAAgB;AAAA,MACtB;AAAA,IACJ;AAEJ,MAAI,cAAc,UAAU;AACxB,QAAI,OAAO,WAAW,EAAE,MAAM,OAAO;AACjC,aAAO;AAAA,QACH;AAAA,QACA,MAAM,gBAAgB;AAAA,QACtB;AAAA,MACJ;AAAA,EACR;AAEA,SAAO,EAAE,MAAM,MAAM,gBAAgB,QAAQ,KAAK;AACtD;AAEO,MAAM,yBAAyB,CAClC,UACA,gBACU;AACV,QAAM,MAAe,CAAC;AACtB,SAAO,QAAQ,WAAW,EAAE,QAAQ,CAAC,CAAC,MAAM,GAAG,MAAM;AACjD,QAAI,IAAI,UAAU,SAAU,KAAI,IAAI,IAAI;AAAA,QACnC,KAAI,IAAI,IAAI,IAAI,QAAQ;AAAA,EACjC,CAAC;AACD,SAAO;AACX;AA2BO,SAAS,oBACZ,uBACA,UACA,cACA,SACA,QAAgB,GAChB,MAAc,sBAAsB,QAChC;AACJ,MAAI,CAAC,sBAAsB,OAAQ;AAEnC,QAAM,2BAA2B,EAAE,YAAY,cAAc,KAAK;AAClE,QAAM,yBAAyB,EAAE,YAAY,cAAc,GAAG;AAE9D,QAAM,yBACF,yBAAyB;AAE7B,MAAI,2BAA2B,GAAG;AAE9B,aAAS,QAAQ,OAAO,QAAQ,KAAK,SAAS;AAC1C,4BAAsB,KAAK,IACvB,gBAAgB;AAAA,IACxB;AACA;AAAA,EACJ,WAES,2BAA2B,MAAM,OAAO;AAC7C;AAAA,EACJ;AAEA,MAAI,2BAA2B;AAC/B,MAAI,oBAAwC;AAC5C,MAAI,oBAAwC;AAE5C,WAAS,QAAQ,OAAO,QAAQ,KAAK,SAAS;AAC1C,QACI,sBAAsB,OACrB,sBAAsB,UAAa,qBAAqB,QAC3D;AACE,0BAAoB,aAAa,wBAAwB,KAAK;AAC9D,UAAI,qBAAqB,KAAK;AAC1B,4BAAoB;AAAA,MACxB;AAAA,IACJ;AAGA,QAAI,UAAU,mBAAmB;AAC7B,0BAAoB;AACpB;AACA;AAAA,IACJ;AAEA,UAAM,gBAAgB,SAAS,KAAK;AAEpC,UAAM,kBACF,sBAAsB,SACf,SAAS,iBAAiB,KAAK,YAChC;AACV,UAAM,kBAAkB,SAAS,iBAAiB,KAAK;AAEvD,UAAM,YACF,sBAAsB,SACf,sBAAsB,iBAAiB,IAGxC;AACV,UAAM,YAAgC,sBAClC,iBACJ;AAEA,QAAI;AACJ,QAAI,OAAO,cAAc,YAAY,OAAO,cAAc,UAAU;AAChE,YAAM,WAAW,gBAAgB;AACjC,YAAM,YAAY,kBAAkB;AACpC,eACK,YAAY,YAAY,YAAY,aACpC,WAAW;AAAA,IACpB,WAAW,OAAO,cAAc,YAAY,QAAQ;AAChD,cAAQ;AAAA,aACH,OAAO,cAAc,YAAY,QAAQ;AAC9C,cAAQ;AAAA,QACP,SAAQ,gBAAgB;AAE7B,0BAAsB,KAAK,IAAI;AAAA,EACnC;AACJ;AAEO,SAAS,uBACZ,uBACA,UACA,cACA,SACA,QAAgB,GAChB,MAAc,sBAAsB,QAChC;AACJ,MAAI,CAAC,sBAAsB,OAAQ;AAKnC,QAAM,2BAA2B,EAAE,YAAY,cAAc,KAAK;AAClE,QAAM,yBAAyB,EAAE,YAAY,cAAc,GAAG;AAE9D,QAAM,yBACF,yBAAyB;AAG7B,MAAI,2BAA2B,GAAG;AAE9B,aAAS,QAAQ,OAAO,QAAQ,KAAK,SAAS;AAC1C,4BAAsB,KAAK,IACvB,gBAAgB;AAAA,IACxB;AACA;AAAA,EACJ,WAES,2BAA2B,MAAM,OAAO;AAC7C;AAAA,EACJ,WAES,2BAA2B,GAAG;AAEnC,UAAM,iBAAiB,aAAa,wBAAwB;AAC5D,UAAM,kBAAkB,SAAS,cAAc;AAE/C,aAAS,QAAQ,OAAO,QAAQ,KAAK,SAAS;AAC1C,UAAI,UAAU,eAAgB;AAE9B,YAAM,gBAAgB,SAAS,KAAK;AACpC,YAAM,WAAW,kBAAkB;AACnC,UACK,WAAW,KACR,KAAK,IAAI,QAAQ,KAAK,QAAQ,0BACjC,WAAW,KACR,KAAK,IAAI,QAAQ,KAAK,QAAQ,uBACpC;AACE,8BAAsB,KAAK,IACvB,sBAAsB,cAAc;AACxC,iBAAS,KAAK,IAAI;AAAA,MACtB,OAAO;AACH,8BAAsB,KAAK,IACvB,gBAAgB;AAAA,MACxB;AAAA,IACJ;AACA;AAAA,EACJ;AAEA,MAAI,2BAA2B;AAC/B,MAAI,oBAAwC;AAC5C,MAAI,oBAAwC;AAE5C,WAAS,QAAQ,OAAO,QAAQ,KAAK,SAAS;AAC1C,QACI,sBAAsB,OACrB,sBAAsB,UAAa,qBAAqB,QAC3D;AACE,0BAAoB,aAAa,wBAAwB,KAAK;AAC9D,UAAI,qBAAqB,KAAK;AAC1B,4BAAoB;AAAA,MACxB;AAAA,IACJ;AAGA,QAAI,UAAU,mBAAmB;AAC7B,0BAAoB;AACpB;AACA;AAAA,IACJ;AAEA,UAAM,gBAAgB,SAAS,KAAK;AAEpC,UAAM,kBACF,sBAAsB,SACf,SAAS,iBAAiB,KAAK,YAChC;AACV,UAAM,kBAAkB,SAAS,iBAAiB,KAAK;AAEvD,UAAM,eAAe,gBAAgB;AACrC,UAAM,eAAe,kBAAkB;AAEvC,QACI,sBAAsB,UACtB,sBAAsB,MACtB,gBAAgB,gBAChB,gBAAgB,QAAQ,uBAC1B;AACE,4BAAsB,KAAK,IACvB,sBAAsB,iBAAiB;AAC3C,eAAS,KAAK,IAAI,SAAS,iBAAiB;AAAA,IAChD,WACI,sBAAsB,UACtB,gBAAgB,QAAQ,wBAC1B;AACE,4BAAsB,KAAK,IACvB,sBAAsB,iBAAiB;AAC3C,eAAS,KAAK,IAAI,SAAS,iBAAiB;AAAA,IAChD;AACI,4BAAsB,KAAK,IACvB,gBAAgB;AAAA,EAC5B;AACJ;AAGO,MAAM,YAAY,CACrB,aACA,gBACiC;AACjC,QAAM,OAAO,YAAY,IAAI,CAAC,SAAS,YAAY,IAAI,CAAC;AAExD,QAAM,QAAQ,CAAC,QACX,QAAQ,QAAQ,QAAQ,SAClB,KACA,OAAO,QAAQ,WACb,MACC,MAAc;AAI3B,MAAI,KAAK,WAAW,EAAG,QAAO,MAAM;AACpC,MAAI,KAAK,WAAW,GAAG;AACnB,UAAM,MAAM,KAAK,CAAC;AAClB,WAAO,CAAC,aAA6B,MAAM,IAAI,QAAQ,CAAC;AAAA,EAC5D;AACA,MAAI,KAAK,WAAW,GAAG;AACnB,UAAM,OAAO,KAAK,CAAC,GACf,OAAO,KAAK,CAAC;AACjB,WAAO,CAAC,aACJ,GAAG,MAAM,KAAK,QAAQ,CAAC,CAAC,IAAI,MAAM,KAAK,QAAQ,CAAC,CAAC;AAAA,EACzD;AACA,MAAI,KAAK,WAAW,GAAG;AACnB,UAAM,OAAO,KAAK,CAAC,GACf,OAAO,KAAK,CAAC,GACb,OAAO,KAAK,CAAC;AACjB,WAAO,CAAC,aACJ,GAAG,MAAM,KAAK,QAAQ,CAAC,CAAC,IAAI,MAAM,KAAK,QAAQ,CAAC,CAAC,IAAI;AAAA,MACjD,KAAK,QAAQ;AAAA,IACjB,CAAC;AAAA,EACT;AAEA,SAAO,CAAC;AAAA;AAAA,IAEJ,KAAK,IAAI,CAAC,QAAQ,MAAM,IAAI,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG;AAAA;AACxD;AAEA,MAAM,uBAAuB,CAAC,UAAmC;AAC7D,SAAO,EAAE,IAAI,OAAO,OAAO,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK;AAC/D;AAEO,MAAM,qBAAqB,CAC9B,QACA,gBACkB;AAClB,MAAI,CAAC,OAAO,OAAQ,QAAO,CAAC;AAE5B,QAAM,UAAU,OAAO,IAAI,oBAAoB;AAC/C,QAAM,QAAQ,eAAe,OAAO,KAAK,EAAE,MAAM,MAAM,CAAE;AAEzD,QAAM,iBAAkC,CAAC;AAKzC,QAAM,QAAQ,CAAC,SAAS;AACpB,QAAI,kBAAmC,CAAC;AACxC,eAAW,CAAC,GAAG,KAAK,KAAK,OAAO,QAAQ,GAAG;AACvC,YAAM,SAAS,MAAM,IAAI,KAAK,CAAC;AAC/B,YAAM,SAAS,KAAK,IAAI,GAAG,QAAQ,CAAC,IAAI,OAAO,MAAM;AAErD,wBAAkB,gBAAgB,OAAO,MAAM;AAC/C,UAAI,SAAS,GAAG;AACZ,0BAAkB,gBAAgB;AAAA,UAC9B,IAAI,MAAM,MAAM,EAAE;AAAA,YACd,gBAAgB;AAAA,UACpB;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AACA,mBAAe,IAAI,IAAI;AAAA,EAC3B,CAAC;AACD,SAAO;AACX;AAEO,MAAM,oBAAoB,CAAC,SAAqC;AACnE,QAAM,gBAAiC,CAAC;AACxC,MAAI,CAAC,KAAK,OAAQ,QAAO;AAEzB,SAAO,KAAK,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,SAAS;AACnC,kBAAc,IAAI,IAAI,KAAK,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC;AAAA,EACrD,CAAC;AACD,SAAO;AACX;AAEA,MAAM,0BAA0B,CAC5B,MACA,iBACkB;AAClB,MAAI,CAAC,KAAK,CAAC,EAAG,QAAO,CAAC;AACtB,SAAO,OAAO,KAAK,KAAK,CAAC,CAAC,EACrB,OAAO,CAAC,SAAS,CAAC,aAAa,IAAI,IAAI,CAAC,EACxC,IAAI,CAAC,SAAS;AACX,UAAM,oBAAoB,KAAK;AAAA,MAC3B,CAAC,QACG,IAAI,IAAI,MAAM,UACd,IAAI,IAAI,MAAM,QACd,IAAI,IAAI,MAAM;AAAA,IACtB;AACA,UAAM,aAAa,oBACb,kBAAkB,IAAI,IACtB;AAEN,WAAO,6BAA6B,MAAM,UAAU;AAAA,EACxD,CAAC;AACT;AAEO,MAAM,uBAAuB,CAChC,mBACA,iBACkB;AAClB,MAAI,CAAC,MAAM,QAAQ,iBAAiB,GAAG;AACnC,UAAM,cAAc;AACpB,WAAO,OAAO,KAAK,WAAW,EACzB,OAAO,CAAC,SAAS,CAAC,aAAa,IAAI,IAAI,CAAC,EACxC,IAAI,CAAC,SAAS;AACX,aAAO;AAAA,QACH;AAAA,QACA,YAAY,IAAI,EAAE;AAAA,UACd,CAAC,QAAQ,QAAQ,UAAa,QAAQ;AAAA,QAC1C;AAAA,MACJ;AAAA,IACJ,CAAC;AAAA,EACT;AACA,SAAO,wBAAwB,mBAAmB,YAAY;AAClE;AAGO,MAAM,aAAa,CACtB,MACA,YAEA,KAAK,IAAI,CAAC,QAAQ;AACd,QAAM,SAAS,QAAQ,KAAK,CAACA,YAAWA,QAAO,SAAS,IAAI,IAAI;AAChE,SAAO,UAAU;AACrB,CAAC;AAEE,MAAM,oBAAoB,CAC7B,aACA,oBACkB;AAClB,QAAM,WAA4B,CAAC;AACnC,SAAO,KAAK,WAAW,EAAE,QAAQ,CAAC,SAAS;AACvC,QAAI,gBAAgB,IAAI;AACpB,eAAS,gBAAgB,IAAI,CAAC,IAAI,YAAY,IAAI;AAAA,QACjD,UAAS,IAAI,IAAI,YAAY,IAAI;AAAA,EAC1C,CAAC;AACD,SAAO;AACX;AAGO,MAAM,iBAAiB,CAC1B,aACA,SACA,OAAO,KAAK,IAAI,MACF,IAAI,IAAI,WAAW,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,IAAI,CAAC;AAErE,MAAM,kCAAkC,CAC3C,aACA,UAAU,GACV,cAA4B,CAAC,GAC7B,OAAO,KAAK,IAAI,GAChB,uBAAkC,MAC9B,gBAAgB,sBACF;AAClB,QAAM,WAA4B,OAAO,OAAO,CAAC,GAAG,WAAW;AAC/D,cAAY,QAAQ,CAAC,SAAS;AAC1B,UAAM,SAAS,SAAS,IAAI;AAC5B,UAAM,gBAAgB,eAAe,OAAO,QAAQ,SAAS,IAAI;AACjE,aAAS,IAAI,IAAI,OAAO;AAAA,MAAI,CAAC,OAAO,UAChC,cAAc,IAAI,KAAK,IAAI,qBAAqB,IAAI;AAAA,IACxD;AAAA,EACJ,CAAC;AACD,SAAO;AACX;AAEO,MAAM,MAAM;AAAA,EACf,cAAc;AACV,SAAK,YAAY,KAAK,IAAI;AAC1B,SAAK,iBAAiB,KAAK;AAAA,EAC/B;AAAA,EAKA,KAAK,KAAsB;AACvB,UAAM,UAAU,KAAK,IAAI,IAAI,KAAK;AAElC,QAAI,IAAK,SAAQ,IAAI,GAAG,OAAO,MAAM,GAAG,EAAE;AAC1C,SAAK,YAAY,KAAK,IAAI;AAC1B,WAAO;AAAA,EACX;AAAA,EAEA,sBAA8B;AAC1B,WAAO,KAAK,IAAI,IAAI,KAAK;AAAA,EAC7B;AACJ;AAEO,MAAM,iBAAiB,CAAC,WAA8B;AACzD,QAAM,QAAQ,WAAW,MAAM;AAC/B,QAAM,SAAS,MAAM,CAAC;AACtB,SAAO,MAAM,MAAM,CAAC,EAAE,IAAI,CAAC,QAAQ;AAC/B,UAAM,SAAc,CAAC;AACrB,WAAO,QAAQ,CAAC,KAAK,UAAU;AAC3B,aAAO,GAAG,IAAI,IAAI,KAAK;AAAA,IAC3B,CAAC;AACD,WAAO;AAAA,EACX,CAAC;AACL;AAEA,MAAM,mBAAmB,CAAC,WACtB,OAAO,IAAI,SAAS;AACjB,MAAM,aAAa,CAAC,WACvB,iBAAiB,cAAc,MAAM,CAAC;AAEnC,MAAM,oBAAoB,CAC7B,OACA,YAAY,QACH;AACT,SAAO,MACF;AAAA,IAAI,CAAC,QACF,IACK;AAAA,MAAI,CAAC,SACF,SAAS,QAAQ,SAAS,SAAY,KAAK;AAAA,IAC/C,EACC,KAAK,SAAS;AAAA,EACvB,EACC,KAAK,IAAI;AAClB;AAaO,MAAM,iBAAiB,CAC1B,KACA,WACA,YACsC;AAEtC,QAAM,gBAAgB,CAAC;AAAA,IACnB;AAAA,IACA;AAAA,EACJ,MAAkE;AAC9D,UAAM,YAAY;AAClB,cAAU,UAAU,KAAK,UAAU,CAAC;AAIpC,eAAW,OAAO,WAAW;AACzB,iBAAW,OAAO,UAAU,SAAS;AACjC,YAAI,EAAE,OAAO,KAAM,KAAI,GAAG,IAAI;AAAA,MAClC;AAAA,IACJ;AAEA,WAAO;AAAA,EACX;AAEA,QAAM,SAAS,KAAK,MAAM,KAAK;AAAA,IAC3B,WAAW,aAAa,gBAAgB,GAAG;AAAA,IAC3C,QAAQ;AAAA,IACR,gBAAgB;AAAA,IAChB,iBAAiB,CAAC,WAAmB,OAAO,KAAK;AAAA,IACjD,WAAW,CAAC,UAAkB,MAAM,KAAK;AAAA,EAC7C,CAAC;AAED,MAAI,SAAS;AACT,WAAO,OAAO,OAAO,KAAK,IAAI,CAAC,WAAW,QAAQ,MAAgB,CAAC;AAAA,EACvE;AAEA,SAAO,cAAc,MAAM;AAC/B;AAEO,MAAM,kBAAkB,CAAC,QAC5B,IAAI,SAAS,GAAI,IAAI,MAAO,IAAI,SAAS,GAAG,IAAI,MAAM;AAEnD,MAAM,eAAe,CAAC,SACzB,KAAK,SACC,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC,GAAG,GAAG,KAAK,IAAI,CAAC,QAAQ,OAAO,OAAO,GAAG,CAAC,CAAC,IAC/D;AAEV,MAAM,aAAa,CAAC,QAAwB,IAAI,MAAM,WAAW;AAE1D,MAAM,cAAc,CAAC,SACxB,SAAS,QAAQ,SAAS,UAAa,SAAS;AAE7C,MAAM,gBAAgB,CAAC,WAAmC;AAC7D,MAAI,SAAS;AACb,WAAS,WAAW,OAAO,SAAS,GAAG,YAAY,GAAG,YAAY;AAC9D,QAAI,CAAC,WAAW,OAAO,QAAQ,CAAC,EAAG;AACnC,aAAS;AAAA,EACb;AACA,SAAO,WAAW,SAAY,SAAS,OAAO,MAAM,GAAG,MAAM;AACjE;AAEO,MAAM,YAAY,CAAC,QAAsB;AAC5C,MAAI;AACJ,OAAK,aAAa,IAAI,SAAS,GAAG,cAAc,GAAG,cAAc;AAC7D,QAAI,CAAC,YAAY,IAAI,UAAU,CAAC,EAAG;AAAA,EACvC;AACA,SAAO,IAAI,MAAM,GAAG,aAAa,CAAC;AACtC;AAEA,MAAM,oBAAoB,CAAC,KAAY,aAA8B;AACjE,QAAM,SAAS,IAAI,MAAM,IAAI,MAAM;AACnC,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACtC,UAAM,QAAQ,SAAS,CAAC;AACxB,WAAO,CAAC,IAAI,IAAI,KAAK;AAAA,EACzB;AACA,SAAO;AACX;AAEO,MAAM,kBAAkB,CAC3B,aACA,UACkB;AAClB,QAAM,WAAW,OAAO,OAAO,WAAW,EAAE,CAAC;AAC7C,MAAI,CAAC,SAAU,QAAO,CAAC;AACvB,QAAM,MAAM,SAAS;AACrB,QAAM,SAAS,aAAa,aAAa,KAAK;AAI9C,MAAI,WAAW;AACf,WAAS,IAAI,GAAG,IAAI,MAAM,GAAG,KAAK;AAC9B,QAAI,OAAO,GAAG,IAAI,CAAC,IAAI,GAAG;AACtB,iBAAW;AACX;AAAA,IACJ;AAAA,EACJ;AAEA,MAAI,SAAU,QAAO;AAErB,QAAM,WAA4B,CAAC;AAEnC,QAAM,WAAW,EAAE,MAAM,GAAG,GAAG,EAAE,KAAK,MAAM;AAC5C,SAAO,QAAQ,WAAW,EAAE,QAAQ,CAAC,CAAC,MAAM,SAAS,MAAM;AACvD,aAAS,IAAI,IAAI,kBAAkB,WAAW,QAAQ;AAAA,EAC1D,CAAC;AAED,SAAO;AACX;AAEA,MAAM,eAAe,CACjB,aACA,gBACmD;AACnD,QAAM,OAAO,YAAY,IAAI,CAAC,SAAS,YAAY,IAAI,CAAC;AAExD,SAAO,CAAC,QAAgB,WAA+B;AACnD,UAAM,aAAa;AACnB,UAAM,aAAa;AAGnB,aAAS,WAAW,GAAG,WAAW,KAAK,QAAQ,YAAY;AACvD,YAAM,MAAM,KAAK,QAAQ;AACzB,YAAM,KAAK,IAAI,MAAM;AACrB,YAAM,KAAK,IAAI,MAAM;AACrB,UAAI,KAAK,GAAI,QAAO;AACpB,UAAI,KAAK,GAAI,QAAO;AAAA,IAExB;AACA,WAAO;AAAA,EACX;AACJ;AAEO,MAAM,oCAAoC,CAAC,QAA0B;AAExE,QAAM,WAAW,eAAe,IAAI,MAAM,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC;AACtE,QAAM,WAAgB,SAAS,CAAC,KAAK,CAAC;AACtC,QAAM,aAAuB,CAAC;AAC9B,SAAO,KAAK,QAAQ,EAAE,QAAQ,CAAC,SAAS;AACpC,QAAI,SAAS,IAAI,MAAM,GAAI,YAAW,KAAK,IAAI;AAAA,EACnD,CAAC;AACD,SAAO;AACX;",
+  "names": ["newDef"]
+}

package/dist/core-table/ErrorValues.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Previously when we get a blank for a value, or a string where we expect a number, etc,
+ * we parse things as simply undefineds or nulls or NaN. Since authors are uploading data
+ * from our sources at runtime, and errors in source data are extremely common, it may be helpful
+ * to parse those invalid values into specific types, to provide better error message and perhaps
+ * in the future suggested autocorrections or workarounds.
+ *
+ * For a good read on the "Errors are values" pattern: https://blog.golang.org/errors-are-values
+ */
+import { ErrorValue } from "../types/index.js";
+declare class NaNButShouldBeNumber extends ErrorValue {
+}
+export declare class DroppedForTesting extends ErrorValue {
+}
+declare class InvalidOnALogScale extends ErrorValue {
+}
+declare class UndefinedButShouldBeNumber extends ErrorValue {
+}
+declare class NullButShouldBeNumber extends ErrorValue {
+}
+declare class BlankButShouldBeNumber extends ErrorValue {
+}
+declare class UndefinedButShouldBeString extends ErrorValue {
+}
+declare class NullButShouldBeString extends ErrorValue {
+}
+declare class NotAParseableNumberButShouldBeNumber extends ErrorValue {
+}
+export declare class DivideByZeroError extends ErrorValue {
+}
+declare class NoValueWithinTolerance extends ErrorValue {
+}
+declare class NoMatchingValueAfterJoin extends ErrorValue {
+}
+export declare class ValueTooLow extends ErrorValue {
+}
+declare class NoValueToCompareAgainst extends ErrorValue {
+}
+declare class FilteredValue extends ErrorValue {
+}
+declare class NoValueForInterpolation extends ErrorValue {
+}
+declare class InvalidQuarterValue extends ErrorValue {
+}
+declare class InvalidNegativeValue extends ErrorValue {
+}
+declare class NoMatchingVariableId extends ErrorValue {
+}
+export declare class MissingValuePlaceholder extends ErrorValue {
+}
+export declare const ErrorValueTypes: {
+    NaNButShouldBeNumber: NaNButShouldBeNumber;
+    DroppedForTesting: DroppedForTesting;
+    InvalidOnALogScale: InvalidOnALogScale;
+    UndefinedButShouldBeNumber: UndefinedButShouldBeNumber;
+    NullButShouldBeNumber: NullButShouldBeNumber;
+    BlankButShouldBeNumber: BlankButShouldBeNumber;
+    UndefinedButShouldBeString: UndefinedButShouldBeString;
+    NullButShouldBeString: NullButShouldBeString;
+    MissingValuePlaceholder: MissingValuePlaceholder;
+    NotAParseableNumberButShouldBeNumber: NotAParseableNumberButShouldBeNumber;
+    DivideByZeroError: DivideByZeroError;
+    NoValueWithinTolerance: NoValueWithinTolerance;
+    NoMatchingValueAfterJoin: NoMatchingValueAfterJoin;
+    ValueTooLow: ValueTooLow;
+    NoValueToCompareAgainst: NoValueToCompareAgainst;
+    FilteredValue: FilteredValue;
+    NoValueForInterpolation: NoValueForInterpolation;
+    InvalidQuarterValue: InvalidQuarterValue;
+    InvalidNegativeValue: InvalidNegativeValue;
+    NoMatchingVariableId: NoMatchingVariableId;
+};
+export declare const isNotErrorValue: <TYPE>(item: TYPE | ErrorValue) => item is TYPE;
+export declare const isNotErrorValueOrEmptyCell: <K>(value: K) => value is Exclude<K, ErrorValue | undefined>;
+export declare const defaultIfErrorValue: <TYPE>(item: TYPE | ErrorValue, defaultValue?: TYPE) => TYPE | undefined;
+export {};
+//# sourceMappingURL=ErrorValues.d.ts.map

package/dist/core-table/ErrorValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorValues.d.ts","sourceRoot":"","sources":["../../src/core-table/ErrorValues.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE9C,cAAM,oBAAqB,SAAQ,UAAU;CAAG;AAChD,qBAAa,iBAAkB,SAAQ,UAAU;CAAG;AACpD,cAAM,kBAAmB,SAAQ,UAAU;CAAG;AAC9C,cAAM,0BAA2B,SAAQ,UAAU;CAAG;AACtD,cAAM,qBAAsB,SAAQ,UAAU;CAAG;AACjD,cAAM,sBAAuB,SAAQ,UAAU;CAAG;AAClD,cAAM,0BAA2B,SAAQ,UAAU;CAAG;AACtD,cAAM,qBAAsB,SAAQ,UAAU;CAAG;AACjD,cAAM,oCAAqC,SAAQ,UAAU;CAAG;AAChE,qBAAa,iBAAkB,SAAQ,UAAU;CAAG;AACpD,cAAM,sBAAuB,SAAQ,UAAU;CAAG;AAClD,cAAM,wBAAyB,SAAQ,UAAU;CAAG;AACpD,qBAAa,WAAY,SAAQ,UAAU;CAAG;AAC9C,cAAM,uBAAwB,SAAQ,UAAU;CAAG;AACnD,cAAM,aAAc,SAAQ,UAAU;CAAG;AACzC,cAAM,uBAAwB,SAAQ,UAAU;CAAG;AACnD,cAAM,mBAAoB,SAAQ,UAAU;CAAG;AAC/C,cAAM,oBAAqB,SAAQ,UAAU;CAAG;AAChD,cAAM,oBAAqB,SAAQ,UAAU;CAAG;AAGhD,qBAAa,uBAAwB,SAAQ,UAAU;CAAG;AAE1D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;CAsB3B,CAAA;AAID,eAAO,MAAM,eAAe,GAAI,IAAI,EAAE,MAAM,IAAI,GAAG,UAAU,KAAG,IAAI,IAAI,IACvC,CAAA;AAEjC,eAAO,MAAM,0BAA0B,GAAI,CAAC,EACxC,OAAO,CAAC,KACT,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,CACI,CAAA;AAEjD,eAAO,MAAM,mBAAmB,GAAI,IAAI,EACpC,MAAM,IAAI,GAAG,UAAU,EACvB,eAAe,IAAI,KACpB,IAAI,GAAG,SAA0D,CAAA"}