ggaction 0.0.12 → 0.0.15

package/src/grammar/impute.js

@@ -0,0 +1,340 @@
+import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { interpolateNumber, inverseLerp } from "./numeric.js";
+import { normalizeTemporalValue } from "./scales/fields.js";
+
+const TRANSFORM_KEYS = Object.freeze([
+  "type", "fields", "groupBy", "sortBy", "method", "value", "edges", "maxGap"
+]);
+const SORT_KEYS = Object.freeze(["field", "order"]);
+const METHODS = Object.freeze(["constant", "forward", "backward", "linear"]);
+
+function rejectUnknownKeys(value, supported, label) {
+  const unknown = Object.keys(value).find(key => !supported.includes(key));
+  if (unknown !== undefined) throw new Error(`Unknown ${label} property "${unknown}".`);
+}
+
+function requireField(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string.`);
+  }
+  return value;
+}
+
+function validateFieldList(value, label) {
+  if (!Array.isArray(value) || value.length === 0 || value.some(field =>
+    typeof field !== "string" || field.length === 0
+  )) {
+    throw new TypeError(`${label} must be a non-empty field array.`);
+  }
+  if (new Set(value).size !== value.length) throw new Error(`${label} fields must be unique.`);
+}
+
+function normalizeFieldList(value, { allowEmpty = false } = {}) {
+  if (value === undefined) return allowEmpty ? [] : value;
+  return Array.isArray(value) ? [...value] : [value];
+}
+
+function normalizeSortBy(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value)) return value;
+  return value.map(sort => isPlainObject(sort)
+    ? { ...sort, order: sort.order ?? "ascending" }
+    : sort
+  );
+}
+
+function validateSortBy(sortBy) {
+  if (!Array.isArray(sortBy)) throw new TypeError("Impute sortBy must be an array.");
+  const fields = [];
+  sortBy.forEach((sort, index) => {
+    if (!isPlainObject(sort)) {
+      throw new TypeError(`Impute sortBy[${index}] must be a plain object.`);
+    }
+    rejectUnknownKeys(sort, SORT_KEYS, `impute sortBy[${index}]`);
+    fields.push(requireField(sort.field, `Impute sortBy[${index}].field`));
+    if (!["ascending", "descending"].includes(sort.order)) {
+      throw new Error(`Unsupported impute sort order "${sort.order}".`);
+    }
+  });
+  if (new Set(fields).size !== fields.length) {
+    throw new Error("Impute sortBy fields must be unique.");
+  }
+}
+
+function scalarType(value, label) {
+  if (value === null || value === undefined) return undefined;
+  if (typeof value === "string" || typeof value === "boolean") return typeof value;
+  if (typeof value === "number" && Number.isFinite(value)) return "number";
+  throw new TypeError(`${label} must contain scalar values; NaN and Infinity are invalid.`);
+}
+
+function scalarKey(value, label) {
+  const type = scalarType(value, label);
+  if (type === undefined) return "null";
+  if (type === "number") return `number:${Object.is(value, -0) ? 0 : value}`;
+  if (type === "string") return `string:${value.length}:${value}`;
+  return `${type}:${value}`;
+}
+
+export function validateImputeTransform(transform) {
+  if (!isPlainObject(transform)) {
+    throw new TypeError("Impute transform must be a plain object.");
+  }
+  rejectUnknownKeys(transform, TRANSFORM_KEYS, "impute transform");
+  if (transform.type !== "impute") {
+    throw new Error(`Unsupported impute transform "${transform.type}".`);
+  }
+  validateFieldList(transform.fields, "Impute fields");
+  if (!Array.isArray(transform.groupBy) || transform.groupBy.some(field =>
+    typeof field !== "string" || field.length === 0
+  )) {
+    throw new TypeError("Impute groupBy must contain field names.");
+  }
+  if (new Set(transform.groupBy).size !== transform.groupBy.length) {
+    throw new Error("Impute groupBy fields must be unique.");
+  }
+  validateSortBy(transform.sortBy);
+  if (!METHODS.includes(transform.method)) {
+    throw new Error(`Unsupported impute method "${transform.method}".`);
+  }
+  const hasValue = Object.hasOwn(transform, "value");
+  if (transform.method === "constant") {
+    if (!hasValue) throw new TypeError("Impute constant requires a value.");
+    if (transform.value === undefined) {
+      throw new TypeError("Impute constant value must be a JSON-safe scalar.");
+    }
+    scalarType(transform.value, "Impute constant value");
+  } else {
+    if (hasValue) throw new Error(`Impute value is not available for ${transform.method}.`);
+    if (transform.sortBy.length === 0) {
+      throw new Error(`Impute ${transform.method} requires non-empty sortBy.`);
+    }
+  }
+  if (transform.method === "linear") {
+    if (transform.sortBy.length !== 1 || transform.sortBy[0].order !== "ascending") {
+      throw new Error("Impute linear requires exactly one ascending sortBy field.");
+    }
+  }
+  if (!['keep', 'error'].includes(transform.edges)) {
+    throw new Error(`Unsupported impute edges policy "${transform.edges}".`);
+  }
+  if (transform.maxGap !== undefined &&
+    (!Number.isSafeInteger(transform.maxGap) || transform.maxGap <= 0)) {
+    throw new RangeError("Impute maxGap must be a positive safe integer.");
+  }
+  return transform;
+}
+
+export function normalizeImputeTransform(args = {}) {
+  const transform = {
+    type: "impute",
+    fields: normalizeFieldList(args.fields),
+    groupBy: normalizeFieldList(args.groupBy, { allowEmpty: true }),
+    sortBy: normalizeSortBy(args.sortBy),
+    method: args.method,
+    edges: args.edges ?? "keep"
+  };
+  if (Object.hasOwn(args, "value")) transform.value = args.value;
+  if (Object.hasOwn(args, "maxGap")) transform.maxGap = args.maxGap;
+  validateImputeTransform(transform);
+  return cloneAndFreeze(transform);
+}
+
+function compareScalar(left, right, label) {
+  const leftType = scalarType(left, label);
+  const rightType = scalarType(right, label);
+  if (leftType === undefined || rightType === undefined) {
+    if (leftType === rightType) return 0;
+    return leftType === undefined ? 1 : -1;
+  }
+  if (leftType !== rightType) throw new TypeError(`${label} must contain one scalar type.`);
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+function compareEntries(left, right, sortBy) {
+  for (const sort of sortBy) {
+    const comparison = compareScalar(
+      left.row[sort.field], right.row[sort.field], `Impute sort field "${sort.field}"`
+    );
+    if (comparison !== 0) return sort.order === "ascending" ? comparison : -comparison;
+  }
+  return left.index - right.index;
+}
+
+function validateRows(rows, transform) {
+  if (!Array.isArray(rows) || !rows.every(isPlainObject)) {
+    throw new TypeError("Impute source rows must be plain objects.");
+  }
+  const required = [...transform.fields, ...transform.groupBy,
+    ...transform.sortBy.map(sort => sort.field)];
+  rows.forEach((row, index) => {
+    for (const field of required) {
+      if (!Object.hasOwn(row, field)) {
+        throw new Error(`Impute source does not contain field "${field}" at row ${index}.`);
+      }
+    }
+    for (const field of transform.fields) {
+      scalarType(row[field], `Impute field "${field}" at row ${index}`);
+    }
+    for (const field of transform.groupBy) {
+      scalarKey(row[field], `Impute group field "${field}" at row ${index}`);
+    }
+    for (const sort of transform.sortBy) {
+      scalarType(row[sort.field], `Impute sort field "${sort.field}" at row ${index}`);
+    }
+  });
+}
+
+function partitions(entries, transform) {
+  const groups = new Map();
+  for (const entry of entries) {
+    const key = transform.groupBy.length === 0 ? "all" : transform.groupBy.map(field =>
+      scalarKey(entry.row[field], `Impute group field "${field}"`)
+    ).join("\0");
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(entry);
+  }
+  return [...groups.values()];
+}
+
+function validateFieldTypes(entries, transform) {
+  for (const field of transform.fields) {
+    const types = new Set(entries.flatMap(entry => {
+      const type = scalarType(entry.row[field], `Impute field "${field}"`);
+      return type === undefined ? [] : [type];
+    }));
+    const constantType = transform.method === "constant"
+      ? scalarType(transform.value, "Impute constant value")
+      : undefined;
+    if (constantType !== undefined) types.add(constantType);
+    if (types.size > 1) {
+      throw new TypeError(`Impute field "${field}" must contain one scalar type.`);
+    }
+    if (transform.method === "linear" &&
+      (types.size > 0 && !types.has("number"))) {
+      throw new TypeError(`Impute linear field "${field}" must contain finite numbers.`);
+    }
+  }
+}
+
+function validateSortFieldTypes(partition, transform) {
+  for (const sort of transform.sortBy) {
+    const types = new Set(partition.flatMap(entry => {
+      const type = scalarType(
+        entry.row[sort.field],
+        `Impute sort field "${sort.field}"`
+      );
+      return type === undefined ? [] : [type];
+    }));
+    if (types.size > 1) {
+      throw new TypeError(`Impute sort field "${sort.field}" must contain one scalar type.`);
+    }
+  }
+}
+
+function linearPositions(partition, transform) {
+  if (transform.method !== "linear") return undefined;
+  const field = transform.sortBy[0].field;
+  const types = new Set(partition.map((entry, index) =>
+    scalarType(entry.row[field], `Impute linear sort field "${field}" at row ${index}`)
+  ));
+  if (types.size !== 1 || types.has(undefined) ||
+    !["number", "string"].includes([...types][0])) {
+    throw new TypeError("Impute linear sort field must contain one numeric or temporal-string type.");
+  }
+  const type = [...types][0];
+  const positions = partition.map((entry, index) => type === "number"
+    ? entry.row[field]
+    : normalizeTemporalValue(entry.row[field], field, index, "auto")
+  );
+  for (let index = 1; index < positions.length; index += 1) {
+    if (positions[index] === positions[index - 1]) {
+      throw new Error("Impute linear sort positions must be unique.");
+    }
+  }
+  return positions;
+}
+
+function missingRuns(partition, field) {
+  const runs = [];
+  let start;
+  for (let index = 0; index <= partition.length; index += 1) {
+    const missing = index < partition.length &&
+      (partition[index].row[field] === null || partition[index].row[field] === undefined);
+    if (missing && start === undefined) start = index;
+    if (!missing && start !== undefined) {
+      runs.push([start, index - 1]);
+      start = undefined;
+    }
+  }
+  return runs;
+}
+
+function setField(row, field, value) {
+  Object.defineProperty(row, field, {
+    value, enumerable: true, writable: true, configurable: true
+  });
+}
+
+function fillRun(partition, field, run, transform, positions) {
+  const [start, end] = run;
+  const length = end - start + 1;
+  if (transform.maxGap !== undefined && length > transform.maxGap) return;
+  if (transform.method === "constant") {
+    for (let index = start; index <= end; index += 1) {
+      setField(partition[index].row, field, transform.value);
+    }
+    return;
+  }
+  const left = start - 1;
+  const right = end + 1;
+  const hasLeft = left >= 0;
+  const hasRight = right < partition.length;
+  const usable = transform.method === "forward" ? hasLeft
+    : transform.method === "backward" ? hasRight
+      : hasLeft && hasRight;
+  if (!usable) {
+    if (transform.edges === "error") {
+      throw new RangeError(`Impute ${transform.method} cannot fill an edge run in field "${field}".`);
+    }
+    return;
+  }
+  if (transform.method === "forward" || transform.method === "backward") {
+    const anchor = transform.method === "forward" ? left : right;
+    const value = partition[anchor].row[field];
+    for (let index = start; index <= end; index += 1) {
+      setField(partition[index].row, field, value);
+    }
+    return;
+  }
+  const leftValue = partition[left].row[field];
+  const rightValue = partition[right].row[field];
+  for (let index = start; index <= end; index += 1) {
+    const proportion = inverseLerp(positions[index], positions[left], positions[right]);
+    setField(
+      partition[index].row,
+      field,
+      interpolateNumber(leftValue, rightValue, proportion)
+    );
+  }
+}
+
+export function deriveImputedRows(rows, transform) {
+  validateImputeTransform(transform);
+  validateRows(rows, transform);
+  const entries = rows.map((row, index) => ({ index, row: { ...row } }));
+  validateFieldTypes(entries, transform);
+  const groups = partitions(entries, transform);
+  for (const partition of groups) {
+    validateSortFieldTypes(partition, transform);
+    partition.sort((left, right) => compareEntries(left, right, transform.sortBy));
+    const positions = linearPositions(partition, transform);
+    for (const field of transform.fields) {
+      for (const run of missingRuns(partition, field)) {
+        fillRun(partition, field, run, transform, positions);
+      }
+    }
+  }
+  return cloneAndFreeze(entries.sort((a, b) => a.index - b.index).map(entry => entry.row));
+}

package/src/grammar/interval.js

@@ -1,7 +1,10 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { aggregateScalarValues } from "./aggregate.js";
 import { requireFiniteResult, stableDecimal } from "./numeric.js";
-import { studentTCriticalValue } from "./statistics/studentT.js";
+import {
+  confidenceCriticalValue,
+  normalizeConfidenceInterval
+} from "./statistics/confidenceInterval.js";
 
 const CENTER_VALUES = ["mean", "median"];
 const EXTENT_VALUES = ["stderr", "stdev", "ci", "iqr"];
@@ -11,6 +14,7 @@ const TRANSFORM_KEYS = [
   "groupBy",
   "center",
   "extent",
+  "method",
   "level",
   "as"
 ];
@@ -84,13 +88,12 @@ export function validateIntervalTransform(transform) {
     throw new Error("Median intervals require iqr, and iqr requires median.");
   }
   if (transform.extent === "ci") {
-    if (
-      !Number.isFinite(transform.level) ||
-      transform.level <= 0 ||
-      transform.level >= 1
-    ) {
-      throw new RangeError("Interval CI level must be between 0 and 1.");
-    }
+    normalizeConfidenceInterval(transform, {
+      defaultMethod: "student-t",
+      label: "Interval CI"
+    });
+  } else if (transform.method !== undefined) {
+    throw new Error("Interval method is supported only for ci extent.");
   } else if (transform.level !== undefined) {
     throw new Error("Interval level is supported only for ci extent.");
   }
@@ -111,16 +114,27 @@ function normalizeGrouping(groupBy) {
 export function normalizeIntervalParameters({
   center = "mean",
   extent = "ci",
+  method,
   level
 } = {}) {
-  const resolvedLevel = extent === "ci" ? level ?? 0.95 : level;
+  const confidence = extent === "ci"
+    ? normalizeConfidenceInterval({ method, level }, {
+        defaultMethod: "student-t",
+        label: "Interval CI"
+      })
+    : undefined;
   const candidate = {
     type: "interval",
     field: "__interval_input",
     groupBy: [],
     center,
     extent,
-    ...(resolvedLevel === undefined ? {} : { level: resolvedLevel }),
+    ...(confidence === undefined
+      ? {
+          ...(method === undefined ? {} : { method }),
+          ...(level === undefined ? {} : { level })
+        }
+      : confidence),
     as: {
       center: "__interval_center",
       lower: "__interval_lower",
@@ -131,18 +145,16 @@ export function normalizeIntervalParameters({
   return cloneAndFreeze({
     center,
     extent,
-    ...(resolvedLevel === undefined ? {} : { level: resolvedLevel })
+    ...(confidence === undefined ? {} : confidence)
   });
 }
 
 export function studentTCritical(degreesOfFreedom, level) {
-  if (!Number.isInteger(degreesOfFreedom) || degreesOfFreedom < 1) {
-    throw new RangeError("Student-t degreesOfFreedom must be a positive integer.");
-  }
-  if (!Number.isFinite(level) || level <= 0 || level >= 1) {
-    throw new RangeError("Student-t level must be between 0 and 1.");
-  }
-  return studentTCriticalValue(level, degreesOfFreedom);
+  return confidenceCriticalValue({
+    method: "student-t",
+    level,
+    degreesOfFreedom
+  });
 }
 
 function isMissing(value) {
@@ -170,7 +182,11 @@ function deriveGroup(values, transform) {
     ? aggregateScalarValues(values, "stdev")
     : transform.extent === "stderr"
       ? aggregateScalarValues(values, "stderr")
-      : studentTCritical(values.length - 1, transform.level) *
+      : confidenceCriticalValue({
+          method: transform.method,
+          level: transform.level,
+          degreesOfFreedom: values.length - 1
+        }) *
         aggregateScalarValues(values, "stderr");
   return {
     center,
@@ -232,12 +248,13 @@ export function normalizeIntervalTransform({
   groupBy,
   center,
   extent,
+  method,
   level,
   as
 }) {
   nonEmptyString(field, "Interval field");
   const grouping = normalizeGrouping(groupBy);
-  const parameters = normalizeIntervalParameters({ center, extent, level });
+  const parameters = normalizeIntervalParameters({ center, extent, method, level });
   const transform = {
     type: "interval",
     field,

package/src/grammar/lineSeries.js

@@ -16,8 +16,9 @@ import {
   findHistogramBinIndex,
   resolveHistogramBins
 } from "./histogram.js";
-
-const SERIES_CHANNELS = ["group", "color", "strokeDash"];
+import {
+  validatePathSeriesAppearance
+} from "./pathSeries.js";
 
 function requireLineEncoding(layer) {
   if (layer?.mark?.type !== "line") {
@@ -70,32 +71,6 @@ function requireLineEncoding(layer) {
   };
 }
 
-function readSeriesFields(rows, layer) {
-  const fields = [];
-  const values = new Map();
-
-  for (const channel of SERIES_CHANNELS) {
-    const encoding = layer.encoding?.[channel];
-
-    if (encoding?.field === undefined) continue;
-    const categorical = channel === "color"
-      ? ["nominal", "ordinal"].includes(encoding.fieldType)
-      : encoding.fieldType === "nominal";
-    if (!categorical) {
-      throw new Error(
-        `Line ${channel} encoding on mark "${layer.id}" must be categorical.`
-      );
-    }
-
-    if (!values.has(encoding.field)) {
-      fields.push(encoding.field);
-      values.set(encoding.field, readNominalField(rows, encoding.field));
-    }
-  }
-
-  return { fields, values };
-}
-
 function groupKey(values) {
   return JSON.stringify(values);
 }
@@ -148,14 +123,14 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     validateAggregateFieldValues(rows, y.field, y.fieldType);
   }
   const xValues = x.fieldType === "temporal"
-    ? readTemporalField(rows, x.field)
+    ? readTemporalField(rows, x.field, x.temporalUnit)
     : readQuantitativeField(rows, x.field);
   const yValues = isAggregate
     ? undefined
     : y.fieldType === "temporal"
-      ? readTemporalField(rows, y.field)
+      ? readTemporalField(rows, y.field, y.temporalUnit)
       : readQuantitativeField(rows, y.field);
-  const seriesFields = readSeriesFields(rows, layer);
+  const seriesFields = validatePathSeriesAppearance(rows, layer);
   const binBoundaries = binnedAggregate
     ? options.xBinBoundaries ?? resolveLineBins(rows, layer).boundaries
     : undefined;
@@ -170,10 +145,10 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     const orderValues = readQuantitativeField(rows, pathOrder.field);
     const groups = new Map();
     for (let index = 0; index < rows.length; index += 1) {
-      const dimensions = seriesFields.fields.map(
-        field => seriesFields.values.get(field)[index]
+      const dimensions = seriesFields.map(
+        field => rows[index][field]
       );
-      const series = groupedSeries(groups, seriesFields.fields, dimensions);
+      const series = groupedSeries(groups, seriesFields, dimensions);
       series.values.push({ x: xValues[index], y: yValues[index] });
       series.orderValues ??= [];
       series.orderValues.push(orderValues[index]);
@@ -197,10 +172,10 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
   if (directRows) {
     const groups = new Map();
     for (let index = 0; index < rows.length; index += 1) {
-      const dimensions = seriesFields.fields.map(
-        field => seriesFields.values.get(field)[index]
+      const dimensions = seriesFields.map(
+        field => rows[index][field]
       );
-      const series = groupedSeries(groups, seriesFields.fields, dimensions);
+      const series = groupedSeries(groups, seriesFields, dimensions);
       series.values.push({ x: xValues[index], y: yValues[index] });
     }
     const orderBy = directTemporal && y.fieldType === "temporal" ? "y" : "x";
@@ -220,8 +195,8 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
   const aggregateGroups = new Map();
 
   for (let index = 0; index < rows.length; index += 1) {
-    const dimensions = seriesFields.fields.map(
-      field => seriesFields.values.get(field)[index]
+    const dimensions = seriesFields.map(
+      field => rows[index][field]
     );
     const binIndex = binnedAggregate
       ? findHistogramBinIndex(xValues[index], binBoundaries)
@@ -255,7 +230,7 @@ function deriveCartesianLineSeries(rows, layer, options = {}) {
     if (value === undefined) continue;
     const series = groupedSeries(
       seriesGroups,
-      seriesFields.fields,
+      seriesFields,
       group.dimensions
     );
 
@@ -315,7 +290,7 @@ function readThetaValues(rows, encoding) {
     return readNominalField(rows, encoding.field);
   }
   return encoding.fieldType === "temporal"
-    ? readTemporalField(rows, encoding.field)
+    ? readTemporalField(rows, encoding.field, encoding.temporalUnit)
     : readQuantitativeField(rows, encoding.field);
 }
 
@@ -341,14 +316,14 @@ export function derivePolarLineSeries(rows, layer, { thetaDomain } = {}) {
   const thetaValues = readThetaValues(rows, theta);
   const radiusValues = readQuantitativeField(rows, radius.field);
   const sortValues = thetaOrder(thetaValues, theta.fieldType, thetaDomain);
-  const seriesFields = readSeriesFields(rows, layer);
+  const seriesFields = validatePathSeriesAppearance(rows, layer);
   const groups = new Map();
 
   for (let index = 0; index < rows.length; index += 1) {
-    const dimensions = seriesFields.fields.map(
-      field => seriesFields.values.get(field)[index]
+    const dimensions = seriesFields.map(
+      field => rows[index][field]
     );
-    const series = groupedSeries(groups, seriesFields.fields, dimensions);
+    const series = groupedSeries(groups, seriesFields, dimensions);
     series.values.push({
       theta: thetaValues[index],
       radius: radiusValues[index],
@@ -384,21 +359,3 @@ export function deriveLineSeries(rows, layer, options) {
     ? derivePolarLineSeries(rows, layer, options)
     : deriveCartesianLineSeries(rows, layer, options);
 }
-
-export function deriveLineSeriesFieldValues(rows, layer, derived, field) {
-  const values = readQuantitativeField(rows, field);
-  if (values.some(value => value < 0)) {
-    throw new RangeError(`Line strokeWidth field "${field}" cannot contain negative values.`);
-  }
-  return cloneAndFreeze(derived.series.map(series => {
-    const matching = values.filter((_, index) => Object.entries(series.key)
-      .every(([key, value]) => rows[index]?.[key] === value));
-    const unique = [...new Set(matching)];
-    if (unique.length !== 1) {
-      throw new Error(
-        `Line strokeWidth field "${field}" must have one value within each series.`
-      );
-    }
-    return unique[0];
-  }));
-}

package/src/grammar/markFilter.js

@@ -1,7 +1,24 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
 import { normalizeMarkSelector } from "./markSelection.js";
 
-const TRANSFORM_KEYS = Object.freeze(["type", "target", "selector"]);
+const TRANSFORM_KEYS = Object.freeze([
+  "type", "target", "selector", "selectors"
+]);
+
+export function markFilterSelectors(transform) {
+  const hasSelector = Object.hasOwn(transform, "selector");
+  const hasSelectors = Object.hasOwn(transform, "selectors");
+  if (hasSelector === hasSelectors) {
+    throw new Error(
+      "Mark filter transform requires exactly one of selector or selectors."
+    );
+  }
+  const selectors = hasSelector ? [transform.selector] : transform.selectors;
+  if (!Array.isArray(selectors) || selectors.length === 0) {
+    throw new TypeError("Mark filter selectors must be a non-empty array.");
+  }
+  return cloneAndFreeze(selectors.map(normalizeMarkSelector));
+}
 
 export function validateMarkFilterTransform(transform) {
   if (!isPlainObject(transform)) {
@@ -19,14 +36,15 @@ export function validateMarkFilterTransform(transform) {
   if (typeof transform.target !== "string" || transform.target.length === 0) {
     throw new TypeError("Mark filter target must be a non-empty string.");
   }
-  normalizeMarkSelector(transform.selector);
+  markFilterSelectors(transform);
 }
 
-export function normalizeMarkFilterTransform(target, selector) {
+export function normalizeMarkFilterTransform(target, selectors) {
   const transform = {
     type: "markFilter",
     target,
-    selector: normalizeMarkSelector(selector)
+    selectors: (Array.isArray(selectors) ? selectors : [selectors])
+      .map(normalizeMarkSelector)
   };
   validateMarkFilterTransform(transform);
   return cloneAndFreeze(transform);