@marktiderman/genesis-forms 0.4.2 → 0.6.0

package/dist/index.js

@@ -833,6 +833,81 @@ var structuredFieldTypes = [
   }
 ];
 
+// src/photo.ts
+var PHOTO_TYPE = "photo";
+var UPLOAD_FIELD_TYPES = [PHOTO_TYPE];
+var PHOTO_FORMATS = {
+  jpeg: ["image/jpeg"],
+  png: ["image/png"],
+  heic: ["image/heic", "image/heif"],
+  webp: ["image/webp"]
+};
+var FORMAT_NAMES = { jpeg: "JPEG", png: "PNG", heic: "HEIC", webp: "WebP" };
+var ALL_FORMATS = Object.keys(PHOTO_FORMATS);
+var DEFAULT_PHOTO_FILES = 3;
+var MAX_PHOTO_FILES = 5;
+var DEFAULT_PHOTO_SIZE_MB = 10;
+var MAX_PHOTO_SIZE_MB = 25;
+var MAX_PHOTO_ID_LENGTH = 200;
+var MAX_PHOTO_NAME_LENGTH = 255;
+var isPhotoFormat = (v) => typeof v === "string" && Object.prototype.hasOwnProperty.call(PHOTO_FORMATS, v);
+var wholeIn = (v, min, max) => typeof v === "number" && Number.isInteger(v) && v >= min && v <= max;
+function photoLimits(field2) {
+  const maxFiles = wholeIn(field2.props?.maxFiles, 1, MAX_PHOTO_FILES) ? field2.props.maxFiles : DEFAULT_PHOTO_FILES;
+  const maxSizeMb = wholeIn(field2.props?.maxSizeMb, 1, MAX_PHOTO_SIZE_MB) ? field2.props.maxSizeMb : DEFAULT_PHOTO_SIZE_MB;
+  const raw = field2.props?.formats;
+  const picked = Array.isArray(raw) ? ALL_FORMATS.filter((f2) => raw.includes(f2)) : [];
+  const formats = picked.length ? picked : [...ALL_FORMATS];
+  return {
+    maxFiles,
+    maxSizeMb,
+    maxBytes: maxSizeMb * 1024 * 1024,
+    formats,
+    mimeTypes: formats.flatMap((f2) => PHOTO_FORMATS[f2])
+  };
+}
+function isPhotoRef(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+  const r = v;
+  return typeof r.id === "string" && r.id.length > 0 && r.id.length <= MAX_PHOTO_ID_LENGTH && typeof r.name === "string" && r.name.length <= MAX_PHOTO_NAME_LENGTH && typeof r.type === "string" && typeof r.size === "number" && Number.isInteger(r.size) && r.size > 0;
+}
+function photoRefs(value) {
+  if (!Array.isArray(value)) return [];
+  const refs = [];
+  for (const r of value) if (isPhotoRef(r)) refs.push({ id: r.id, name: r.name, type: r.type, size: r.size });
+  return refs;
+}
+var plural2 = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function photoFormatList(formats) {
+  const names = formats.map((f2) => FORMAT_NAMES[f2]);
+  return names.length > 1 ? `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}` : names[0] ?? "";
+}
+var photoTypeMessage = (field2) => `Use a ${photoFormatList(photoLimits(field2).formats)} photo.`;
+var photoSizeMessage = (field2) => `Each photo must be ${photoLimits(field2).maxSizeMb} MB or smaller.`;
+var photoCountMessage = (field2) => `Add at most ${plural2(photoLimits(field2).maxFiles, "photo")}.`;
+var photoFieldType = {
+  type: PHOTO_TYPE,
+  label: "Photo",
+  category: "media",
+  value: { json: true },
+  operators: ["answered", "empty"],
+  a11y: { semantics: "group" },
+  isEmpty: (value) => value === void 0 || value === null || Array.isArray(value) && value.length === 0,
+  validate: (value, field2) => {
+    if (!Array.isArray(value) || !value.every(isPhotoRef)) return "Add a photo.";
+    const limits = photoLimits(field2);
+    if (value.length > limits.maxFiles) return photoCountMessage(field2);
+    const refs = value;
+    if (new Set(refs.map((r) => r.id)).size !== refs.length) return "Each photo can be added once.";
+    if (refs.some((r) => !limits.mimeTypes.includes(r.type.toLowerCase()))) return photoTypeMessage(field2);
+    if (refs.some((r) => r.size > limits.maxBytes)) return photoSizeMessage(field2);
+    return null;
+  },
+  normalize: (value) => Array.isArray(value) && value.every(isPhotoRef) ? photoRefs(value) : value,
+  summarize: (value) => photoRefs(value).map((r) => r.name || "Photo").join(", "),
+  samples: () => [[{ id: "sample-photo", name: "photo.jpg", type: "image/jpeg", size: 1024 }]]
+};
+
 // src/fields.ts
 var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types");
 var globalScope = globalThis;
@@ -875,12 +950,127 @@ function summarizeValue(value, field2) {
   if (Array.isArray(value)) return value.join(", ");
   return String(value);
 }
+var OPTION_LIMITS = {
+  /** Characters in a description. */
+  description: 500,
+  /** Characters in an image URL. */
+  image: 2048,
+  /** Attributes on one option. */
+  attributes: 20,
+  /** Characters in an attribute's name. */
+  attributeName: 64,
+  /** Characters in one attribute value. */
+  attributeValue: 200,
+  /** Values in one attribute's list. */
+  attributeItems: 50
+};
+function isHttpsUrl(url) {
+  return typeof url === "string" && url.length <= OPTION_LIMITS.image && /^https:\/\/[^\s/?#@\\]+(?:[/?#][^\s]*)?$/i.test(url) && // No control characters anywhere (a line break would end a CSV row or an HTML attribute).
+  ![...url].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127);
+}
+function attributeName(name) {
+  return name.trim() !== "" && name.length <= OPTION_LIMITS.attributeName && !(name in Object.prototype);
+}
+function readAttributes(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const out = {};
+  let count = 0;
+  for (const name of Object.keys(raw)) {
+    if (count >= OPTION_LIMITS.attributes) break;
+    if (!attributeName(name)) continue;
+    const v = raw[name];
+    const fits = (x) => typeof x === "string" && x.length <= OPTION_LIMITS.attributeValue;
+    if (fits(v)) out[name] = v;
+    else if (Array.isArray(v) && v.length <= OPTION_LIMITS.attributeItems && v.every(fits)) out[name] = [...v];
+    else continue;
+    count++;
+  }
+  return count ? out : void 0;
+}
+function readOption(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const o = raw;
+  if (typeof o.value !== "string") return null;
+  const out = { value: o.value };
+  if (typeof o.label === "string") out.label = o.label;
+  if (typeof o.description === "string" && o.description.trim() && o.description.length <= OPTION_LIMITS.description) {
+    out.description = o.description;
+  }
+  if (isHttpsUrl(o.image)) out.image = o.image;
+  const attributes = readAttributes(o.attributes);
+  if (attributes) out.attributes = attributes;
+  return out;
+}
+function optionJson(option) {
+  const out = { value: option.value };
+  if (option.label !== void 0) out.label = option.label;
+  if (option.description !== void 0) out.description = option.description;
+  if (option.image !== void 0) out.image = option.image;
+  if (option.attributes !== void 0) out.attributes = { ...option.attributes };
+  return out;
+}
+var OTHER_MAX_LENGTH = 200;
+function otherOption(field2) {
+  const other = field2.props?.other;
+  if (other === true) return { label: "Other" };
+  if (other && typeof other === "object" && !Array.isArray(other)) {
+    const label = typeof other.label === "string" && other.label.trim() ? other.label.trim() : "Other";
+    return { label };
+  }
+  return null;
+}
+function isOtherValue(field2, value) {
+  return otherOption(field2) !== null && typeof value === "string" && !choiceOptions(field2).some((o) => o.value === value);
+}
+var typedOther = (field2, value) => isOtherValue(field2, value) && value.trim() !== "" && value.length <= OTHER_MAX_LENGTH;
 function choiceOptions(field2) {
   const raw = field2.props?.options;
   if (!Array.isArray(raw)) return [];
-  return raw.flatMap(
-    (o) => o && typeof o === "object" && !Array.isArray(o) && typeof o.value === "string" ? [{ value: o.value, label: typeof o.label === "string" ? o.label : void 0 }] : []
-  );
+  return raw.flatMap((o) => {
+    const option = readOption(o);
+    return option ? [option] : [];
+  });
+}
+function optionsSource(field2) {
+  const raw = field2.props?.optionsFrom;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  if (raw.source !== "host" || typeof raw.key !== "string" || !raw.key) return void 0;
+  const out = { source: "host", key: raw.key };
+  const filter = raw.filter;
+  if (filter && typeof filter === "object" && !Array.isArray(filter) && typeof filter.attribute === "string" && filter.attribute && typeof filter.field === "string" && filter.field) {
+    out.filter = { attribute: filter.attribute, field: filter.field };
+  }
+  return out;
+}
+function hostList(hostOptions, key) {
+  if (!hostOptions || !Object.prototype.hasOwnProperty.call(hostOptions, key)) return [];
+  const list = hostOptions[key];
+  if (!Array.isArray(list)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const o of list) {
+    const option = readOption(o);
+    if (!option || !option.value || seen.has(option.value)) continue;
+    seen.add(option.value);
+    out.push(option);
+  }
+  return out;
+}
+function withHostOptions(definition, hostOptions) {
+  let changed = false;
+  const blocks = definition.blocks.map((block) => {
+    if (block.kind !== "field") return block;
+    const from = optionsSource(block);
+    if (!from) return block;
+    const own2 = choiceOptions(block);
+    const taken = new Set(own2.map((o) => o.value));
+    const added = hostList(hostOptions, from.key).filter((o) => !taken.has(o.value));
+    if (!added.length) return block;
+    changed = true;
+    const options = [...own2, ...added].map(optionJson);
+    return { ...block, props: { ...block.props, options } };
+  });
+  return changed ? { ...definition, blocks } : definition;
 }
 function optionLabel(field2, value) {
   const option = choiceOptions(field2).find((o) => o.value === value);
@@ -1000,7 +1190,7 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "in", "answered", "empty"],
     a11y: { semantics: "group" },
-    validate: (value, field2) => typeof value === "string" && choiceOptions(field2).some((o) => o.value === value) ? null : "Choose one of the options.",
+    validate: (value, field2) => typeof value === "string" && (choiceOptions(field2).some((o) => o.value === value) || typedOther(field2, value)) ? null : "Choose one of the options.",
     summarize: (value, field2) => optionLabel(field2, String(value))
   },
   {
@@ -1012,7 +1202,8 @@ var builtins = [
     a11y: { semantics: "group" },
     validate: (value, field2) => {
       const allowed = new Set(choiceOptions(field2).map((o) => o.value));
-      return Array.isArray(value) && value.length <= allowed.size && new Set(value).size === value.length && value.every((v) => typeof v === "string" && allowed.has(v)) ? null : "Choose from the options.";
+      const others = Array.isArray(value) ? value.filter((v) => typeof v === "string" && !allowed.has(v)) : [];
+      return Array.isArray(value) && new Set(value).size === value.length && value.every((v) => typeof v === "string") && (others.length === 0 || others.length === 1 && typedOther(field2, others[0])) ? null : "Choose from the options.";
     },
     summarize: (value, field2) => Array.isArray(value) ? value.map((v) => optionLabel(field2, String(v))).join(", ") : String(value)
   },
@@ -1033,7 +1224,7 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "in", "answered", "empty"],
     a11y: { semantics: "control" },
-    validate: (value, field2) => typeof value === "string" && choiceOptions(field2).some((o) => o.value === value) ? null : "Choose one of the options.",
+    validate: (value, field2) => typeof value === "string" && (choiceOptions(field2).some((o) => o.value === value) || typedOther(field2, value)) ? null : "Choose one of the options.",
     summarize: (value, field2) => optionLabel(field2, String(value))
   },
   {
@@ -1143,7 +1334,48 @@ function dateLimits(field2) {
   if (typeof max === "string" && isIsoDate(max)) out.max = max;
   return out;
 }
-for (const manifest of [...builtins, ...structuredFieldTypes, calculatedFieldType]) registerFieldType(manifest);
+for (const manifest of [...builtins, ...structuredFieldTypes, calculatedFieldType, photoFieldType]) registerFieldType(manifest);
+
+// src/hidden.ts
+var MAX_HIDDEN_STRING_LENGTH = 1e3;
+var DECIMAL = /^-?\d+(\.\d+)?$/;
+function coerceHiddenValue(value, type) {
+  if (typeof value === "string" && value.length > MAX_HIDDEN_STRING_LENGTH) return void 0;
+  if (type === "string") {
+    if (typeof value === "string") return value;
+    if (typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return String(value);
+    return void 0;
+  }
+  if (type === "number") {
+    if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+    if (typeof value !== "string" || !DECIMAL.test(value)) return void 0;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  if (typeof value === "boolean") return value;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function coerceHidden(definition, raw, options = {}) {
+  const declared = new Map((definition.hidden ?? []).map((h) => [h.name, h]));
+  const values = {};
+  const ignored = [];
+  if (!isPlainObject(raw)) return { values, ignored };
+  for (const name of Object.keys(raw)) {
+    const value = raw[name];
+    if (value === void 0) continue;
+    const spec = declared.get(name);
+    if (!spec || options.sources && !options.sources.includes(spec.source)) {
+      ignored.push(name);
+      continue;
+    }
+    const coerced = coerceHiddenValue(value, spec.type);
+    if (coerced === void 0) ignored.push(name);
+    else Object.defineProperty(values, name, { value: coerced, enumerable: true, writable: true, configurable: true });
+  }
+  return { values, ignored };
+}
 
 // src/logic.ts
 function own(record, key) {
@@ -1276,6 +1508,225 @@ function fieldMap(def) {
   return map;
 }
 
+// src/options.ts
+var CHOICE_FIELD_TYPES = /* @__PURE__ */ new Set(["single-choice", "multi-choice", "dropdown"]);
+var isChoice = (block) => !!block && block.kind === "field" && CHOICE_FIELD_TYPES.has(block.type);
+function put(record, key, value) {
+  Object.defineProperty(record, key, { value, enumerable: true, writable: true, configurable: true });
+}
+function optionFilter(field2) {
+  return optionsSource(field2)?.filter;
+}
+function answerValues(answer) {
+  const one = (v) => typeof v === "string" ? [v] : typeof v === "number" || typeof v === "boolean" ? [String(v)] : [];
+  if (answer === void 0 || answer === null) return [];
+  return Array.isArray(answer) ? answer.flatMap(one) : one(answer);
+}
+function optionMatches(option, attribute, answer) {
+  const have = option.attributes && Object.prototype.hasOwnProperty.call(option.attributes, attribute) ? option.attributes[attribute] : void 0;
+  if (have === void 0) return false;
+  const wanted = answerValues(answer);
+  return (Array.isArray(have) ? have : [have]).some((v) => wanted.includes(v));
+}
+function filterSource(definition, key) {
+  return definition.blocks.find((b) => b.kind === "field" && b.key === key);
+}
+function visibleOptions(definition, field2, values) {
+  const options = choiceOptions(field2);
+  const filter = optionFilter(field2);
+  if (!filter) return options;
+  const source = filterSource(definition, filter.field);
+  if (!source || source.id === field2.id) return options;
+  const answer = own(values, source.id);
+  if (isEmptyValue(answer, source)) return options;
+  return options.filter((o) => optionMatches(o, filter.attribute, answer));
+}
+function answersOnPath(state) {
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const id of state.path) out[id] = own(state.values, id);
+  return out;
+}
+var OUTSIDE_FILTER = "Choose one of the options.";
+function filteredChoiceError(definition, field2, value, values) {
+  if (!optionFilter(field2) || isEmptyValue(value, field2)) return null;
+  const all = new Set(choiceOptions(field2).map((o) => o.value));
+  const shown2 = new Set(visibleOptions(definition, field2, values).map((o) => o.value));
+  const picked = answerValues(value);
+  return picked.some((v) => all.has(v) && !shown2.has(v)) ? OUTSIDE_FILTER : null;
+}
+function hasOptionFilters(definition) {
+  return definition.blocks.some((b) => isChoice(b) && optionFilter(b) !== void 0);
+}
+function clearFilteredAnswers(definition, values, changedId) {
+  const changed = definition.blocks.find((b) => b.kind === "field" && b.id === changedId);
+  if (!changed) return values;
+  const keys = /* @__PURE__ */ new Set([changed.key]);
+  let out = values;
+  for (const block of definition.blocks) {
+    if (!isChoice(block)) continue;
+    const filter = optionFilter(block);
+    if (!filter || !keys.has(filter.field)) continue;
+    const value = own(out, block.id);
+    if (value === void 0 || isEmptyValue(value, block)) continue;
+    const all = new Set(choiceOptions(block).map((o) => o.value));
+    const shown2 = new Set(visibleOptions(definition, block, out).map((o) => o.value));
+    const keep = (v) => typeof v !== "string" || !all.has(v) || shown2.has(v);
+    let next = value;
+    if (Array.isArray(value)) {
+      const kept = value.filter(keep);
+      if (kept.length !== value.length) next = kept.length ? kept : void 0;
+    } else if (!keep(value)) next = void 0;
+    if (next === value) continue;
+    if (out === values) out = { ...values };
+    put(out, block.id, next);
+    keys.add(block.key);
+  }
+  return out;
+}
+var SEARCHABLE_OPTION_COUNT = 10;
+function isSearchable(field2, optionCount = choiceOptions(field2).length) {
+  const setting = field2.props?.searchable;
+  if (setting === true || setting === false) return setting;
+  return optionCount > SEARCHABLE_OPTION_COUNT;
+}
+function fold(text) {
+  return text.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
+}
+function searchOptions(options, query) {
+  const words = fold(query).split(/\s+/).filter(Boolean);
+  if (!words.length) return [...options];
+  return options.filter((o) => {
+    const text = fold([o.label ?? "", o.value, o.description ?? ""].join(" "));
+    return words.every((w) => text.includes(w));
+  });
+}
+var MAX_PREFILL_PARAM_LENGTH = 64;
+function isPrefillParam(param) {
+  return typeof param === "string" && param.length <= MAX_PREFILL_PARAM_LENGTH && /^[A-Za-z0-9_.-]+$/.test(param);
+}
+function prefillSetting(field2) {
+  if (!CHOICE_FIELD_TYPES.has(field2.type)) return void 0;
+  const raw = field2.props?.prefill;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw) || !isPrefillParam(raw.param)) return void 0;
+  return { param: raw.param, hideWhenPrefilled: raw.hideWhenPrefilled === true };
+}
+function paramValues(params, name) {
+  let raw;
+  if (typeof params.getAll === "function") {
+    raw = params.getAll(name);
+  } else if (Object.prototype.hasOwnProperty.call(params, name)) {
+    raw = params[name];
+  }
+  const list = Array.isArray(raw) ? raw : raw === void 0 ? [] : [raw];
+  return list.filter((v) => typeof v === "string" && v !== "" && v.length <= MAX_HIDDEN_STRING_LENGTH);
+}
+function prefillFromLink(definition, params, values = {}) {
+  const out = {};
+  if (!params || typeof params !== "object") return out;
+  const seen = {};
+  for (const id of Object.keys(values)) put(seen, id, values[id]);
+  for (const block of definition.blocks) {
+    if (!isChoice(block)) continue;
+    const setting = prefillSetting(block);
+    if (!setting || own(seen, block.id) !== void 0) continue;
+    const raw = paramValues(params, setting.param);
+    if (!raw.length) continue;
+    const shown2 = new Set(visibleOptions(definition, block, seen).map((o) => o.value));
+    let value;
+    if (block.type === "multi-choice") {
+      const picked = [];
+      for (const r of raw) {
+        for (const v of shown2.has(r) ? [r] : r.split(",").map((s) => s.trim())) {
+          if (shown2.has(v) && !picked.includes(v)) picked.push(v);
+        }
+      }
+      if (picked.length) value = picked;
+    } else value = raw.find((v) => shown2.has(v));
+    if (value === void 0) continue;
+    put(out, block.id, value);
+    put(seen, block.id, value);
+  }
+  return out;
+}
+function hiddenByPrefill(definition, state) {
+  const hideable = /* @__PURE__ */ new Set();
+  for (const b of definition.blocks) {
+    if (isChoice(b) && prefillSetting(b)?.hideWhenPrefilled) hideable.add(b.id);
+  }
+  if (!hideable.size) return [];
+  const prefilled = /* @__PURE__ */ new Set();
+  for (const e of state.events) {
+    if (e.type !== "answer" || !hideable.has(e.field)) continue;
+    if (e.source === "prefill") prefilled.add(e.field);
+    else prefilled.delete(e.field);
+  }
+  if (!prefilled.size) return [];
+  const fields = new Map(definition.blocks.map((b) => [b.id, b]));
+  return state.path.filter((id) => {
+    if (!prefilled.has(id) || own(state.errors, id) !== void 0) return false;
+    const field2 = fields.get(id);
+    return !isEmptyValue(own(state.values, id), field2);
+  });
+}
+function respondentPath(definition, state) {
+  const hidden = hiddenByPrefill(definition, state);
+  if (!hidden.length) return [...state.path];
+  const skip = new Set(hidden);
+  return state.path.filter((id) => !skip.has(id));
+}
+function snapshotOf(byValue, value) {
+  const option = byValue.get(value);
+  if (option) return { value, label: option.label ?? value };
+  return { value, label: value, other: true };
+}
+function answerSnapshots(definition, answers) {
+  const out = {};
+  for (const block of definition.blocks) {
+    if (!isChoice(block) || !optionsSource(block)) continue;
+    const value = own(answers, block.id);
+    if (isEmptyValue(value, block)) continue;
+    const byValue = new Map(choiceOptions(block).map((o) => [o.value, o]));
+    let snapshot;
+    if (Array.isArray(value)) {
+      const items = value.filter((v) => typeof v === "string").map((v) => snapshotOf(byValue, v));
+      if (items.length) snapshot = items;
+    } else if (typeof value === "string") snapshot = snapshotOf(byValue, value);
+    if (snapshot) put(out, block.id, snapshot);
+  }
+  return out;
+}
+function answersFromSnapshots(definition, snapshots) {
+  const answers = {};
+  const missing = {};
+  for (const block of definition.blocks) {
+    if (!isChoice(block)) continue;
+    const raw = own(snapshots, block.id);
+    const list = (Array.isArray(raw) ? raw : raw === void 0 ? [] : [raw]).flatMap((s) => {
+      const o = readOption(s);
+      if (!o) return [];
+      const label = o.label ?? o.value;
+      return [s.other === true ? { value: o.value, label, other: true } : { value: o.value, label }];
+    });
+    if (!list.length) continue;
+    const options = choiceOptions(block);
+    const byValue = new Set(options.map((o) => o.value));
+    const allowsOther = block.props?.other !== void 0 && block.props?.other !== false;
+    const found = [];
+    const lost = [];
+    for (const s of list) {
+      let value;
+      if (byValue.has(s.value)) value = s.value;
+      else if (s.other) value = allowsOther ? s.value : void 0;
+      else value = options.find((o) => fold(o.label ?? o.value) === fold(s.label))?.value;
+      if (value === void 0) lost.push(s);
+      else if (!found.includes(value)) found.push(value);
+    }
+    if (found.length) put(answers, block.id, block.type === "multi-choice" ? found : found[0]);
+    if (lost.length) put(missing, block.id, lost);
+  }
+  return { answers, missing };
+}
+
 // src/recall.ts
 var TOKEN = /\{\{\s*(field|hidden):([A-Za-z0-9_-]+)\s*(?:\|([^}]*))?\}\}/g;
 function recall(text, scope) {
@@ -1355,6 +1806,31 @@ function parseForm(input) {
   const optionalBoolean = (v, path) => {
     if (v !== void 0 && typeof v !== "boolean") issue(path, "Must be true or false.");
   };
+  const optionDetails = (o, at) => {
+    if (o.description !== void 0 && (typeof o.description !== "string" || o.description.length > OPTION_LIMITS.description)) {
+      issue(`${at}.description`, `Must be text of at most ${OPTION_LIMITS.description} characters.`);
+    }
+    if (o.image !== void 0 && !isHttpsUrl(o.image)) {
+      issue(`${at}.image`, `Must be an https:// link of at most ${OPTION_LIMITS.image} characters.`);
+    }
+    if (o.attributes === void 0) return;
+    const attributes = o.attributes;
+    if (!isObject2(attributes) || Object.keys(attributes).length > OPTION_LIMITS.attributes) {
+      issue(`${at}.attributes`, `Must be an object of at most ${OPTION_LIMITS.attributes} attributes.`);
+      return;
+    }
+    const fits = (x) => typeof x === "string" && x.length <= OPTION_LIMITS.attributeValue;
+    for (const [name2, v] of Object.entries(attributes)) {
+      if (!name2.trim() || name2.length > OPTION_LIMITS.attributeName || RESERVED.has(name2)) {
+        issue(`${at}.attributes`, `${shown(name2)} isn't a usable attribute name (at most ${OPTION_LIMITS.attributeName} characters).`);
+      } else if (!fits(v) && !(Array.isArray(v) && v.length <= OPTION_LIMITS.attributeItems && v.every(fits))) {
+        issue(
+          `${at}.attributes.${name2}`,
+          `Must be text, or a list of at most ${OPTION_LIMITS.attributeItems} texts, each at most ${OPTION_LIMITS.attributeValue} characters.`
+        );
+      }
+    }
+  };
   const name = (v, path, what) => {
     if (typeof v !== "string" || !v) {
       issue(path, `${what} must be a non-empty string.`);
@@ -1443,6 +1919,22 @@ function parseForm(input) {
       }
     }
     if (type === "consent") optionalText(props2.text, `${path}.text`);
+    if (type === PHOTO_TYPE) {
+      if (props2.maxFiles !== void 0 && !(isInt(props2.maxFiles) && props2.maxFiles >= 1 && props2.maxFiles <= MAX_PHOTO_FILES)) {
+        issue(`${path}.maxFiles`, `Must be a whole number from 1 to ${MAX_PHOTO_FILES}.`);
+      }
+      if (props2.maxSizeMb !== void 0 && !(isInt(props2.maxSizeMb) && props2.maxSizeMb >= 1 && props2.maxSizeMb <= MAX_PHOTO_SIZE_MB)) {
+        issue(`${path}.maxSizeMb`, `Must be a whole number from 1 to ${MAX_PHOTO_SIZE_MB}.`);
+      }
+      if (props2.formats !== void 0) {
+        const formats = props2.formats;
+        if (!Array.isArray(formats) || formats.length === 0 || !formats.every(isPhotoFormat)) {
+          issue(`${path}.formats`, "Must be a list of one or more of jpeg, png, heic and webp.");
+        } else if (new Set(formats).size !== formats.length) {
+          issue(`${path}.formats`, "Name each format once.");
+        }
+      }
+    }
   };
   if (!isObject2(input)) {
     issue("", "A form definition must be an object.");
@@ -1463,6 +1955,7 @@ function parseForm(input) {
     else {
       optionalBoolean(input.settings.anonymous, "settings.anonymous");
       optionalBoolean(input.settings.clearHiddenValues, "settings.clearHiddenValues");
+      optionalBoolean(input.settings.saveProgress, "settings.saveProgress");
     }
   }
   if (input.meta !== void 0 && (!isObject2(input.meta) || !isJson(input.meta))) {
@@ -1503,6 +1996,38 @@ function parseForm(input) {
         issue(`${path}.type`, `Unknown field type "${String(block.type)}".`);
       }
       if (block.props !== void 0) {
+        const from = isObject2(block.props) ? block.props.optionsFrom : void 0;
+        if (from !== void 0) {
+          if (!isObject2(from) || from.source !== "host" || typeof from.key !== "string" || !from.key) {
+            issue(`${path}.props.optionsFrom`, 'Must be { source: "host", key } with a non-empty key.');
+          } else if (typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+            warnings.push({ path: `${path}.props.optionsFrom`, message: "Only single choice, multiple choice and dropdown questions take options from the app." });
+          }
+          const filter = isObject2(from) ? from.filter : void 0;
+          if (filter !== void 0) {
+            const at = `${path}.props.optionsFrom.filter`;
+            if (!isObject2(filter) || typeof filter.attribute !== "string" || !filter.attribute || filter.attribute.length > OPTION_LIMITS.attributeName || typeof filter.field !== "string" || !filter.field) {
+              issue(at, `Must be { attribute, field }: an attribute name (at most ${OPTION_LIMITS.attributeName} characters) and an earlier question's key.`);
+            } else if (!keys.has(filter.field)) {
+              issue(`${at}.field`, `"${filter.field}" must be the key of an earlier question.`);
+            }
+          }
+        }
+        const prefill = isObject2(block.props) ? block.props.prefill : void 0;
+        if (prefill !== void 0) {
+          if (!isObject2(prefill) || !isPrefillParam(prefill.param)) {
+            issue(
+              `${path}.props.prefill`,
+              `Must be { param, hideWhenPrefilled? }: a link parameter of letters, digits, "_", "-" or "." (at most ${MAX_PREFILL_PARAM_LENGTH} characters).`
+            );
+          } else {
+            optionalBoolean(prefill.hideWhenPrefilled, `${path}.props.prefill.hideWhenPrefilled`);
+            if (typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+              warnings.push({ path: `${path}.props.prefill`, message: "Only single choice, multiple choice and dropdown questions are filled in from a link." });
+            }
+          }
+        }
+        if (isObject2(block.props)) optionalBoolean(block.props.searchable, `${path}.props.searchable`);
         if (!isObject2(block.props) || !isJson(block.props)) issue(`${path}.props`, "Must be a JSON object.");
         else if (block.props.options !== void 0) {
           const options = block.props.options;
@@ -1511,12 +2036,25 @@ function parseForm(input) {
             options.forEach((o, j) => {
               const at = `${path}.props.options[${j}]`;
               if (!isObject2(o) || typeof o.value !== "string") issue(at, "Each option needs a string value.");
-              else optionalText(o.label, `${at}.label`);
+              else {
+                optionalText(o.label, `${at}.label`);
+                optionDetails(o, at);
+              }
             });
-            choices.set(
-              block.id,
-              new Set(options.flatMap((o) => isObject2(o) && typeof o.value === "string" ? [o.value] : []))
-            );
+            if (from === void 0) {
+              choices.set(
+                block.id,
+                new Set(options.flatMap((o) => isObject2(o) && typeof o.value === "string" ? [o.value] : []))
+              );
+            }
+          }
+        }
+        const other = isObject2(block.props) ? block.props.other : void 0;
+        if (other !== void 0) {
+          if (other !== true && other !== false && !(isObject2(other) && (other.label === void 0 || typeof other.label === "string"))) {
+            issue(`${path}.props.other`, "Must be true, false or { label }.");
+          } else if (other !== false && typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+            warnings.push({ path: `${path}.props.other`, message: 'Only single choice, multiple choice and dropdown questions take an "Other" answer.' });
           }
         }
         const { max, maxLength: maxLength2 } = isObject2(block.props) ? block.props : {};
@@ -1591,6 +2129,8 @@ function parseForm(input) {
       } else if (ref.column !== void 0) issue(path, `"${ref.key}" is not a table, so it has no column "${ref.column}".`);
       else if (targetType === "media-notes" || targetType === "text-highlights") {
         warnings.push({ path, message: `"${ref.key}" holds notes, not numbers; the formula reads it as blank.` });
+      } else if (targetType === PHOTO_TYPE) {
+        warnings.push({ path, message: `"${ref.key}" holds photos, not numbers; the formula reads it as blank.` });
       }
     }
   });
@@ -1810,9 +2350,30 @@ function field(type, key, options, props2) {
   return block;
 }
 var props = (all) => Object.fromEntries(Object.entries(all).filter((e) => e[1] !== void 0));
-var choiceProps = (options) => ({
-  options: options.map((o) => o.label ? { value: o.value, label: o.label } : { value: o.value })
-});
+var choiceProps = (o) => {
+  const out = {};
+  if (o.options || !o.optionsFrom) {
+    out.options = (o.options ?? []).map(
+      (x) => props({
+        value: x.value,
+        label: x.label || void 0,
+        description: x.description,
+        image: x.image,
+        attributes: x.attributes
+      })
+    );
+  }
+  if (o.optionsFrom) {
+    const { source, key, filter } = o.optionsFrom;
+    out.optionsFrom = filter ? { source, key, filter: { attribute: filter.attribute, field: filter.field } } : { source, key };
+  }
+  if (o.prefill) {
+    out.prefill = o.prefill.hideWhenPrefilled ? { param: o.prefill.param, hideWhenPrefilled: true } : { param: o.prefill.param };
+  }
+  if (o.searchable !== void 0) out.searchable = o.searchable;
+  if (o.other) out.other = o.other === true ? true : props({ label: o.other.label });
+  return out;
+};
 var hiddenSpec = (type, o) => ({
   type,
   source: o.source ?? "url",
@@ -1836,11 +2397,11 @@ var f = {
   ),
   /** A 0-to-10 Net Promoter Score. The end labels default to "Not likely" and "Very likely" in the renderer. */
   nps: (key, o) => field("nps", key, o, props({ lowLabel: o.lowLabel || void 0, highLabel: o.highLabel || void 0 })),
-  singleChoice: (key, o) => field("single-choice", key, o, choiceProps(o.options)),
-  multiChoice: (key, o) => field("multi-choice", key, o, choiceProps(o.options)),
+  singleChoice: (key, o) => field("single-choice", key, o, choiceProps(o)),
+  multiChoice: (key, o) => field("multi-choice", key, o, choiceProps(o)),
   yesNo: (key, o) => field("yes-no", key, o),
   /** One option from a compact menu: for a long list (a country, a class), where single choice would be a wall of buttons. */
-  dropdown: (key, o) => field("dropdown", key, o, choiceProps(o.options)),
+  dropdown: (key, o) => field("dropdown", key, o, choiceProps(o)),
   /** A number, optionally between `min` and `max` and on a `step` (from `min`, else 0): `step: 1` for whole numbers. */
   number: (key, o) => field("number", key, o, props({ min: o.min, max: o.max, step: o.step })),
   /** A calendar day, stored as `YYYY-MM-DD`, optionally between `min` and `max` (also `YYYY-MM-DD`). */
@@ -1892,6 +2453,17 @@ var f = {
     o,
     props({ text: o.text, maxHighlights: o.maxHighlights })
   ),
+  /**
+   * Up to a few photos (a picture of broken equipment). The answer holds the
+   * references the host's upload returned, never the bytes; `formats` from
+   * jpeg, png, heic and webp (default all four).
+   */
+  photo: (key, o) => field(
+    "photo",
+    key,
+    o,
+    props({ maxFiles: o.maxFiles, maxSizeMb: o.maxSizeMb, formats: o.formats ? [...o.formats] : void 0 })
+  ),
   /** Any registered field type, including plugins. */
   custom: (type, key, o) => field(type, key, o, o.props),
   heading: (id, text) => ({ kind: "content", id, type: "heading", text }),
@@ -1999,47 +2571,6 @@ ${list}`);
   };
 }
 
-// src/hidden.ts
-var MAX_HIDDEN_STRING_LENGTH = 1e3;
-var DECIMAL = /^-?\d+(\.\d+)?$/;
-function coerceHiddenValue(value, type) {
-  if (typeof value === "string" && value.length > MAX_HIDDEN_STRING_LENGTH) return void 0;
-  if (type === "string") {
-    if (typeof value === "string") return value;
-    if (typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return String(value);
-    return void 0;
-  }
-  if (type === "number") {
-    if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
-    if (typeof value !== "string" || !DECIMAL.test(value)) return void 0;
-    const n = Number(value);
-    return Number.isFinite(n) ? n : void 0;
-  }
-  if (typeof value === "boolean") return value;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  return void 0;
-}
-function coerceHidden(definition, raw, options = {}) {
-  const declared = new Map((definition.hidden ?? []).map((h) => [h.name, h]));
-  const values = {};
-  const ignored = [];
-  if (!isPlainObject(raw)) return { values, ignored };
-  for (const name of Object.keys(raw)) {
-    const value = raw[name];
-    if (value === void 0) continue;
-    const spec = declared.get(name);
-    if (!spec || options.sources && !options.sources.includes(spec.source)) {
-      ignored.push(name);
-      continue;
-    }
-    const coerced = coerceHiddenValue(value, spec.type);
-    if (coerced === void 0) ignored.push(name);
-    else Object.defineProperty(values, name, { value: coerced, enumerable: true, writable: true, configurable: true });
-  }
-  return { values, ignored };
-}
-
 // src/validate.ts
 var REQUIRED_MESSAGE = "This question needs an answer.";
 function runCustom(validator, value) {
@@ -2075,7 +2606,8 @@ function readsAny(node, ids) {
 function createForm(definition, options = {}) {
   return build(definition, options).engine;
 }
-function build(definition, options, replaying = false, budget) {
+function build(given, options, replaying = false, budget) {
+  const definition = withHostOptions(given, options.hostOptions);
   const fields = fieldMap(definition);
   const byKey = new Map([...fields.values()].map((f2) => [f2.key, f2]));
   const blocks = new Map(definition.blocks.map((b) => [b.id, b]));
@@ -2121,6 +2653,7 @@ function build(definition, options, replaying = false, budget) {
     path: first.path,
     current: first.path[0] ?? null,
     history: [],
+    furthest: first.path[0] ?? null,
     errors: {},
     status: "in_progress",
     ending: null,
@@ -2141,16 +2674,34 @@ function build(definition, options, replaying = false, budget) {
     return at === void 0 ? event : { ...event, at };
   };
   const isVisibleIn = (s, id) => s.path.includes(id);
+  const filters = hasOptionFilters(definition);
+  const clearFiltered = (values, id) => filters ? clearFilteredAnswers(definition, values, id) : values;
   const errorsFor = (s, ids) => {
     const errors = {};
+    let shown2;
     for (const id of ids) {
       const field2 = fields.get(id);
       if (!field2 || !isVisibleIn(s, id)) continue;
-      const message = validateField(field2, own(s.values, id), { custom: options.validators?.[id] });
+      const value = own(s.values, id);
+      let message = validateField(field2, value, { custom: options.validators?.[id] });
+      if (!message && filters) message = filteredChoiceError(definition, field2, value, shown2 ??= answersOnPath(s));
       if (message) errors[id] = message;
     }
     return errors;
   };
+  const skipped = (s) => new Set(hiddenByPrefill(definition, s));
+  const shownFrom = (s, from, skip) => {
+    for (let i = from; i < s.path.length; i++) if (!skip.has(s.path[i])) return s.path[i];
+    return void 0;
+  };
+  const showCurrent = () => {
+    if (!state.current) return;
+    const skip = skipped(state);
+    if (!skip.has(state.current)) return;
+    const at = state.path.indexOf(state.current);
+    const shown2 = at < 0 ? void 0 : shownFrom(state, at, skip);
+    if (shown2) state = { ...state, current: shown2, furthest: state.furthest === state.current ? shown2 : state.furthest };
+  };
   let unsettled = false;
   let formulasStale = false;
   const settleNow = (needValues = true) => {
@@ -2179,13 +2730,13 @@ function build(definition, options, replaying = false, budget) {
     const errors = { ...state.errors };
     delete errors[id];
     if (batch) {
-      state.values = { ...state.values, [id]: value };
+      state.values = clearFiltered({ ...state.values, [id]: value }, id);
       state.errors = errors;
       log(event);
       unsettled = true;
       return;
     }
-    const { values, path } = settle({ ...state.values, [id]: value }, state.hidden);
+    const { values, path } = settle(clearFiltered({ ...state.values, [id]: value }, id), state.hidden);
     emit({ ...state, values, path, errors, events: log(event) });
   };
   const engine = {
@@ -2216,19 +2767,21 @@ function build(definition, options, replaying = false, budget) {
         return false;
       }
       const at = state.path.indexOf(state.current);
-      const target = state.path[at + 1];
+      const target = shownFrom(state, at + 1, skipped(state));
       if (!target) {
         emit({ ...state, events });
         return true;
       }
-      emit({ ...state, current: target, history: [...state.history, state.current], events });
+      const furthest = state.furthest && state.path.indexOf(state.furthest) >= state.path.indexOf(target) ? state.furthest : target;
+      emit({ ...state, current: target, history: [...state.history, state.current], furthest, events });
       return true;
     },
     back() {
       if (state.status === "completed") return;
       const history = [...state.history];
+      const skip = skipped(state);
       let previous = history.pop();
-      while (previous && !state.path.includes(previous)) previous = history.pop();
+      while (previous && (!state.path.includes(previous) || skip.has(previous))) previous = history.pop();
       if (!previous) return;
       emit({ ...state, current: previous, history, events: log(stamp({ type: "back" })) });
     },
@@ -2256,15 +2809,27 @@ function build(definition, options, replaying = false, budget) {
       return out;
     }
   };
-  if (options.initialValues) {
+  const fromLink = options.linkParams ? prefillFromLink(definition, options.linkParams, options.initialValues) : {};
+  const initialValues = Object.keys(fromLink).length ? { ...fromLink, ...options.initialValues } : options.initialValues;
+  if (initialValues) {
     const wasBatch = batch;
     batch = true;
-    for (const [id, value] of Object.entries(options.initialValues)) {
+    for (const [id, value] of Object.entries(initialValues)) {
       if (!fields.has(id) || value === void 0) continue;
       answer(id, value, stamp({ type: "answer", field: id, value, source: "prefill" }));
     }
     settleNow();
     batch = wasBatch;
+    showCurrent();
+  }
+  const resumeAt = options.resumeAt;
+  if (resumeAt && !replaying && state.path.includes(resumeAt)) {
+    for (let i = 0; i < state.path.length && state.current !== resumeAt; i++) {
+      if (!engine.next()) {
+        state = { ...state, errors: {} };
+        break;
+      }
+    }
   }
   const apply = (event) => {
     if (event.type === "answer") {
@@ -2274,18 +2839,22 @@ function build(definition, options, replaying = false, budget) {
       }
     } else if (event.type === "next") {
       settleNow(false);
+      showCurrent();
       if (formulasStale && isCalculated(fields.get(state.current ?? ""))) settleNow(true);
       engine.next();
     } else if (event.type === "back") {
       settleNow(false);
+      showCurrent();
       engine.back();
     } else if (event.type === "submit") {
       settleNow();
+      showCurrent();
       engine.submit();
     }
   };
   const finish = () => {
     settleNow();
+    showCurrent();
     batch = false;
     state = { ...state, events: [...state.events] };
   };
@@ -2296,7 +2865,12 @@ function replay(definition, events, options = {}) {
 }
 function replayWithin(definition, events, options, maxWork) {
   const budget = void 0 ;
-  const { engine, apply, finish } = build(definition, { ...options, initialValues: void 0, clock: () => void 0 }, true, budget);
+  const { engine, apply, finish } = build(
+    definition,
+    { ...options, initialValues: void 0, linkParams: void 0, clock: () => void 0 },
+    true,
+    budget
+  );
   try {
     for (const event of events) apply(event);
     finish();
@@ -2305,6 +2879,33 @@ function replayWithin(definition, events, options, maxWork) {
   return engine;
 }
 
+// src/progress.ts
+function furthestReached(state, definition) {
+  const at = (id) => id ? state.path.indexOf(id) : -1;
+  let furthest = Math.max(at(state.current), at(state.furthest));
+  for (const id of state.history) furthest = Math.max(furthest, at(id));
+  const fields = fieldMap(definition);
+  for (let i = state.path.length - 1; i > furthest; i--) {
+    const field2 = fields.get(state.path[i]);
+    if (field2 && !isEmptyValue(own(state.values, field2.id), field2)) {
+      furthest = i;
+      break;
+    }
+  }
+  return furthest >= 0 ? state.path[furthest] : null;
+}
+function formProgress(engine) {
+  const state = engine.getState();
+  const furthest = furthestReached(state, engine.definition);
+  const index = furthest ? state.path.indexOf(furthest) : -1;
+  const fields = fieldMap(engine.definition);
+  let fieldId = null;
+  for (let i = index; i >= 0 && fieldId === null; i--) {
+    if (fields.has(state.path[i])) fieldId = state.path[i];
+  }
+  return { step: index + 1, total: state.path.length, fieldId };
+}
+
 // src/explain.ts
 function explain(source, blockId, options = {}) {
   const input = "getState" in source ? { definition: source.definition, values: source.getState().values, hidden: source.getState().hidden } : source;
@@ -2441,6 +3042,22 @@ function describeCondition(condition, def, fields = fieldMap(def)) {
   return `${left} ${op} ${right}`;
 }
 
-export { CALCULATED_TYPE, COMPUTED_FIELD_TYPES, FORMULA_FUNCTIONS, HIGHLIGHT_NOTE_MESSAGE, MAX_CALCULATED_DECIMALS, MAX_FORMULA_ITEMS, MAX_FORMULA_LENGTH, MAX_FORM_FORMULA_LENGTH, MAX_HIDDEN_STRING_LENGTH, MAX_HIGHLIGHT_NOTE_LENGTH, MAX_HIGHLIGHT_QUOTE_LENGTH, MAX_SETTLE_ITEMS, MAX_TABLE_CELL_LENGTH, MAX_TABLE_COLUMNS, MAX_TIMESTAMP_SECONDS, REQUIRED_MESSAGE, STRUCTURED_FIELD_TYPES, calculatedProps, calculatedValue, canonicalJson, choiceOptions, coerceHidden, coerceHiddenValue, computePath, createForm, dateLimits, defineForm, describeCondition, evaluate, evaluateFormula, explain, f, fingerprint, formatCalculated, formatTimestamp, formulaInput, formulaNumber, formulaRefs, getFieldType, isEmptyValue, isFormEvent, isIsoDate, isJson, isSensitive, listFieldTypes, listLimits, normalizeValue, numberLimits, parseForm, parseFormula, parseTimestamp, ratingDisplay, recall, registerFieldType, renameFormulaKey, replay, ruleVisible, scaleLabels, steps, summarizeValue, tableColumns, tableLimits, validateField, when };
+// src/carry.ts
+function carryAnswers(from, to, answers, extra = {}) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const block of from.blocks) {
+    if (block.kind === "field" && answers[block.id] !== void 0) byKey.set(block.key, answers[block.id]);
+  }
+  for (const [key, value] of Object.entries(extra)) {
+    if (value !== null && value !== void 0 && !byKey.has(key)) byKey.set(key, value);
+  }
+  const out = {};
+  for (const block of to.blocks) {
+    if (block.kind === "field" && byKey.has(block.key)) out[block.id] = byKey.get(block.key);
+  }
+  return out;
+}
+
+export { CALCULATED_TYPE, CHOICE_FIELD_TYPES, COMPUTED_FIELD_TYPES, DEFAULT_PHOTO_FILES, DEFAULT_PHOTO_SIZE_MB, FORMULA_FUNCTIONS, HIGHLIGHT_NOTE_MESSAGE, MAX_CALCULATED_DECIMALS, MAX_FORMULA_ITEMS, MAX_FORMULA_LENGTH, MAX_FORM_FORMULA_LENGTH, MAX_HIDDEN_STRING_LENGTH, MAX_HIGHLIGHT_NOTE_LENGTH, MAX_HIGHLIGHT_QUOTE_LENGTH, MAX_PHOTO_FILES, MAX_PHOTO_ID_LENGTH, MAX_PHOTO_NAME_LENGTH, MAX_PHOTO_SIZE_MB, MAX_PREFILL_PARAM_LENGTH, MAX_SETTLE_ITEMS, MAX_TABLE_CELL_LENGTH, MAX_TABLE_COLUMNS, MAX_TIMESTAMP_SECONDS, OPTION_LIMITS, OTHER_MAX_LENGTH, PHOTO_FORMATS, PHOTO_TYPE, REQUIRED_MESSAGE, SEARCHABLE_OPTION_COUNT, STRUCTURED_FIELD_TYPES, UPLOAD_FIELD_TYPES, answerSnapshots, answersFromSnapshots, answersOnPath, calculatedProps, calculatedValue, canonicalJson, carryAnswers, choiceOptions, clearFilteredAnswers, coerceHidden, coerceHiddenValue, computePath, createForm, dateLimits, defineForm, describeCondition, evaluate, evaluateFormula, explain, f, filteredChoiceError, fingerprint, formProgress, formatCalculated, formatTimestamp, formulaInput, formulaNumber, formulaRefs, furthestReached, getFieldType, hasOptionFilters, hiddenByPrefill, isEmptyValue, isFormEvent, isHttpsUrl, isIsoDate, isJson, isOtherValue, isPhotoFormat, isPhotoRef, isPrefillParam, isSearchable, isSensitive, listFieldTypes, listLimits, normalizeValue, numberLimits, optionFilter, optionJson, optionMatches, optionsSource, otherOption, parseForm, parseFormula, parseTimestamp, photoCountMessage, photoFormatList, photoLimits, photoRefs, photoSizeMessage, photoTypeMessage, prefillFromLink, prefillSetting, ratingDisplay, readOption, recall, registerFieldType, renameFormulaKey, replay, respondentPath, ruleVisible, scaleLabels, searchOptions, steps, summarizeValue, tableColumns, tableLimits, validateField, visibleOptions, when, withHostOptions };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map