@ai-matrx/records-ui 0.93.69 → 0.93.72

package/dist/table-shape.js

@@ -0,0 +1,554 @@
+"use client";
+
+// src/kindValues.ts
+import { tryDecodeDirective } from "@ai-matrx/content-ir/directives";
+var KIND_KEY = "__kind";
+var WHOLE_FENCE = /^\s*```(?:matrx|json)?[ \t]*\r?\n?([\s\S]*?)\r?\n?[ \t]*```\s*$/;
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function parseJsonObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return null;
+  try {
+    return asObject(JSON.parse(trimmed));
+  } catch {
+    return null;
+  }
+}
+function fromObject(obj) {
+  const directive = tryDecodeDirective(obj);
+  if (directive) return { value: obj, kind: directive.slug, directive: true, items: [...directive.items] };
+  const named = obj[KIND_KEY];
+  if (typeof named === "string" && named.trim() !== "") {
+    const items = Array.isArray(obj.items) ? obj.items.filter((i) => asObject(i) !== null) : [];
+    return { value: obj, kind: named.trim(), directive: false, items };
+  }
+  return null;
+}
+function kindValueOf(value) {
+  const obj = asObject(value);
+  if (obj) return fromObject(obj);
+  if (typeof value !== "string" || value.length > 2e5) return null;
+  const fenced = WHOLE_FENCE.exec(value);
+  const parsed = parseJsonObject(fenced ? fenced[1] : value);
+  return parsed ? fromObject(parsed) : null;
+}
+
+// src/names.ts
+function humanize(token) {
+  const words = token.replace(/[_\-.]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim();
+  if (words === "") return token;
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+// src/tableShape.ts
+var FEWEST_LIST_ITEMS = 2;
+var FEWEST_KEY_VALUE_PAIRS = 2;
+var LONGEST_TEXT_READ = 2e6;
+function cellWords(raw) {
+  return raw.replace(/<br\s*\/?>/gi, "\n").replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\(([^)]*)\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/(^|[^\w*])\*([^*\n]+)\*(?=[^\w*]|$)/g, "$1$2").replace(/(^|[^\w_])_([^_\n]+)_(?=[^\w_]|$)/g, "$1$2").replace(/~~([^~]+)~~/g, "$1").replace(/`([^`]*)`/g, "$1").replace(/\\\|/g, "|").trim();
+}
+function uniqueLabels(raw) {
+  const seen = /* @__PURE__ */ new Map();
+  return raw.map((label, index) => {
+    const base = label.trim() || `Column ${index + 1}`;
+    const key = base.toLowerCase();
+    const count = (seen.get(key) ?? 0) + 1;
+    seen.set(key, count);
+    return count === 1 ? base : `${base} ${count}`;
+  });
+}
+function rowsOf(headers, matrix) {
+  return matrix.filter((cells) => cells.some((c) => c.trim() !== "")).map((cells) => {
+    const row = {};
+    headers.forEach((h, i) => {
+      row[h] = (cells[i] ?? "").trim();
+    });
+    return row;
+  });
+}
+function plural(n, one, many) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function sizeWords(rows, columns) {
+  return `${plural(rows, "row", "rows")} and ${plural(columns, "column", "columns")}`;
+}
+var HEADING = /^\s{0,3}#{1,6}\s+(.+?)\s*#*\s*$/;
+var BOLD_LINE = /^\s*\*\*([^*]+)\*\*:?\s*$/;
+var LEAD_IN = /^\s*([^|\-*+#>`].{1,80}?):\s*$/;
+function nameAbove(lines, lineIndex) {
+  let looked = 0;
+  for (let i = lineIndex - 1; i >= 0 && looked < 4; i -= 1) {
+    const line = lines[i] ?? "";
+    if (line.trim() === "") continue;
+    looked += 1;
+    const m = HEADING.exec(line) ?? (looked === 1 ? BOLD_LINE.exec(line) ?? LEAD_IN.exec(line) : null);
+    if (m) return cellWords(m[1]).replace(/:$/, "").trim() || null;
+  }
+  return null;
+}
+var SEPARATOR = /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/;
+function splitPipes(line) {
+  let text = line.trim();
+  if (text.startsWith("|")) text = text.slice(1);
+  if (text.endsWith("|") && !text.endsWith("\\|")) text = text.slice(0, -1);
+  const cells = [];
+  let cell = "";
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (ch === "\\" && text[i + 1] === "|") {
+      cell += "\\|";
+      i += 1;
+    } else if (ch === "|") {
+      cells.push(cell);
+      cell = "";
+    } else cell += ch;
+  }
+  cells.push(cell);
+  return cells.map(cellWords);
+}
+var LIST_ITEM = /^(\s*)(?:[-*+•]|\d{1,3}[.)])\s+(?:\[[ xX]\]\s+)?(.*)$/;
+var KEY_VALUE = /^\s*(?:\*\*|__)?([^:*_|]{1,40}?)(?::(?:\*\*|__)|(?:\*\*|__):|:)\s+(.+)$/;
+function keyValueOf(text) {
+  const m = KEY_VALUE.exec(text);
+  if (!m) return null;
+  const key = cellWords(m[1]);
+  const value = cellWords(m[2]);
+  if (!key || !value) return null;
+  if (key.split(/\s+/).length > 5 || /^\d+$/.test(key) || /https?$/i.test(key)) return null;
+  return { key, value };
+}
+function recordsFromPairs(pairs) {
+  const records = [];
+  let current = /* @__PURE__ */ new Map();
+  const first = pairs[0]?.key.toLowerCase();
+  for (const pair of pairs) {
+    const k = pair.key.toLowerCase();
+    if (current.size > 0 && (k === first || [...current.keys()].some((c) => c.toLowerCase() === k))) {
+      records.push(current);
+      current = /* @__PURE__ */ new Map();
+    }
+    current.set(pair.key, pair.value);
+  }
+  if (current.size > 0) records.push(current);
+  return records;
+}
+function shapeFromRecords(records, base, from) {
+  const order = [];
+  for (const r of records) for (const k of r.keys()) if (!order.some((o) => o.toLowerCase() === k.toLowerCase())) order.push(k);
+  const headers = uniqueLabels(order);
+  const rows = records.map((r) => {
+    const row = {};
+    order.forEach((k, i) => {
+      const hit = [...r.entries()].find(([rk]) => rk.toLowerCase() === k.toLowerCase());
+      row[headers[i]] = hit ? hit[1] : "";
+    });
+    return row;
+  });
+  return {
+    ...base,
+    kind: "key_value",
+    headers,
+    rows,
+    splits: [],
+    said: rows.length === 1 ? `One record with ${plural(headers.length, "value", "values")} from ${from}` : `${sizeWords(rows.length, headers.length)} from ${from}`
+  };
+}
+var SPLITS = [
+  { delimiter: " \u2014 ", label: "Split at the dash" },
+  { delimiter: " \u2013 ", label: "Split at the dash" },
+  { delimiter: " - ", label: "Split at the hyphen" },
+  { delimiter: ": ", label: "Split at the colon" },
+  { delimiter: " | ", label: "Split at the bar" },
+  { delimiter: "	", label: "Split at the tab" },
+  { delimiter: ", ", label: "Split at each comma" }
+];
+function listSplits(items) {
+  const out = [];
+  for (const { delimiter, label } of SPLITS) {
+    if (!items.every((t) => t.includes(delimiter))) continue;
+    if (out.some((s) => s.label === label)) continue;
+    const every = delimiter === ", ";
+    const parts = items.map((t) => every ? t.split(delimiter) : [t.slice(0, t.indexOf(delimiter)), t.slice(t.indexOf(delimiter) + delimiter.length)]);
+    const width = Math.max(...parts.map((p) => p.length));
+    const headers = uniqueLabels(width === 2 ? ["Item", "Detail"] : Array.from({ length: width }, (_, i) => i === 0 ? "Item" : `Detail ${i}`));
+    out.push({ delimiter, label, headers, rows: rowsOf(headers, parts.map((p) => p.map((c) => cellWords(c)))) });
+  }
+  return out;
+}
+function shapeFromList(items, name, at) {
+  const top = items.filter((i) => i.depth === 0);
+  if (top.length === 0) return null;
+  const withChildren = top.filter((i) => i.children.length > 0);
+  if (withChildren.length === top.length && top.length >= 1) {
+    const childPairs = top.map((i) => i.children.map(keyValueOf));
+    if (childPairs.every((ps) => ps.length > 0 && ps.every((p) => p !== null))) {
+      const lead = "Name";
+      const records = top.map((item, idx) => {
+        const r = /* @__PURE__ */ new Map();
+        r.set(lead, cellWords(item.text).replace(/:$/, ""));
+        for (const p of childPairs[idx]) r.set(p.key, p.value);
+        return r;
+      });
+      return shapeFromRecords(records, { name, at }, "a list");
+    }
+  }
+  const pairs = top.map((i) => keyValueOf(i.text));
+  if (pairs.length >= FEWEST_KEY_VALUE_PAIRS && pairs.every((p) => p !== null)) {
+    const records = recordsFromPairs(pairs);
+    const sameKeys = records.every((r) => r.size === records[0].size);
+    if (records.length === 1 || sameKeys && records[0].size >= 2) return shapeFromRecords(records, { name, at }, "a list");
+  }
+  if (top.length < FEWEST_LIST_ITEMS) return null;
+  const texts = top.map((i) => cellWords(i.text));
+  const anyChildren = top.some((i) => i.children.length > 0);
+  const headers = anyChildren ? ["Item", "Details"] : ["Item"];
+  const rows = top.map((item, idx) => {
+    const row = { Item: texts[idx] };
+    if (anyChildren) row.Details = item.children.map(cellWords).join("; ");
+    return row;
+  });
+  return {
+    kind: "list",
+    headers,
+    rows,
+    name,
+    at,
+    splits: anyChildren ? [] : listSplits(texts),
+    said: `${plural(rows.length, "item", "items")} from a list`
+  };
+}
+function parseDelimited(text, delimiter) {
+  const rows = [];
+  let row = [];
+  let cell = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (quoted) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          cell += '"';
+          i += 1;
+        } else quoted = false;
+      } else cell += ch;
+      continue;
+    }
+    if (ch === '"' && cell.trim() === "") quoted = true;
+    else if (ch === delimiter) {
+      row.push(cell);
+      cell = "";
+    } else if (ch === "\n" || ch === "\r") {
+      if (ch === "\r" && text[i + 1] === "\n") i += 1;
+      row.push(cell);
+      rows.push(row);
+      row = [];
+      cell = "";
+    } else cell += ch;
+  }
+  if (cell.length > 0 || row.length > 0) {
+    row.push(cell);
+    rows.push(row);
+  }
+  return rows.filter((r) => r.some((c) => c.trim() !== ""));
+}
+function delimitedShape(text, delimiter, fenced, at, name) {
+  const matrix = parseDelimited(text.trim(), delimiter);
+  if (matrix.length < 2) return null;
+  const width = matrix[0].length;
+  if (width < 2) return null;
+  const same = matrix.filter((r) => r.length === width).length;
+  if (same / matrix.length < 0.9) return null;
+  if (!fenced) {
+    const cells = matrix.flat();
+    const long = cells.filter((c) => c.trim().length > 80).length;
+    if (delimiter === "," && (long / cells.length > 0.2 || matrix.length < 2)) return null;
+  }
+  const headers = uniqueLabels(matrix[0].map((c) => c.trim()));
+  const rows = rowsOf(headers, matrix.slice(1));
+  if (rows.length === 0) return null;
+  const kind = delimiter === "	" ? "tsv" : "csv";
+  return {
+    kind,
+    headers,
+    rows,
+    name,
+    at,
+    splits: [],
+    said: `${sizeWords(rows.length, headers.length)} from ${kind === "tsv" ? "pasted spreadsheet cells" : "CSV"}`
+  };
+}
+function cellOf(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value) && value.every((v) => typeof v !== "object" || v === null)) return value.map(cellOf).join(", ");
+  return JSON.stringify(value);
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function labelOfKey(key) {
+  return /[\s]/.test(key) || /^[A-Z]/.test(key) ? key : humanize(key);
+}
+function shapeFromObjects(objects, kind, from, name) {
+  if (objects.length === 0) return null;
+  const keys = [];
+  for (const o of objects) for (const k of Object.keys(o)) if (k !== "__kind" && !keys.includes(k)) keys.push(k);
+  if (keys.length === 0) return null;
+  const headers = uniqueLabels(keys.map(labelOfKey));
+  const rows = objects.map((o) => {
+    const row = {};
+    keys.forEach((k, i) => {
+      row[headers[i]] = cellOf(o[k]);
+    });
+    return row;
+  });
+  return { kind, headers, rows, name, at: null, splits: [], said: `${sizeWords(rows.length, headers.length)} from ${from}` };
+}
+function shapeOfValue(value, name = null) {
+  let v = value;
+  if (typeof v === "string") {
+    const t = v.trim();
+    const fence = /^```(?:json|matrx)?\s*\n?([\s\S]*?)\n?```$/.exec(t);
+    const body = fence ? fence[1].trim() : t;
+    if (!(body.startsWith("{") || body.startsWith("["))) return null;
+    try {
+      v = JSON.parse(body);
+    } catch {
+      return null;
+    }
+  }
+  if (Array.isArray(v)) {
+    const objects = v.filter(isPlainObject);
+    if (objects.length === 0 || objects.length < v.length) return null;
+    return shapeFromObjects(objects, "rows", "JSON rows", name);
+  }
+  if (!isPlainObject(v)) return null;
+  const kv = kindValueOf(v);
+  if (kv) {
+    const label = kv.kind.replace(/^directive_v\d+_/, "").replace(/_/g, " ");
+    if (kv.items.length > 0) return shapeFromObjects(kv.items, "kind", `a ${label}`, name);
+    const scalars = Object.fromEntries(Object.entries(v).filter(([k, x]) => k !== "__kind" && (typeof x !== "object" || x === null)));
+    const shape = shapeFromObjects([scalars], "kind", `a ${label}`, name);
+    if (shape) return shape;
+  }
+  let best = null;
+  for (const [key, member] of Object.entries(v)) {
+    if (Array.isArray(member) && member.length > 0 && member.every(isPlainObject)) {
+      if (!best || member.length > best.items.length) best = { key, items: member };
+    }
+  }
+  if (best) return shapeFromObjects(best.items, kv ? "kind" : "rows", "JSON rows", name ?? labelOfKey(best.key));
+  return null;
+}
+function readTableShapes(text) {
+  if (typeof text !== "string" || text.trim() === "" || text.length > LONGEST_TEXT_READ) return [];
+  const whole = text.trim();
+  if (whole.startsWith("{") || whole.startsWith("[") || /^```(?:json|matrx)/.test(whole)) {
+    const s = shapeOfValue(whole);
+    if (s) return [{ ...s, at: { start: 0, end: text.length } }];
+  }
+  if (!/^\s*[|#>*-]/m.test(whole)) {
+    if (whole.includes("	")) {
+      const s2 = delimitedShape(whole, "	", false, { start: 0, end: text.length }, null);
+      if (s2) return [s2];
+    }
+    const s = delimitedShape(whole, ",", false, { start: 0, end: text.length }, null);
+    if (s) return [s];
+  }
+  const lines = text.split(/\r?\n/);
+  const offsets = [];
+  let pos = 0;
+  for (const line of lines) {
+    offsets.push(pos);
+    pos += line.length + 1;
+  }
+  const endOf = (i2) => (offsets[i2] ?? 0) + (lines[i2]?.length ?? 0);
+  const shapes = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const fence = /^\s*```\s*([\w-]*)\s*$/.exec(line);
+    if (fence) {
+      let j = i + 1;
+      while (j < lines.length && !/^\s*```\s*$/.test(lines[j] ?? "")) j += 1;
+      const body = lines.slice(i + 1, j).join("\n");
+      const lang = fence[1].toLowerCase();
+      const at = { start: offsets[i], end: endOf(Math.min(j, lines.length - 1)) };
+      const name = nameAbove(lines, i);
+      let s = null;
+      if (lang === "csv") s = delimitedShape(body, ",", true, at, name);
+      else if (lang === "tsv") s = delimitedShape(body, "	", true, at, name);
+      else if (lang === "json" || lang === "matrx") s = shapeOfValue(body, name);
+      if (s) shapes.push({ ...s, at });
+      i = j + 1;
+      continue;
+    }
+    if (line.includes("|") && SEPARATOR.test(lines[i + 1] ?? "") && !SEPARATOR.test(line)) {
+      const headers = uniqueLabels(splitPipes(line));
+      let j = i + 2;
+      const matrix = [];
+      while (j < lines.length && (lines[j] ?? "").includes("|") && (lines[j] ?? "").trim() !== "") {
+        matrix.push(splitPipes(lines[j]));
+        j += 1;
+      }
+      const rows = rowsOf(headers, matrix);
+      if (headers.length >= 1 && rows.length >= 1) {
+        shapes.push({
+          kind: "table",
+          headers,
+          rows,
+          name: nameAbove(lines, i),
+          at: { start: offsets[i], end: endOf(j - 1) },
+          splits: [],
+          said: `${sizeWords(rows.length, headers.length)} from a table`
+        });
+      }
+      i = j;
+      continue;
+    }
+    const item = LIST_ITEM.exec(line);
+    if (item) {
+      const baseIndent = item[1].length;
+      const items = [];
+      let j = i;
+      while (j < lines.length) {
+        const l = lines[j] ?? "";
+        const m = LIST_ITEM.exec(l);
+        if (m) {
+          const depth = m[1].length > baseIndent ? 1 : 0;
+          if (depth === 0) items.push({ depth: 0, text: m[2], children: [] });
+          else if (items.length > 0) items[items.length - 1].children.push(m[2]);
+          j += 1;
+          continue;
+        }
+        if (l.trim() === "" && LIST_ITEM.test(lines[j + 1] ?? "")) {
+          j += 1;
+          continue;
+        }
+        if (l.trim() !== "" && /^\s{2,}\S/.test(l) && items.length > 0) {
+          items[items.length - 1].text += ` ${l.trim()}`;
+          j += 1;
+          continue;
+        }
+        break;
+      }
+      const s = shapeFromList(items, nameAbove(lines, i), { start: offsets[i], end: endOf(j - 1) });
+      if (s) shapes.push(s);
+      i = j;
+      continue;
+    }
+    if (keyValueOf(line)) {
+      let j = i;
+      const pairs = [];
+      while (j < lines.length) {
+        const l = lines[j] ?? "";
+        const p = keyValueOf(l);
+        if (p) {
+          pairs.push(p);
+          j += 1;
+          continue;
+        }
+        if (l.trim() === "" && keyValueOf(lines[j + 1] ?? "")) {
+          j += 1;
+          continue;
+        }
+        break;
+      }
+      if (pairs.length >= FEWEST_KEY_VALUE_PAIRS) {
+        const records = recordsFromPairs(pairs);
+        const sameKeys = records.every((r) => r.size === records[0].size);
+        if (records.length === 1 || sameKeys && records[0].size >= 2) {
+          shapes.push(shapeFromRecords(records, { name: nameAbove(lines, i), at: { start: offsets[i], end: endOf(j - 1) } }, "key and value lines"));
+        } else {
+          const headers = ["Name", "Text"];
+          shapes.push({
+            kind: "key_value",
+            headers,
+            rows: pairs.map((p) => ({ Name: p.key, Text: p.value })),
+            name: nameAbove(lines, i),
+            at: { start: offsets[i], end: endOf(j - 1) },
+            splits: [],
+            said: `${plural(pairs.length, "line", "lines")}, each a name and what was said`
+          });
+        }
+      }
+      i = Math.max(j, i + 1);
+      continue;
+    }
+    i += 1;
+  }
+  return shapes;
+}
+function readTableShape(text) {
+  return readTableShapes(text)[0] ?? null;
+}
+function hasTableShape(text) {
+  return readTableShapes(text).length > 0;
+}
+function shapeOfGrid(headers, cells, name = null) {
+  const labels = uniqueLabels(headers.map((h) => cellWords(String(h ?? ""))));
+  const rows = rowsOf(labels, cells.map((r) => r.map((c) => cellWords(String(c ?? "")))));
+  if (labels.length === 0 || rows.length === 0) return null;
+  return { kind: "table", headers: labels, rows, name, at: null, splits: [], said: `${sizeWords(rows.length, labels.length)} from a table` };
+}
+var MOST_GUESSED_CHOICES = 12;
+var NUMBER = /^[+-]?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?$/;
+var MONEY = /^([$€£¥])\s?([+-]?(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?)$/;
+var PERCENT = /^[+-]?\d+(?:\.\d+)?\s?%$/;
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+var SLASH_DATE = /^\d{1,2}\/\d{1,2}\/\d{2,4}$/;
+var WORD_DATE = /^(?:\d{1,2}\s+)?(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\.?\s+\d{1,2}(?:st|nd|rd|th)?,?\s+\d{4}$|^\d{1,2}\s+(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)[a-z]*\.?\s+\d{4}$/i;
+var EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+var URL_WORD = /^https?:\/\/\S+$/i;
+var PHONE = /^\+?[\d\s().-]{7,20}$/;
+var YES = /* @__PURE__ */ new Set(["yes", "true", "y", "\u2713", "\u2714", "checked", "done"]);
+var NO = /* @__PURE__ */ new Set(["no", "false", "n", "\u2717", "\u2718", "unchecked", ""]);
+function isDate(v) {
+  return ISO_DATE.test(v) || SLASH_DATE.test(v) || WORD_DATE.test(v);
+}
+function guessColumn(values) {
+  const filled = values.map((v) => String(v ?? "").trim()).filter((v) => v !== "");
+  if (filled.length === 0) return { type: "text" };
+  const every = (test) => filled.every(test);
+  if (every((v) => YES.has(v.toLowerCase()) || NO.has(v.toLowerCase())) && filled.some((v) => YES.has(v.toLowerCase())) && filled.some((v) => !/^\d+$/.test(v))) {
+    return { type: "checkbox" };
+  }
+  if (every((v) => NUMBER.test(v))) return { type: "number" };
+  if (every((v) => MONEY.test(v))) {
+    const symbols = new Set(filled.map((v) => MONEY.exec(v)[1]));
+    if (symbols.size === 1) return { type: "currency", unit: [...symbols][0] };
+  }
+  if (every((v) => PERCENT.test(v))) return { type: "percent" };
+  if (every(isDate)) return { type: "datetime", kind: every((v) => !/\d:\d/.test(v)) ? "date" : "datetime" };
+  if (every((v) => EMAIL.test(v))) return { type: "email" };
+  if (every((v) => URL_WORD.test(v))) return { type: "url" };
+  if (every((v) => PHONE.test(v) && (v.match(/\d/g)?.length ?? 0) >= 7)) return { type: "phone" };
+  if (filled.some((v) => v.length > 120 || v.includes("\n"))) return { type: "long_text" };
+  const distinct = [];
+  for (const v of filled) if (!distinct.some((d) => d.toLowerCase() === v.toLowerCase())) distinct.push(v);
+  const short = every((v) => v.length <= 40 && v.split(/\s+/).length <= 5);
+  const words = filled.filter((v) => !/\d/.test(v)).length >= filled.length / 2;
+  if (filled.length >= 3 && short && words && distinct.length < filled.length && distinct.length <= MOST_GUESSED_CHOICES) {
+    return { type: "select", options: distinct };
+  }
+  return { type: "text" };
+}
+export {
+  FEWEST_KEY_VALUE_PAIRS,
+  FEWEST_LIST_ITEMS,
+  LONGEST_TEXT_READ,
+  MOST_GUESSED_CHOICES,
+  cellWords,
+  guessColumn,
+  hasTableShape,
+  parseDelimited,
+  readTableShape,
+  readTableShapes,
+  shapeOfGrid,
+  shapeOfValue,
+  uniqueLabels
+};
+//# sourceMappingURL=table-shape.js.map