@bicharts/chart-host 0.6.56 → 0.6.59

package/dist/chunk-XIAL6EEC.mjs

@@ -0,0 +1,598 @@
+/*! @bicharts/chart-host — Apache-2.0. Bundled reference data: GeoNames (https://www.geonames.org/) CC BY 4.0; Natural Earth and US Census/TIGER (public domain). Full text: NOTICE in this package. */
+
+// src/filterScope.ts
+function viewToken(view) {
+  const bytes = new TextEncoder().encode(JSON.stringify(view));
+  let bin = "";
+  bytes.forEach((b) => {
+    bin += String.fromCharCode(b);
+  });
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function viewFromToken(token) {
+  if (!token) return null;
+  try {
+    const b64 = token.replace(/-/g, "+").replace(/_/g, "/") + "===".slice((token.length + 3) % 4);
+    const bin = atob(b64);
+    const bytes = Uint8Array.from(bin, (ch) => ch.charCodeAt(0));
+    const v = JSON.parse(new TextDecoder().decode(bytes));
+    return v && v.v === 1 ? v : null;
+  } catch {
+    return null;
+  }
+}
+function keyString(values) {
+  return JSON.stringify(values.map((v) => v instanceof Date ? `__date:${v.getTime()}` : v === void 0 ? null : v));
+}
+function keyOfRow(row, columns) {
+  return columns.map((c) => row?.[c]);
+}
+function toKeys(input, width) {
+  if (input == null) return [];
+  if (!Array.isArray(input)) return width === 1 ? [[input]] : [];
+  if (input.length === 0) return [];
+  if (width === 1) return input.map((v) => Array.isArray(v) ? [v[0]] : [v]);
+  if (input.every((v) => Array.isArray(v))) return input.map((v) => v.slice(0, width));
+  return input.length === width ? [input.slice()] : [];
+}
+var nextId = 0;
+function createFilter(columns, opts = {}) {
+  const cols = Array.isArray(columns) ? columns.slice() : [columns];
+  if (!cols.length || cols.some((c) => typeof c !== "string" || !c)) {
+    throw new Error('createFilter: name the key column(s), e.g. createFilter("RegionCode")');
+  }
+  const display = opts.display == null ? cols : Array.isArray(opts.display) ? opts.display.slice() : [opts.display];
+  let keys = [];
+  let keySet = /* @__PURE__ */ new Set();
+  let rows = [];
+  let reason = null;
+  let version = 0;
+  const subs = /* @__PURE__ */ new Set();
+  let hovered = null;
+  const hoverSubs = /* @__PURE__ */ new Set();
+  const kept = /* @__PURE__ */ new WeakMap();
+  const commit = (nextKeys, nextRows, why) => {
+    const nextSet = new Set(nextKeys.map(keyString));
+    if (nextSet.size === keySet.size && [...nextSet].every((k) => keySet.has(k))) {
+      if (nextRows.length) rows = nextRows;
+      return;
+    }
+    keys = nextKeys;
+    keySet = nextSet;
+    rows = nextRows;
+    reason = why;
+    version++;
+    for (const cb of Array.from(subs)) cb(filter, why);
+  };
+  const dedupe = (ks) => {
+    const seen2 = /* @__PURE__ */ new Set();
+    return ks.filter((k) => {
+      const s = keyString(k);
+      if (seen2.has(s)) return false;
+      seen2.add(s);
+      return true;
+    });
+  };
+  const seen = /* @__PURE__ */ new Map();
+  const remember = (list) => {
+    for (const r of list) seen.set(keyString(keyOfRow(r, cols)), r);
+  };
+  const displayOf = (k, more) => {
+    const s = keyString(k);
+    const row = (more ?? []).find((r) => keyString(keyOfRow(r, cols)) === s) ?? seen.get(s);
+    const parts = row ? display.map((d) => row[d]) : k;
+    const text = parts.filter((p) => p != null && p !== "").map(String).join(" \u2192 ");
+    return text || k.filter((p) => p != null && p !== "").map(String).join(" \u2192 ");
+  };
+  let warnedKeep = false;
+  const filter = {
+    id: opts.id ?? `f${++nextId}`,
+    key: opts.key ?? cols.join("+"),
+    hoverEnabled: !!opts.hover,
+    get hovered() {
+      return hovered;
+    },
+    setHover(k) {
+      const next = k && k.length ? k.slice(0, cols.length) : null;
+      if ((next ? keyString(next) : null) === (hovered ? keyString(hovered) : null)) return;
+      hovered = next;
+      for (const cb of Array.from(hoverSubs)) cb(hovered);
+    },
+    onHover(cb) {
+      hoverSubs.add(cb);
+      return () => {
+        hoverSubs.delete(cb);
+      };
+    },
+    columns: cols,
+    label: opts.label ?? cols.join(" / "),
+    get active() {
+      return keys.length > 0;
+    },
+    get keys() {
+      return keys;
+    },
+    get rows() {
+      return rows;
+    },
+    get row() {
+      return rows[0] ?? null;
+    },
+    get value() {
+      return keys.length ? keys[0][0] : null;
+    },
+    get values() {
+      return keys.map((k) => k[0]);
+    },
+    get text() {
+      return keys.map((k) => displayOf(k)).join(", ");
+    },
+    textOf(key, more) {
+      const k = Array.isArray(key) ? key : [key];
+      return displayOf(k.slice(0, cols.length), more);
+    },
+    get reason() {
+      return reason;
+    },
+    get version() {
+      return version;
+    },
+    selectRows(selected, why = "page") {
+      const list = (selected ?? []).filter((r) => r && typeof r === "object");
+      remember(list);
+      commit(dedupe(list.map((r) => keyOfRow(r, cols))), list, why);
+    },
+    set(input, why = "page") {
+      const ks = dedupe(toKeys(input, cols.length));
+      const want = new Set(ks.map(keyString));
+      commit(ks, rows.filter((r) => want.has(keyString(keyOfRow(r, cols)))), why);
+    },
+    clear(why = "page") {
+      commit([], [], why);
+    },
+    has(row, on) {
+      if (!keys.length || !row) return false;
+      const where = on && on.length ? on : cols;
+      if (cols.length === 1 && where.length > 1) {
+        return where.some((c) => keySet.has(keyString([row[c]])));
+      }
+      return keySet.has(keyString(keyOfRow(row, where)));
+    },
+    keep(input, on) {
+      const list = input ?? [];
+      const colKey = (on ?? cols).join("
");
+      const hit = kept.get(list);
+      if (hit && hit.version === version && hit.cols === colKey) return hit.out;
+      const where = on && on.length ? on : cols;
+      if (keys.length && list.length && !warnedKeep && !list.some((r) => r && where.some((c) => c in r))) {
+        warnedKeep = true;
+        try {
+          console.warn(`[chart-host] filter "${filter.label}": these rows have no ${where.join(" / ")} column, so keep() drops them all - filter their query (filterQuery + treatAs) or add the key column.`);
+        } catch {
+        }
+      }
+      const out = keys.length ? list.filter((r) => filter.has(r, on)) : list.slice();
+      kept.set(list, { version, cols: colKey, out });
+      return out;
+    },
+    onChange(cb) {
+      subs.add(cb);
+      return () => {
+        subs.delete(cb);
+      };
+    }
+  };
+  return filter;
+}
+function createFilterScope() {
+  const list = [];
+  const offs = /* @__PURE__ */ new Map();
+  const ctl = /* @__PURE__ */ new Map();
+  const ctlOffs = /* @__PURE__ */ new Map();
+  const subs = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const cb of Array.from(subs)) cb(scope);
+  };
+  const scope = {
+    get filters() {
+      return list.slice();
+    },
+    get active() {
+      return list.filter((f) => f.active);
+    },
+    filter(columns, opts) {
+      const f = createFilter(columns, opts);
+      scope.add(f);
+      return f;
+    },
+    add(f) {
+      if (!offs.has(f)) {
+        list.push(f);
+        offs.set(f, f.onChange(() => notify()));
+        notify();
+      }
+      return () => {
+        const off = offs.get(f);
+        if (!off) return;
+        off();
+        offs.delete(f);
+        const i = list.indexOf(f);
+        if (i >= 0) list.splice(i, 1);
+        notify();
+      };
+    },
+    clearAll(why = "page") {
+      for (const f of list.slice()) f.clear(why);
+    },
+    onChange(cb) {
+      subs.add(cb);
+      return () => {
+        subs.delete(cb);
+      };
+    },
+    get controls() {
+      return ctl;
+    },
+    addControls(key, c) {
+      let k = key, n = 1;
+      while (ctl.has(k) && ctl.get(k) !== c) k = `${key}-${++n}`;
+      if (!ctl.has(k)) {
+        ctl.set(k, c);
+        ctlOffs.set(k, c.onChange(() => notify()));
+        notify();
+      }
+      return () => {
+        if (ctl.get(k) !== c) return;
+        ctlOffs.get(k)?.();
+        ctlOffs.delete(k);
+        ctl.delete(k);
+        notify();
+      };
+    },
+    save() {
+      const view = { v: 1 };
+      for (const f of list) if (f.active) (view.filters ??= {})[f.key] = f.keys.map((k) => k.slice());
+      for (const [k, c] of ctl) {
+        const values = c.values;
+        if (Object.keys(values).length) (view.controls ??= {})[k] = { ...values };
+      }
+      return view;
+    },
+    restore(view) {
+      if (!view || view.v !== 1) return;
+      for (const f of list) {
+        const keys = view.filters?.[f.key];
+        if (keys && keys.length) f.set(keys, "page");
+        else f.clear("page");
+      }
+      for (const [k, c] of ctl) {
+        const values = view.controls?.[k];
+        if (values) c.set(values);
+      }
+    }
+  };
+  return scope;
+}
+var LINKED_HOVER_CLASS = "bic-linked-hover";
+var hoverStyled = false;
+function ensureHoverStyle(doc) {
+  if (hoverStyled || !doc?.head) return;
+  hoverStyled = true;
+  const s = doc.createElement("style");
+  s.setAttribute("data-bic", "linked-hover");
+  s.textContent = `.${LINKED_HOVER_CLASS}{filter:drop-shadow(0 0 2px var(--bic-linked-hover,rgba(0,0,0,.65))) drop-shadow(0 0 1px var(--bic-linked-hover,rgba(0,0,0,.65)))}`;
+  doc.head.appendChild(s);
+}
+function payloadRowReader(getPayload) {
+  return {
+    rowAt(i) {
+      const p = getPayload();
+      const r = p?.rows?.[i];
+      if (!p || !r) return null;
+      const o = {};
+      p.columns.forEach((c, k) => {
+        o[c.name] = r[k];
+      });
+      return o;
+    },
+    rowCount() {
+      return getPayload()?.rows?.length ?? 0;
+    }
+  };
+}
+var sortedEq = (a, b) => {
+  if (a.length !== b.length) return false;
+  const x = a.slice().sort((p, q) => p - q), y = b.slice().sort((p, q) => p - q);
+  return x.every((v, i) => v === y[i]);
+};
+function bindFilter(host, filter, opts) {
+  const token = {};
+  const ownerKeys = () => keysString(filter.keys);
+  const isMine = () => {
+    const o = owners.get(filter);
+    return !!o && o.token === token && o.keys === ownerKeys();
+  };
+  {
+    const o = owners.get(filter);
+    if (o && o.orphan && o.keys === ownerKeys()) owners.set(filter, { token, keys: o.keys, orphan: false });
+  }
+  const wanted = () => {
+    if (!filter.active) return [];
+    const out = [];
+    const n = opts.rowCount();
+    for (let i = 0; i < n; i++) {
+      const r = opts.rowAt(i);
+      if (r && filter.has(r)) out.push(i);
+    }
+    return out;
+  };
+  const paint = () => {
+    const want = wanted();
+    const cur = host.selection.current ?? [];
+    if (sortedEq(want, cur)) return;
+    if (want.length) host.selection.highlight(want);
+    else if (cur.length) host.selection.clear();
+  };
+  const offHost = host.selection.onChange((idxs, source) => {
+    if (source === "host") return;
+    if (!idxs.length) {
+      if (filter.active) filter.clear("clear");
+      return;
+    }
+    const rows = idxs.map((i) => opts.rowAt(i)).filter((r) => !!r);
+    if (!rows.length) return;
+    filter.selectRows(rows, "click");
+    owners.set(filter, { token, keys: ownerKeys(), orphan: false });
+  });
+  const offFilter = filter.onChange(() => {
+    const o = owners.get(filter);
+    if (o && o.keys !== ownerKeys()) owners.delete(filter);
+    paint();
+  });
+  const el = opts.container ?? null;
+  let offHoverDom = () => {
+  };
+  let offHover = () => {
+  };
+  if (filter.hoverEnabled && el) {
+    ensureHoverStyle(el.ownerDocument);
+    const markRow = (t) => {
+      const m = t?.closest?.(".d3-mark[data-row-idx]");
+      const v = m ? parseInt((m.getAttribute("data-row-idx") ?? "").split(",")[0], 10) : NaN;
+      return Number.isFinite(v) ? v : null;
+    };
+    const over = (e) => {
+      const i = markRow(e.target);
+      const r = i === null ? null : opts.rowAt(i);
+      if (r) filter.setHover(keyOfRow(r, filter.columns));
+    };
+    const leave = () => filter.setHover(null);
+    el.addEventListener("mouseover", over);
+    el.addEventListener("mouseleave", leave);
+    offHoverDom = () => {
+      el.removeEventListener("mouseover", over);
+      el.removeEventListener("mouseleave", leave);
+    };
+    const paintHover = (k) => {
+      const want = k ? keyString(k) : null;
+      el.querySelectorAll(".d3-mark[data-row-idx]").forEach((m) => {
+        const idx = parseInt((m.getAttribute("data-row-idx") ?? "").split(",")[0], 10);
+        const r = Number.isFinite(idx) ? opts.rowAt(idx) : null;
+        const on = !!want && !!r && keyString(keyOfRow(r, filter.columns)) === want;
+        m.classList.toggle(LINKED_HOVER_CLASS, on);
+      });
+    };
+    offHover = filter.onHover(paintHover);
+  }
+  return {
+    reconcile() {
+      if (filter.active && opts.rowCount() > 0 && isMine()) {
+        const drawn = /* @__PURE__ */ new Set();
+        const n = opts.rowCount();
+        for (let i = 0; i < n; i++) {
+          const r = opts.rowAt(i);
+          if (r) drawn.add(keyString(keyOfRow(r, filter.columns)));
+        }
+        const keep = filter.keys.filter((k) => drawn.has(keyString(k)));
+        if (keep.length !== filter.keys.length) {
+          filter.set(keep, "data");
+          return;
+        }
+      }
+      paint();
+    },
+    paint,
+    detach() {
+      offHost();
+      offFilter();
+      offHoverDom();
+      offHover();
+      const o = owners.get(filter);
+      if (o && o.token === token) owners.set(filter, { ...o, orphan: true });
+    }
+  };
+}
+var owners = /* @__PURE__ */ new WeakMap();
+var keysString = (keys) => keys.map((k) => keyString(k)).sort().join("|");
+function fromVegaInteraction(filter, events) {
+  const before = filter.version;
+  for (const ev of events ?? []) {
+    if (ev?.action === "clear") {
+      filter.clear("clear");
+      continue;
+    }
+    if (ev?.action !== "select") continue;
+    const keys = [];
+    for (const sel of ev.selections ?? []) {
+      const preds = sel?.predicates ?? [];
+      const key = filter.columns.map((c) => {
+        const p = preds.find((q) => q?.name === c && (q.type === void 0 || q.type === "set"));
+        return p && p.values && p.values.length ? p.values[0] : void 0;
+      });
+      if (key.every((v) => v !== void 0)) keys.push(key);
+    }
+    if (keys.length) filter.set(keys, "click");
+  }
+  return filter.version !== before;
+}
+
+// src/controls.ts
+var same = (a, b) => a.length === b.length && a.every((x, i) => x.key === b[i].key && x.label === b[i].label && x.text === b[i].text && JSON.stringify(x.value) === JSON.stringify(b[i].value));
+function createControls(initial) {
+  const ui = initial ? { knobs: { ...initial } } : {};
+  let info = [];
+  let version = 0;
+  const subs = /* @__PURE__ */ new Set();
+  const appliers = /* @__PURE__ */ new Set();
+  const notify = () => {
+    version++;
+    for (const cb of Array.from(subs)) cb(c);
+  };
+  const c = {
+    get values() {
+      const out = {};
+      for (const i of info) out[i.key] = i.value;
+      if (!info.length && ui.knobs && typeof ui.knobs === "object") Object.assign(out, ui.knobs);
+      return out;
+    },
+    get info() {
+      return info;
+    },
+    get summary() {
+      return info.map((i) => [i.label, i.text].filter(Boolean).join(" ")).filter(Boolean).join(" \xB7 ");
+    },
+    get ready() {
+      return info.length > 0;
+    },
+    get version() {
+      return version;
+    },
+    set(values) {
+      const knobs = { ...ui.knobs ?? {}, ...values };
+      ui.knobs = knobs;
+      for (const a of Array.from(appliers)) a();
+    },
+    reset() {
+      delete ui.knobs;
+      for (const a of Array.from(appliers)) a();
+    },
+    onChange(cb) {
+      subs.add(cb);
+      return () => {
+        subs.delete(cb);
+      };
+    },
+    _ui: ui,
+    _attach(onApply) {
+      appliers.add(onApply);
+      return () => {
+        appliers.delete(onApply);
+      };
+    },
+    _report(next) {
+      if (same(info, next)) return;
+      info = next;
+      notify();
+    }
+  };
+  return c;
+}
+function readControls(container) {
+  const bag = container.__lchKnobs;
+  if (!bag || typeof bag !== "object") return [];
+  const keys = Object.keys(bag);
+  if (!keys.length) return [];
+  const groups = Array.from(container.querySelectorAll("g.llm-slider"));
+  return keys.map((key, i) => {
+    const g = groups.find((x) => x.getAttribute("data-knob") === key) ?? groups[i] ?? null;
+    const txt = (sel) => (g?.querySelector(sel)?.textContent ?? "").trim();
+    return { key, value: bag[key], label: txt(".llm-slider-label"), text: txt(".llm-slider-readout") };
+  });
+}
+function attachControls(getHost, container, controls) {
+  const c = controls;
+  const read = () => c._report(readControls(container));
+  const setUiState = (s) => {
+    if (!s || typeof s !== "object") return;
+    for (const k of Object.keys(c._ui)) delete c._ui[k];
+    Object.assign(c._ui, s);
+    Promise.resolve().then(read);
+  };
+  const off = c._attach(() => {
+    const host = getHost();
+    if (!host) return;
+    host.setOptions({ uiState: c._ui });
+    host.rendered.then(read, () => {
+    });
+  });
+  return {
+    options: { uiState: c._ui, setUiState },
+    read,
+    detach: off
+  };
+}
+
+// src/markNotes.ts
+var keyText = (k) => JSON.stringify(k.map((v) => v == null ? "" : String(v).trim()));
+function defaultKey(n, width) {
+  return width > 1 ? [n.markKey, n.markKeyTo] : [n.markKey];
+}
+function noteBadges(notes, opts) {
+  const cols = typeof opts.columns === "string" ? [opts.columns] : opts.columns.slice();
+  const keyOf = opts.keyOf ?? ((n) => defaultKey(n, cols.length));
+  const textOf = opts.textOf ?? ((n) => String(n.body ?? ""));
+  const byKey = /* @__PURE__ */ new Map();
+  for (const n of notes ?? []) {
+    if (opts.chart !== void 0 && n.chart !== opts.chart) continue;
+    const key = keyOf(n).slice(0, cols.length);
+    if (key.length < cols.length || key.some((v) => v == null || v === "")) continue;
+    const id = keyText(key);
+    const hit = byKey.get(id);
+    if (hit) hit.list.push(n);
+    else byKey.set(id, { key, list: [n] });
+  }
+  return [...byKey.entries()].map(([id, { key, list }]) => {
+    const title = list.length > 1 ? `${textOf(list[0])} (+${list.length - 1} more)` : textOf(list[0]);
+    const base = { id, label: String(list.length), title };
+    if (cols.length === 1) return { ...base, column: cols[0], value: key[0] };
+    const where = {};
+    cols.forEach((c, i) => {
+      where[c] = key[i];
+    });
+    return { ...base, where };
+  });
+}
+function badgeKey(a) {
+  try {
+    const v = JSON.parse(String(a.id ?? ""));
+    if (Array.isArray(v)) return v;
+  } catch {
+  }
+  if (a.where) return Object.values(a.where);
+  return a.value !== void 0 ? [a.value] : [];
+}
+function notesFor(notes, key, opts) {
+  const cols = typeof opts.columns === "string" ? [opts.columns] : opts.columns.slice();
+  const want = !key ? null : Array.isArray(key) ? key : key.keys[0] ?? null;
+  if (!want) return [];
+  const keyOf = opts.keyOf ?? ((n) => defaultKey(n, cols.length));
+  const target = keyText(want.slice(0, cols.length));
+  return (notes ?? []).filter((n) => (opts.chart === void 0 || n.chart === opts.chart) && keyText(keyOf(n).slice(0, cols.length)) === target);
+}
+
+export {
+  viewToken,
+  viewFromToken,
+  createFilter,
+  createFilterScope,
+  LINKED_HOVER_CLASS,
+  payloadRowReader,
+  bindFilter,
+  fromVegaInteraction,
+  createControls,
+  readControls,
+  attachControls,
+  noteBadges,
+  badgeKey,
+  notesFor
+};

package/dist/dax.mjs

@@ -0,0 +1,60 @@
+/*! @bicharts/chart-host — Apache-2.0. Bundled reference data: GeoNames (https://www.geonames.org/) CC BY 4.0; Natural Earth and US Census/TIGER (public domain). Full text: NOTICE in this package. */
+import "./chunk-GHODWOAL.mjs";
+
+// src/dax.ts
+var COLUMN_REF = /^(?:'(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_]*)\[[^\]]+\]$/;
+function daxLiteral(v) {
+  if (v == null) return "BLANK()";
+  if (typeof v === "boolean") return v ? "TRUE()" : "FALSE()";
+  if (typeof v === "number") {
+    if (!Number.isFinite(v)) throw new Error(`daxLiteral: ${v} has no DAX literal`);
+    return String(v);
+  }
+  if (typeof v === "bigint") return v.toString();
+  if (v instanceof Date) {
+    if (Number.isNaN(v.getTime())) throw new Error("daxLiteral: an invalid Date");
+    return `DATE(${v.getFullYear()}, ${v.getMonth() + 1}, ${v.getDate()})` + (v.getHours() || v.getMinutes() || v.getSeconds() ? ` + TIME(${v.getHours()}, ${v.getMinutes()}, ${v.getSeconds()})` : "");
+  }
+  return `"${String(v).replace(/"/g, '""')}"`;
+}
+function treatAs(selection, ...columnRefs) {
+  if (!columnRefs.length) throw new Error(`treatAs: name the model column, e.g. treatAs(region, "'Geography'[RegionCode]")`);
+  for (const c of columnRefs) {
+    if (!COLUMN_REF.test(c.trim())) throw new Error(`treatAs: "${c}" isn't a column reference like 'Table'[Column]`);
+  }
+  const keys = !selection ? [] : isFilter(selection) ? selection.keys.slice() : selection.map((k) => Array.isArray(k) ? k : [k]);
+  if (!keys.length) return null;
+  const width = columnRefs.length;
+  for (const k of keys) {
+    if (k.length < width) throw new Error(`treatAs: a key has ${k.length} value(s) for ${width} column(s)`);
+  }
+  const rows = keys.map((k) => width === 1 ? daxLiteral(k[0]) : `(${k.slice(0, width).map(daxLiteral).join(", ")})`);
+  return `TREATAS({${rows.join(", ")}}, ${columnRefs.map((c) => c.trim()).join(", ")})`;
+}
+function calculateTable(table, ...filters) {
+  const live = filters.filter((f) => typeof f === "string" && f.trim().length > 0);
+  return live.length ? `CALCULATETABLE(
+${table},
+${live.join(",\n")}
+)` : table;
+}
+function filterQuery(query, ...filters) {
+  const live = filters.filter((f) => typeof f === "string" && f.trim().length > 0);
+  if (!live.length) return query;
+  const evals = query.match(/\bEVALUATE\b/gi) ?? [];
+  if (evals.length !== 1) throw new Error(`filterQuery: expected one EVALUATE, found ${evals.length}`);
+  const m = /^([\s\S]*?\bEVALUATE\b)([\s\S]*?)(\bORDER\s+BY\b[\s\S]*)?$/i.exec(query);
+  const head = m[1], table = m[2].trim(), tail = m[3] ?? "";
+  return `${head}
+${calculateTable(table, ...live)}
+${tail}`.replace(/\n$/, "");
+}
+function isFilter(x) {
+  return !!x && typeof x === "object" && Array.isArray(x.keys) && typeof x.has === "function";
+}
+export {
+  calculateTable,
+  daxLiteral,
+  filterQuery,
+  treatAs
+};

package/dist/geo.mjs

@@ -7,12 +7,12 @@ import {
 import {
   WORLD_110M
 } from "./chunk-ABGDJ3NJ.mjs";
-import {
-  US_ZIP3
-} from "./chunk-D3N3JUMK.mjs";
 import {
   US_STATES
 } from "./chunk-75ZJSYIF.mjs";
+import {
+  US_ZIP3
+} from "./chunk-D3N3JUMK.mjs";
 import "./chunk-GHODWOAL.mjs";
 
 // src/geo.ts