@bettercms-ai/kit 0.1.1 → 2.0.0

package/dist/adapters/values.js

@@ -0,0 +1,623 @@
+import { BUTTON_SIZES, BUTTON_VARIANTS, DOCK_ICON_NAME_SET, LINK_RELS, LINK_VALUE_TYPES, VIDEO_VALUE_KEYS } from "./prod-types.js";
+//#region src/adapters/values.ts
+var isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+/** The keys only a button carries; a link field never stores them. */
+var BUTTON_ONLY = [
+	"style",
+	"variant",
+	"size",
+	"arrow",
+	"icon",
+	"fullWidth"
+];
+var isScriptHref = (href) => /^(javascript|data|vbscript):/i.test(href.replace(/[\u0000- \u007F]/g, ""));
+/**
+* F1 stores the V2 link object as sent (link-value.ts: the kit's pageId, entryId, anchor, email, phone, label… are
+* kept), plus `ref` for a page / entry link so delivery resolves it. A bare href string stays a string.
+*/
+function linkToProd(v) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	if (typeof v === "string") return isScriptHref(v) ? {
+		value: null,
+		lost: [""]
+	} : {
+		value: v,
+		lost: []
+	};
+	if (isScriptHref(v.href)) return {
+		value: null,
+		lost: [""]
+	};
+	const lost = [];
+	const out = {};
+	for (const [k, x] of Object.entries(v)) if (BUTTON_ONLY.includes(k)) lost.push(k);
+	else out[k] = x;
+	if (v.type !== void 0 && !LINK_VALUE_TYPES.includes(v.type)) {
+		lost.push("type");
+		delete out.type;
+	}
+	if (typeof v.newTab === "boolean" && v.target !== void 0 && v.newTab !== (v.target === "_blank")) {
+		lost.push("target");
+		delete out.target;
+	}
+	const ref = v.type === "page" ? v.pageId : v.type === "entry" ? v.entryId : void 0;
+	if (ref) out.ref = ref;
+	return {
+		value: out,
+		lost
+	};
+}
+function linkFromProd(v) {
+	if (typeof v === "string") return v;
+	if (!isObj(v) || typeof v.href !== "string") return null;
+	const { ref, ...rest } = v;
+	const out = rest;
+	if (typeof ref === "string") {
+		if (out.type === "page" && out.pageId === void 0) out.pageId = ref;
+		if (out.type === "entry" && out.entryId === void 0) out.entryId = ref;
+	}
+	return out;
+}
+/**
+* A V2 button is a link with a label and a look, flattened. Prod's ButtonValue reads `label`, `href` (string or link
+* object), `variant`, `size`, `arrow`, `icon` (a dock icon name), `newTab`, `rel`; other keys are kept and ignored,
+* so the link half (type, pageId, anchor…) rides along as sent. The look is written as `variant` (what renderers read).
+*/
+function buttonToProd(v) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	if (typeof v.href === "string" && isScriptHref(v.href)) return {
+		value: null,
+		lost: [""]
+	};
+	const lost = [];
+	const out = { ...v };
+	const valid = (x) => typeof x === "string" && BUTTON_VARIANTS.includes(x);
+	const look = [v.variant, v.style].find(valid);
+	if (look !== void 0) out.variant = look;
+	else delete out.variant;
+	if (v.variant !== void 0 && !valid(v.variant)) lost.push("variant");
+	if (v.style !== void 0 && v.variant !== void 0 && v.style === v.variant) lost.push("variant");
+	if (v.size !== void 0 && !BUTTON_SIZES.includes(v.size)) {
+		lost.push("size");
+		delete out.size;
+	}
+	if (v.icon !== void 0 && !DOCK_ICON_NAME_SET.has(v.icon)) {
+		lost.push("icon");
+		delete out.icon;
+	}
+	if (v.rel !== void 0 && !LINK_RELS.includes(v.rel)) {
+		lost.push("rel");
+		delete out.rel;
+	}
+	if (typeof v.newTab === "boolean" && v.target !== void 0 && v.newTab !== (v.target === "_blank")) {
+		lost.push("target");
+		delete out.target;
+	}
+	if (v.fullWidth !== void 0 && typeof v.fullWidth !== "boolean") {
+		lost.push("fullWidth");
+		delete out.fullWidth;
+	}
+	if (typeof out.label !== "string") {
+		out.label = "";
+		lost.push("label");
+	}
+	if (typeof out.href !== "string") {
+		out.href = "";
+		lost.push("href");
+	}
+	return {
+		value: out,
+		lost: [...new Set(lost)]
+	};
+}
+function buttonFromProd(v) {
+	if (!isObj(v)) return null;
+	const out = { ...v };
+	if (isObj(v.href)) {
+		const link = linkFromProd(v.href);
+		if (isObj(link)) Object.assign(out, link);
+	}
+	if (out.style !== void 0 && out.variant === out.style) delete out.variant;
+	if (out.icon === null) delete out.icon;
+	if ((out.label === void 0 || out.label === "") && out.href === "#") out.href = "";
+	return out;
+}
+var ZONED = /^(.*)\[([^\]]+)\]$/;
+var NO_SECONDS = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2})(Z|[+-]\d{2}:?\d{2})?$/;
+var OFFSET = /(?:Z|[+-]\d{2}:?\d{2})$/;
+/** A date is the same "YYYY-MM-DD" string on both sides. */
+var dateToProd = (v) => ({
+	value: v ?? null,
+	lost: []
+});
+var dateFromProd = (v) => typeof v === "string" ? v : null;
+/**
+* V2 stores RFC 9557 (`2026-10-14T09:00:00+05:30[Asia/Kolkata]`). Prod keeps the ISO instant with seconds and its
+* offset; a `[Zone]` suffix is checked and dropped on write. So the zone survives only as the field's own
+* `config.timezone` when that names it (pass it as `zone`); otherwise it is lost.
+*/
+function datetimeToProd(v, opts = {}) {
+	if (v == null || v === "") return {
+		value: v ?? null,
+		lost: []
+	};
+	const lost = [];
+	const m = ZONED.exec(v);
+	let bare = m ? m[1] : v;
+	if (m && (m[2] !== opts.zone || !OFFSET.test(bare))) lost.push("zone");
+	const short = NO_SECONDS.exec(bare);
+	if (short) {
+		bare = `${short[1]}:00${short[2] ?? ""}`;
+		lost.push("format");
+	}
+	return {
+		value: bare,
+		lost
+	};
+}
+function datetimeFromProd(v, opts = {}) {
+	if (typeof v !== "string") return null;
+	const zone = opts.zone && opts.zone !== "site" ? opts.zone : void 0;
+	return zone && OFFSET.test(v) && !ZONED.test(v) ? `${v}[${zone}]` : v;
+}
+var CROPS = {
+	"16:9": 16 / 9,
+	"4:3": 4 / 3,
+	"1:1": 1,
+	"4:5": 4 / 5
+};
+var round = (n) => Math.round(n * 1e6) / 1e6;
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+/** A crop preset → the centred-on-focal rect prod stores. Needs the image's pixel size. */
+function cropRect(crop, width, height, focal = {
+	x: 50,
+	y: 50
+}) {
+	if (crop === "original" || !(width > 0 && height > 0)) return void 0;
+	const want = CROPS[crop];
+	const have = width / height;
+	const w = want < have ? want / have : 1;
+	const h = want < have ? 1 : have / want;
+	const left = clamp01(Math.min(1 - w, Math.max(0, focal.x / 100 - w / 2)));
+	const top = clamp01(Math.min(1 - h, Math.max(0, focal.y / 100 - h / 2)));
+	return {
+		top: round(top),
+		right: round(1 - left - w),
+		bottom: round(1 - top - h),
+		left: round(left)
+	};
+}
+/** A stored rect → the preset whose aspect it cuts (within 1%), when the image's pixel size is known. */
+function cropPreset(rect, width, height) {
+	const w = (1 - rect.left - rect.right) * width;
+	const h = (1 - rect.top - rect.bottom) * height;
+	if (!(w > 0 && h > 0)) return void 0;
+	const ratio = w / h;
+	return Object.entries(CROPS).find(([, r]) => Math.abs(ratio - r) / r < .01)?.[0];
+}
+/**
+* The contract holds against `imageFromProd(value)` with no asset (how stored defaults are read): a crop rect needs the
+* image's pixel size to read back as its preset, and width / height / size live on the asset, so all four are named in
+* `lost`. Passing the asset to imageFromProd restores them.
+*/
+function imageToProd(v) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	if (typeof v === "string") return {
+		value: v,
+		lost: []
+	};
+	const lost = [];
+	const out = { url: v.url };
+	if (v.id !== void 0) out.id = v.id;
+	if (v.name !== void 0) out.name = v.name;
+	if (v.alt !== void 0) out.altText = v.alt;
+	if (v.focal) out.focal = {
+		x: round(v.focal.x / 100),
+		y: round(v.focal.y / 100)
+	};
+	if (isCropRect(v.crop)) out.crop = {
+		top: v.crop.top,
+		right: v.crop.right,
+		bottom: v.crop.bottom,
+		left: v.crop.left
+	};
+	else if (typeof v.crop === "string" && v.crop !== "original") {
+		const rect = v.width && v.height ? cropRect(v.crop, v.width, v.height, v.focal) : void 0;
+		if (rect) out.crop = rect;
+		else lost.push("crop");
+	}
+	for (const k of [
+		"caption",
+		"width",
+		"height",
+		"size"
+	]) if (v[k] !== void 0) lost.push(k);
+	for (const k of Object.keys(v)) if (![
+		"url",
+		"id",
+		"name",
+		"alt",
+		"focal",
+		"crop",
+		"caption",
+		"width",
+		"height",
+		"size"
+	].includes(k)) lost.push(k);
+	return {
+		value: out,
+		lost
+	};
+}
+/** A crop window as prod stores it: four 0–1 edges that leave something on both axes. */
+function isCropRect(v) {
+	if (!isObj(v)) return false;
+	const { top, right, bottom, left } = v;
+	const num = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 && n <= 1;
+	return num(top) && num(right) && num(bottom) && num(left) && top + bottom < 1 && left + right < 1;
+}
+/**
+* Pass the asset's pixel size to read a stored crop rect back as its preset and to restore width / height / size.
+* An older value written as `{ src, alt }` (the block's own image props) reads as the same picture and alt text.
+*/
+function imageFromProd(v, asset = {}) {
+	if (typeof v === "string") return v;
+	if (!isObj(v)) return null;
+	const url = typeof v.url === "string" ? v.url : typeof v.src === "string" ? v.src : null;
+	if (url === null) return null;
+	const p = v;
+	const out = { url };
+	if (p.id !== void 0) out.id = p.id;
+	if (p.name !== void 0) out.name = p.name;
+	if (p.altText !== void 0) out.alt = p.altText;
+	else if (typeof p.alt === "string") out.alt = p.alt;
+	if (p.focal) out.focal = {
+		x: round(p.focal.x * 100),
+		y: round(p.focal.y * 100)
+	};
+	if (isCropRect(p.crop)) out.crop = (asset.width && asset.height ? cropPreset(p.crop, asset.width, asset.height) : void 0) ?? { ...p.crop };
+	if (asset.width !== void 0) out.width = asset.width;
+	if (asset.height !== void 0) out.height = asset.height;
+	if (asset.size !== void 0) out.size = asset.size;
+	return out;
+}
+/**
+* A V2 reference value is the target's id. Prod reads a bare id as an ENTRY on a prop reference that takes entries
+* (backend acceptsEntries), so a page, form or collection picked there travels in the kit as `"<kind>:<id>"` (the
+* dock's reference services hand such picks back tagged) and is stored as `{ kind, id }` (targetRefOf). A stored
+* `{ kind, id }` reads back tagged, whatever the field takes, so a save writes the same target back.
+*/
+var TARGET_TAG = /^(page|form|collection):(.+)$/;
+var targetTag = (kind, id) => `${kind}:${id}`;
+function parseTargetTag(v) {
+	const m = TARGET_TAG.exec(v);
+	return m ? {
+		kind: m[1],
+		id: m[2]
+	} : null;
+}
+var isTargetRef = (v) => isObj(v) && typeof v.kind === "string" && TARGET_TAG.test(`${v.kind}:x`) && typeof v.id === "string" && v.id !== "";
+/**
+* V2 stores the target id (`"en_12"`; a list for many). Prod stores the same id, or `{ entryId, modelSlug }` on a
+* polymorphic field (pass `modelSlug`), or `{ formId }` on a component `form` prop (`to: "form"`), or `{ kind, id }` for
+* a tagged page / form / collection pick (`"page:pg_1"`).
+*/
+function referenceToProd(v, opts = {}) {
+	if (v == null || v === "") return {
+		value: null,
+		lost: []
+	};
+	if (Array.isArray(v)) return {
+		value: v.map((x) => parseTargetTag(x) ?? x),
+		lost: []
+	};
+	if (opts.to === "form") return {
+		value: { formId: v },
+		lost: []
+	};
+	const target = parseTargetTag(v);
+	if (target) return {
+		value: target,
+		lost: []
+	};
+	if (opts.modelSlug) return {
+		value: {
+			entryId: v,
+			modelSlug: opts.modelSlug
+		},
+		lost: []
+	};
+	return {
+		value: v,
+		lost: []
+	};
+}
+var refId = (v) => typeof v === "string" ? v || null : isTargetRef(v) ? targetTag(v.kind, v.id) : isObj(v) ? typeof v.entryId === "string" && v.entryId || typeof v.formId === "string" && v.formId || null : null;
+function referenceFromProd(v) {
+	if (Array.isArray(v)) return v.map(refId).filter((x) => !!x);
+	return refId(v);
+}
+/**
+* Prod has no table type: the schema adapter stores a V2 table as a `json` field (named in the lossy ledger), and
+* `json` keeps any JSON value, so the TableValue itself is stored verbatim (typed columns, groups, footer,
+* footnotes, caption, design, jsonLd).
+*/
+function tableToProd(v) {
+	return {
+		value: v == null ? null : JSON.parse(JSON.stringify(v)),
+		lost: []
+	};
+}
+var tableFromProd = (v) => isObj(v) ? v : null;
+var SCALE_UNITS = [
+	"px",
+	"%",
+	"rem",
+	"em",
+	"vw",
+	"vh"
+];
+/**
+* Prod stores the three V2 scale shapes as they are (CPO D41, reference-validation.ts scaleValueProblem): a bare number,
+* a token step's string, a custom `{ value, unit }`. Pass the field's scale: a token it does not list, or a custom value
+* it does not allow (allowCustom off, a unit outside its units, past its bounds), is refused by the backend, so it is
+* not written (`lost: [""]`). With no scale only a number is known to fit.
+*/
+function scaleToProd(v, scale) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	if (typeof v === "number") return Number.isFinite(v) ? {
+		value: v,
+		lost: []
+	} : {
+		value: null,
+		lost: [""]
+	};
+	const refused = {
+		value: null,
+		lost: [""]
+	};
+	if (!scale) return refused;
+	if (typeof v === "string") return Array.isArray(scale.steps) && scale.steps.some((x) => x.value === v) ? {
+		value: v,
+		lost: []
+	} : refused;
+	if (!isObj(v) || !scale.allowCustom || typeof v.value !== "number" || !Number.isFinite(v.value) || Object.keys(v).some((k) => k !== "value" && k !== "unit")) return refused;
+	const custom = typeof scale.allowCustom === "object" ? scale.allowCustom : {};
+	if (!(custom.units ?? scale.units ?? SCALE_UNITS).includes(v.unit)) return refused;
+	const bound = (b) => typeof b === "number" ? b : b?.[v.unit];
+	const min = bound(custom.min);
+	const max = bound(custom.max);
+	if (min !== void 0 && v.value < min || max !== void 0 && v.value > max) return refused;
+	return {
+		value: {
+			value: v.value,
+			unit: v.unit
+		},
+		lost: []
+	};
+}
+function scaleFromProd(v) {
+	if (typeof v === "number") return Number.isFinite(v) ? v : null;
+	if (typeof v === "string") return v;
+	if (isObj(v) && typeof v.value === "number" && typeof v.unit === "string" && SCALE_UNITS.includes(v.unit)) return {
+		value: v.value,
+		unit: v.unit
+	};
+	return null;
+}
+/** An http(s) URL or a site path; "" is an unset one (video-value.ts isVideoUrl). */
+var isVideoUrl = (s) => s === "" || /^https?:\/\/[^\s]+$/i.test(s.trim()) || /^\/(?!\/)\S*$/.test(s.trim());
+/**
+* The V2 video value and prod's are the same shape: a URL string, or `{ url, poster?, autoplay?, loop?, transcript? }`
+* (the video block's props). The backend refuses any other key, and a url or poster that is not an http(s) URL or a
+* site path (video_value_invalid): another key is left out and named, a bad url refuses the value whole.
+*/
+function videoToProd(v) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	if (typeof v === "string") return isVideoUrl(v) ? {
+		value: v,
+		lost: []
+	} : {
+		value: null,
+		lost: [""]
+	};
+	if (!isObj(v) || typeof v.url !== "string" || !isVideoUrl(v.url)) return {
+		value: null,
+		lost: [""]
+	};
+	const lost = [];
+	const out = {};
+	for (const [k, x] of Object.entries(v)) if (!VIDEO_VALUE_KEYS.includes(k) ? false : k === "url" ? true : k === "poster" ? typeof x === "string" && isVideoUrl(x) : k === "transcript" ? typeof x === "string" && x.length <= 1e5 : typeof x === "boolean") out[k] = x;
+	else if (x !== void 0) lost.push(k);
+	return {
+		value: out,
+		lost
+	};
+}
+function videoFromProd(v) {
+	if (typeof v === "string") return v;
+	if (!isObj(v) || typeof v.url !== "string") return null;
+	return { ...v };
+}
+/**
+* A V2 list of one primitive (`of: [{ type }]`) is a prod `array` with `config.itemType`, each item judged and normalized
+* as a field of its type: an image item stores prod's image keys (altText, 0–1 focal), a link item its stored link. Scalar
+* and rich text items pass as they are. `lost` names `<index>/<key>` (or `<index>` for a whole item) per item.
+*/
+function listToProd(v, itemType) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	if (!Array.isArray(v)) return {
+		value: null,
+		lost: [""]
+	};
+	const lost = [];
+	const out = [];
+	v.forEach((x, i) => {
+		const r = itemType === "image" ? imageToProd(x) : itemType === "link" ? linkToProd(x) : {
+			value: x,
+			lost: []
+		};
+		for (const l of r.lost) lost.push(l ? `${i}/${l}` : String(i));
+		out.push(r.value);
+	});
+	return {
+		value: out,
+		lost
+	};
+}
+function listFromProd(v, itemType) {
+	if (!Array.isArray(v)) return [];
+	return itemType === "image" ? v.map((x) => imageFromProd(x)) : itemType === "link" ? v.map((x) => linkFromProd(x)) : [...v];
+}
+/**
+* The backend judges tags trimmed and case-insensitively (reference-validation.ts tagsValueProblem): a field write
+* trims and de-dupes, a prop value is refused (tags_value_invalid). So the value is written clean for both: trimmed,
+* first spelling of a case-repeat kept, and an empty, over-long, off-list (`allowCustom: false`) or over-`max` tag left
+* out. `lost` names each changed or dropped tag by its index in `v`.
+*/
+function tagsToProd(v, opts = {}) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	const allowed = opts.allowCustom === false ? new Set((opts.options ?? []).map((o) => (typeof o === "string" ? o : o.value).trim().toLowerCase())) : void 0;
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const lost = [];
+	v.forEach((x, i) => {
+		const t = typeof x === "string" ? x.trim() : "";
+		const folded = t.toLowerCase();
+		const keep = t !== "" && Array.from(t).length <= 64 && !seen.has(folded) && (!allowed || allowed.has(folded)) && (opts.max === void 0 || out.length < opts.max);
+		if (keep) {
+			seen.add(folded);
+			out.push(t);
+		}
+		if (!keep || t !== x) lost.push(String(i));
+	});
+	return {
+		value: out,
+		lost
+	};
+}
+var tagsFromProd = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+/**
+* A prod rating runs from config.min (0 unset) to config.max (5 unset) in steps of config.step (1 unset), and 0 is "not
+* rated" on every scale (validation-parity.ts ratingScale / onRatingScale). V2's empty rating is null: it is written as
+* null, and any other number off the scale is refused by the backend (rating_value_invalid), so it is not written either.
+*/
+function ratingToProd(v, opts = {}) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	const min = opts.min ?? 0;
+	const max = opts.max ?? 5;
+	const step = opts.step ?? 1;
+	const steps = (v - min) / step;
+	return Number.isFinite(v) && v >= min && v <= max && Math.abs(steps - Math.round(steps)) < 1e-9 ? {
+		value: v,
+		lost: []
+	} : {
+		value: null,
+		lost: [""]
+	};
+}
+/** A stored number back; 0 on a scale that starts above it is prod's "not rated", which V2 holds as null. */
+function ratingFromProd(v, opts = {}) {
+	if (typeof v !== "number" || !Number.isFinite(v)) return null;
+	return v === 0 && (opts.min ?? 0) > 0 ? null : v;
+}
+/**
+* Prod stores a code value as a string, or `{ language?, code }` (no other key). A language outside the field's
+* `config.languages` is refused by the backend (code_value_invalid), so it is left out and named; a value over
+* CODE_MAX_LENGTH characters is refused whole.
+*/
+function codeToProd(v, opts = {}) {
+	if (v == null) return {
+		value: null,
+		lost: []
+	};
+	const code = typeof v === "string" ? v : v.code;
+	if (typeof code !== "string" || code.length > 1e5) return {
+		value: null,
+		lost: [""]
+	};
+	if (typeof v === "string") return {
+		value: v,
+		lost: []
+	};
+	const lost = Object.keys(v).filter((k) => k !== "code" && k !== "language");
+	const out = { code };
+	if (v.language !== void 0) {
+		if (typeof v.language === "string" && (!opts.languages || opts.languages.includes(v.language))) out.language = v.language;
+		else lost.push("language");
+	}
+	return {
+		value: out,
+		lost
+	};
+}
+function codeFromProd(v) {
+	if (typeof v === "string") return v;
+	if (!isObj(v) || typeof v.code !== "string") return null;
+	return typeof v.language === "string" ? {
+		language: v.language,
+		code: v.code
+	} : { code: v.code };
+}
+/** A V2 list of object items is stored by prod as the repeatable zone of its array: `{ repeatable: [...] }`. */
+var zoneListToProd = (v) => ({ repeatable: v ? [...v] : [] });
+var zoneListFromProd = (v) => isObj(v) && Array.isArray(v.repeatable) ? [...v.repeatable] : Array.isArray(v) ? [...v] : [];
+var isTypedRow = (v) => isObj(v) && typeof v._type === "string" && v._type !== "";
+/**
+* V2 rows → the stored rows. Prod keeps V2's own row shape, so a row passes as it is after `mapRow` (its fields through
+* their plans); a row with no `_type` has no item type to be judged by (item_type_required) and is named, by index.
+*/
+function typedRowsToProd(v, mapRow = (r) => ({ ...r })) {
+	if (v == null) return {
+		value: v ?? null,
+		lost: []
+	};
+	if (!Array.isArray(v)) return {
+		value: v,
+		lost: ["(value)"]
+	};
+	const lost = [];
+	return {
+		value: v.map((row, i) => {
+			if (isTypedRow(row)) return mapRow(row, i);
+			lost.push(String(i));
+			return row;
+		}),
+		lost
+	};
+}
+/** Stored rows → V2 rows: the same shape, each row through `mapRow`; a row that is not typed passes as stored. */
+function typedRowsFromProd(v, mapRow = (r) => ({ ...r })) {
+	if (!Array.isArray(v)) return v;
+	return v.map((row, i) => isTypedRow(row) ? mapRow(row, i) : row);
+}
+/** A dock icon name passes through; anything else is not a prod icon. */
+var isDockIcon = (v) => typeof v === "string" && DOCK_ICON_NAME_SET.has(v);
+//#endregion
+export { buttonFromProd, buttonToProd, codeFromProd, codeToProd, cropPreset, cropRect, dateFromProd, dateToProd, datetimeFromProd, datetimeToProd, imageFromProd, imageToProd, isCropRect, isDockIcon, linkFromProd, linkToProd, listFromProd, listToProd, parseTargetTag, ratingFromProd, ratingToProd, referenceFromProd, referenceToProd, scaleFromProd, scaleToProd, tableFromProd, tableToProd, tagsFromProd, tagsToProd, targetTag, typedRowsFromProd, typedRowsToProd, videoFromProd, videoToProd, zoneListFromProd, zoneListToProd };
+
+//# sourceMappingURL=values.js.map