@riverbankcms/sdk 0.72.0 → 0.75.0

package/dist/client/chunk-PMAIXMAB.mjs

@@ -0,0 +1,1960 @@
+import { jsx } from 'react/jsx-runtime';
+
+// ../../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+var clsx_default = clsx;
+
+// ../core/src/branded.ts
+var asMediaAssetId = (id) => id;
+var asFormId = (id) => id;
+var asPassId = (id) => id;
+var asCustomerPassId = (id) => id;
+var asAppointmentServiceId = (id) => id;
+var asAppointmentResourceId = (id) => id;
+
+// ../core/src/date-math.ts
+function addDaysToDate(date, dayCount) {
+  const next = new Date(date);
+  next.setUTCDate(next.getUTCDate() + dayCount);
+  return next;
+}
+function addDaysToIso(isoString, dayCount) {
+  const date = new Date(isoString);
+  if (!Number.isFinite(date.getTime())) {
+    return isoString;
+  }
+  return addDaysToDate(date, dayCount).toISOString();
+}
+function subtractDaysFromIso(isoString, dayCount) {
+  return addDaysToIso(isoString, -dayCount);
+}
+
+// ../core/src/booking-flexible-balance.ts
+function clampFlexibleBalanceConfiguredAmount(amountCents, totalAmountCents) {
+  return Math.max(0, Math.min(amountCents, totalAmountCents));
+}
+function resolveFlexibleBalanceInitialPaymentCents(input) {
+  return clampFlexibleBalanceConfiguredAmount(
+    input.config.upfrontAmountCents,
+    input.totalAmountCents
+  );
+}
+function resolveFlexibleBalanceDueAt(input) {
+  switch (input.dueDateRule.kind) {
+    case "relative_to_start_date":
+      return subtractDaysFromIso(
+        input.bookingStartAt,
+        input.dueDateRule.daysBeforeStart
+      );
+    case "fixed_calendar_date":
+      return input.dueDateRule.dueAt;
+    default:
+      return assertNever(input.dueDateRule);
+  }
+}
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+// ../core/src/booking-instalments.ts
+function isDepositBearingBookingInstalmentPlan(plan) {
+  switch (plan.kind) {
+    case "deposit_plus_one_remainder":
+    case "deposit_plus_scheduled_instalments":
+      return true;
+    case "equal_scheduled_instalments":
+      return false;
+    default:
+      return assertNever2(plan);
+  }
+}
+function getBookingInstalmentDepositRefundability(plan) {
+  return isDepositBearingBookingInstalmentPlan(plan) ? plan.depositRefundability : null;
+}
+function clampConfiguredAmount(amountCents, totalAmountCents) {
+  return Math.max(0, Math.min(amountCents, totalAmountCents));
+}
+function splitAmountWithRemainderInFirst(totalAmountCents, partCount) {
+  if (partCount <= 0) {
+    return [];
+  }
+  const baseAmountCents = Math.floor(totalAmountCents / partCount);
+  const remainderCents = totalAmountCents - baseAmountCents * partCount;
+  return Array.from({ length: partCount }, (_, index) => index === 0 ? baseAmountCents + remainderCents : baseAmountCents);
+}
+function addIntervalPreservingMonthAnchor(isoString, intervalCount, intervalUnit) {
+  const date = new Date(isoString);
+  if (!Number.isFinite(date.getTime())) {
+    return isoString;
+  }
+  switch (intervalUnit) {
+    case "day":
+      date.setUTCDate(date.getUTCDate() + intervalCount);
+      return date.toISOString();
+    case "week":
+      date.setUTCDate(date.getUTCDate() + intervalCount * 7);
+      return date.toISOString();
+    case "month":
+      return addMonthsPreservingAnchorDay(date, intervalCount).toISOString();
+    default:
+      return assertNever2(intervalUnit);
+  }
+}
+function getBookingInstalmentPlanIntervalCount(plan) {
+  switch (plan.kind) {
+    case "deposit_plus_one_remainder":
+      return plan.remainderDueCount;
+    case "deposit_plus_scheduled_instalments":
+    case "equal_scheduled_instalments":
+      return plan.intervalCount;
+    default:
+      return assertNever2(plan);
+  }
+}
+function omitZeroAmountFutureRows(rows) {
+  if (rows.length <= 1) {
+    return rows;
+  }
+  const [firstRow, ...futureRows] = rows;
+  if (!firstRow) {
+    return [];
+  }
+  return [
+    firstRow,
+    ...futureRows.filter((row) => row.amountCents > 0)
+  ];
+}
+function addMonthsPreservingAnchorDay(date, intervalCount) {
+  const anchorDay = date.getUTCDate();
+  const nextMonth = new Date(Date.UTC(
+    date.getUTCFullYear(),
+    date.getUTCMonth() + intervalCount,
+    1,
+    date.getUTCHours(),
+    date.getUTCMinutes(),
+    date.getUTCSeconds(),
+    date.getUTCMilliseconds()
+  ));
+  const lastDayOfTargetMonth = new Date(Date.UTC(
+    nextMonth.getUTCFullYear(),
+    nextMonth.getUTCMonth() + 1,
+    0
+  )).getUTCDate();
+  nextMonth.setUTCDate(Math.min(anchorDay, lastDayOfTargetMonth));
+  return nextMonth;
+}
+function assertNever2(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+// ../core/src/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// ../core/src/booking-date-time.ts
+var DEFAULT_LOCALE = "en-US";
+var FALLBACK_TIMEZONE = "UTC";
+var LOCAL_DATE_PATTERN = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/u;
+function isValidTimeZone(timeZone) {
+  try {
+    new Intl.DateTimeFormat(DEFAULT_LOCALE, { timeZone }).format(/* @__PURE__ */ new Date());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getSafeTimeZone(timeZone) {
+  const normalized = typeof timeZone === "string" ? timeZone.trim() : "";
+  return normalized && isValidTimeZone(normalized) ? normalized : FALLBACK_TIMEZONE;
+}
+function parseStrictBookingTimeZone(timeZone) {
+  const normalized = timeZone.trim();
+  if (!normalized || !isValidTimeZone(normalized)) {
+    return null;
+  }
+  return normalized;
+}
+function formatParseError(error) {
+  switch (error.reason) {
+    case "invalid_starts_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in startsAt, received "${error.value}"`;
+    case "invalid_ends_at":
+      return `Expected a valid UTC/offset-aware ISO datetime in endsAt, received "${error.value ?? ""}"`;
+    case "invalid_time_zone":
+      return `Expected a valid IANA timezone in timeZone, received "${error.value}"`;
+  }
+}
+function formatToPartsLookup(date, locale, timeZone, format) {
+  return new Map(
+    new Intl.DateTimeFormat(locale, {
+      ...format,
+      timeZone
+    }).formatToParts(date).map((part) => [part.type, part.value])
+  );
+}
+function getZonedDateTimeParts(date, timeZone) {
+  const parts = formatToPartsLookup(date, "en-GB", timeZone, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const read = (type) => Number(parts.get(type) ?? "");
+  return {
+    year: read("year"),
+    month: read("month"),
+    day: read("day"),
+    hour: read("hour"),
+    minute: read("minute"),
+    second: read("second")
+  };
+}
+function formatDateKey(date) {
+  const year = String(date.year).padStart(4, "0");
+  const month = String(date.month).padStart(2, "0");
+  const day = String(date.day).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function toBookingTimeZone(timeZone) {
+  return getSafeTimeZone(timeZone);
+}
+var DEFAULT_BOOKING_TIME_ZONE = FALLBACK_TIMEZONE;
+function resolveBookingTimeZoneId(...candidates) {
+  for (const candidate of candidates) {
+    const normalized = typeof candidate === "string" ? candidate.trim() : "";
+    if (normalized && isValidTimeZone(normalized)) {
+      return normalized;
+    }
+  }
+  return FALLBACK_TIMEZONE;
+}
+function parseUtcIsoDateTimeString(value) {
+  const normalized = value.trim();
+  const hasUtcSuffix = normalized.endsWith("Z");
+  const hasExplicitOffset = /[+-]\d{2}:\d{2}$/u.test(normalized);
+  if (!hasUtcSuffix && !hasExplicitOffset) {
+    return err("missing-timezone-offset");
+  }
+  const date = new Date(normalized);
+  if (Number.isNaN(date.getTime())) {
+    return err("invalid-date-time");
+  }
+  return ok(date.toISOString());
+}
+function toUtcIsoDateTimeString(value) {
+  const parsed = parseUtcIsoDateTimeString(value);
+  if (!parsed.ok) {
+    const message = parsed.error === "missing-timezone-offset" ? `Expected an offset-aware ISO datetime, received "${value}"` : `Expected a valid ISO datetime, received "${value}"`;
+    throw new Error(message);
+  }
+  return parsed.value;
+}
+function parseScheduledBookingDateTime(input) {
+  try {
+    const startsAt = toUtcIsoDateTimeString(input.startsAt);
+    const timeZone = parseStrictBookingTimeZone(input.timeZone);
+    if (!timeZone) {
+      return {
+        ok: false,
+        field: "timeZone",
+        reason: "invalid_time_zone",
+        value: input.timeZone
+      };
+    }
+    return {
+      ok: true,
+      value: {
+        startsAt,
+        timeZone,
+        locale: input.locale
+      }
+    };
+  } catch {
+    return {
+      ok: false,
+      field: "startsAt",
+      reason: "invalid_starts_at",
+      value: input.startsAt
+    };
+  }
+}
+function parseScheduledBookingDateRange(input) {
+  const start = parseScheduledBookingDateTime(input);
+  if (!start.ok) {
+    return start;
+  }
+  if (input.endsAt == null) {
+    return {
+      ok: true,
+      value: start.value
+    };
+  }
+  try {
+    return {
+      ok: true,
+      value: {
+        ...start.value,
+        endsAt: toUtcIsoDateTimeString(input.endsAt)
+      }
+    };
+  } catch {
+    return {
+      ok: false,
+      field: "endsAt",
+      reason: "invalid_ends_at",
+      value: input.endsAt
+    };
+  }
+}
+function toScheduledBookingDateTime(input) {
+  const result = parseScheduledBookingDateTime(input);
+  if (result.ok) {
+    return result.value;
+  }
+  throw new Error(formatParseError(result));
+}
+function toScheduledBookingDateRange(input) {
+  const result = parseScheduledBookingDateRange(input);
+  if (result.ok) {
+    return result.value;
+  }
+  throw new Error(formatParseError(result));
+}
+function formatBookingInstant(isoString, options) {
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) {
+    return isoString;
+  }
+  return new Intl.DateTimeFormat(options.locale ?? DEFAULT_LOCALE, {
+    ...options.format,
+    timeZone: getSafeTimeZone(options.timeZone)
+  }).format(date);
+}
+function formatBookingDate(input, format = {
+  weekday: "long",
+  year: "numeric",
+  month: "long",
+  day: "numeric"
+}) {
+  return formatBookingInstant(input.startsAt, {
+    locale: input.locale,
+    timeZone: input.timeZone,
+    format
+  });
+}
+function formatBookingTime(input, format = {
+  hour: "numeric",
+  minute: "2-digit",
+  hour12: true
+}) {
+  return formatBookingInstant(input.startsAt, {
+    locale: input.locale,
+    timeZone: input.timeZone,
+    format
+  });
+}
+function formatBookingDateTime(input, format = {
+  weekday: "short",
+  month: "short",
+  day: "numeric",
+  hour: "numeric",
+  minute: "2-digit"
+}) {
+  return formatBookingInstant(input.startsAt, {
+    locale: input.locale,
+    timeZone: input.timeZone,
+    format
+  });
+}
+function formatBookingDateParts(input, options) {
+  return {
+    date: formatBookingDate(
+      input,
+      options?.dateFormat ?? {
+        weekday: "short",
+        month: "short",
+        day: "numeric",
+        year: "numeric"
+      }
+    ),
+    time: formatBookingTime(
+      input,
+      options?.timeFormat ?? {
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true
+      }
+    )
+  };
+}
+function getBookingLocalDateKey(input) {
+  return formatDateKey(getLocalScheduleDate(new Date(input.startsAt), input.timeZone));
+}
+function parseBookingLocalDate(value) {
+  const match = LOCAL_DATE_PATTERN.exec(value.trim());
+  if (!match?.groups) {
+    throw new Error(`Invalid booking date format: "${value}" (expected YYYY-MM-DD)`);
+  }
+  const year = Number(match.groups.year);
+  const month = Number(match.groups.month);
+  const day = Number(match.groups.day);
+  const candidate = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
+  if (Number.isNaN(candidate.getTime()) || candidate.getUTCFullYear() !== year || candidate.getUTCMonth() + 1 !== month || candidate.getUTCDate() !== day) {
+    throw new Error(`Invalid booking date format: "${value}" (expected YYYY-MM-DD)`);
+  }
+  return { year, month, day };
+}
+function getLocalScheduleDate(date, timeZone) {
+  const parts = getZonedDateTimeParts(date, getSafeTimeZone(timeZone));
+  return { year: parts.year, month: parts.month, day: parts.day };
+}
+function formatLocalScheduleDate(date) {
+  return formatDateKey(date);
+}
+function addLocalScheduleDays(date, days) {
+  const utcDate = new Date(Date.UTC(date.year, date.month - 1, date.day + days, 12, 0, 0));
+  return {
+    year: utcDate.getUTCFullYear(),
+    month: utcDate.getUTCMonth() + 1,
+    day: utcDate.getUTCDate()
+  };
+}
+
+// ../core/src/location.ts
+function normalizeLocationAddressText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function hasLocationCoordinates(value) {
+  return typeof value?.lat === "number" && typeof value?.lng === "number";
+}
+function toLocationCoordinates(value) {
+  if (!hasLocationCoordinates(value)) {
+    return null;
+  }
+  return {
+    lat: value.lat,
+    lng: value.lng
+  };
+}
+
+// ../core/src/planner.ts
+var systemPlanningClock = {
+  now: () => Date.now()
+};
+function resolvePlanningNowDate(input = {}) {
+  if (input.now !== void 0) {
+    return input.now;
+  }
+  return new Date((input.clock ?? systemPlanningClock).now());
+}
+function resolvePlanningDateInput(input = {}) {
+  if (input instanceof Date) {
+    return input;
+  }
+  return resolvePlanningNowDate(input);
+}
+
+// ../media-core/src/typeGuards.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+
+// ../media-core/src/url.ts
+var DEFAULT_BASE_PATH = "/api/img";
+var RELATIVE_STORAGE_PATH_PREFIXES = [
+  "originals/",
+  "variants/",
+  "imports/"
+];
+function isRelativeDirectImageStoragePath(storagePath) {
+  return RELATIVE_STORAGE_PATH_PREFIXES.some((prefix) => storagePath.startsWith(prefix));
+}
+function isSiteScopedDirectImageStoragePath(storagePath) {
+  return storagePath.startsWith("sites/");
+}
+function encodeStoragePath(storagePath) {
+  return storagePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function resolveDirectImagePathTarget(target) {
+  switch (target.kind) {
+    case "relative":
+      return `sites/${target.siteId}/${target.storagePath}`;
+    case "site-scoped":
+    case "bucket-scoped":
+      return target.storagePath;
+  }
+}
+function buildDirectImageUrl(supabaseUrl, target, storageBucket = "media", options) {
+  const baseUrl = supabaseUrl.replace(/\/$/, "");
+  const resolvedPath = resolveDirectImagePathTarget(target);
+  const encodedPath = encodeStoragePath(resolvedPath);
+  const sourcePath = target.storagePath;
+  const isSvg = sourcePath.toLowerCase().endsWith(".svg");
+  if (options && !isSvg && (options.width || options.height)) {
+    const params = new URLSearchParams();
+    if (options.width) params.set("width", String(options.width));
+    if (options.height) params.set("height", String(options.height));
+    if (options.quality) params.set("quality", String(options.quality));
+    if (options.resize) params.set("resize", options.resize);
+    return `${baseUrl}/storage/v1/render/image/public/${storageBucket}/${encodedPath}?${params.toString()}`;
+  }
+  return `${baseUrl}/storage/v1/object/public/${storageBucket}/${encodedPath}`;
+}
+function getDirectImageUrlForRelativePath(supabaseUrl, storagePath, siteId, storageBucket = "media", options) {
+  return buildDirectImageUrl(
+    supabaseUrl,
+    { kind: "relative", storagePath, siteId },
+    storageBucket,
+    options
+  );
+}
+function getDirectImageUrlForSiteScopedPath(supabaseUrl, storagePath, storageBucket = "media", options) {
+  return buildDirectImageUrl(
+    supabaseUrl,
+    { kind: "site-scoped", storagePath },
+    storageBucket,
+    options
+  );
+}
+function getDirectImageUrlForBucketPath(supabaseUrl, storagePath, storageBucket = "media", options) {
+  return buildDirectImageUrl(
+    supabaseUrl,
+    { kind: "bucket-scoped", storagePath },
+    storageBucket,
+    options
+  );
+}
+function getDirectImageUrlForStoragePath(supabaseUrl, storagePath, storageBucket = "media", siteId, options) {
+  if (isRelativeDirectImageStoragePath(storagePath) && siteId) {
+    return getDirectImageUrlForRelativePath(supabaseUrl, storagePath, siteId, storageBucket, options);
+  }
+  if (isSiteScopedDirectImageStoragePath(storagePath)) {
+    return getDirectImageUrlForSiteScopedPath(supabaseUrl, storagePath, storageBucket, options);
+  }
+  return getDirectImageUrl(supabaseUrl, storagePath, storageBucket, siteId, options);
+}
+function getDirectImageUrl(supabaseUrl, storagePath, storageBucket = "media", siteId, options) {
+  if (isSiteScopedDirectImageStoragePath(storagePath)) {
+    if (siteId && true) {
+      console.warn(
+        `[media-core] storagePath "${storagePath}" already contains site prefix. Using path as-is for backward compatibility. After migration, paths should be relative (e.g., "originals/2024/12/img.jpg").`
+      );
+    }
+    return getDirectImageUrlForSiteScopedPath(supabaseUrl, storagePath, storageBucket, options);
+  }
+  if (siteId && isRelativeDirectImageStoragePath(storagePath)) {
+    return getDirectImageUrlForRelativePath(supabaseUrl, storagePath, siteId, storageBucket, options);
+  }
+  return getDirectImageUrlForBucketPath(supabaseUrl, storagePath, storageBucket, options);
+}
+var formatNumber = (value) => Number.isInteger(value) ? value.toString() : value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+var ORDER = [
+  "w",
+  "h",
+  "fit",
+  "rect",
+  "q",
+  "autoFormat",
+  "or"
+];
+var getImageUrl = (asset, params = {}, basePath = DEFAULT_BASE_PATH) => {
+  const trimmedBase = basePath.endsWith("/") ? basePath.slice(0, Math.max(basePath.length - 1, 0)) : basePath;
+  const path = `${trimmedBase}/${encodeURIComponent(asset.id)}`;
+  const searchParams = new URLSearchParams();
+  if (params.w !== void 0) searchParams.set("w", formatNumber(params.w));
+  if (params.h !== void 0) searchParams.set("h", formatNumber(params.h));
+  if (params.fit !== void 0) searchParams.set("fit", params.fit);
+  if (params.rect) searchParams.set("rect", params.rect.map(formatNumber).join(","));
+  if (params.q !== void 0) searchParams.set("q", formatNumber(params.q));
+  if (params.autoFormat) searchParams.append("auto", "format");
+  if (params.or !== void 0) searchParams.set("or", String(params.or));
+  const sorted = new URLSearchParams();
+  ORDER.forEach((key) => {
+    if (key === "autoFormat") {
+      if (params.autoFormat) sorted.append("auto", "format");
+      return;
+    }
+    const value = searchParams.get(key);
+    if (value !== null) sorted.set(key, value);
+  });
+  const query = sorted.toString();
+  return query ? `${path}?${query}` : path;
+};
+
+// ../media-core/src/transformRect.ts
+function isValidTransformRectStructure(rect) {
+  if (!Array.isArray(rect) || rect.length !== 4) return false;
+  const [left, top, width, height] = rect;
+  return Number.isFinite(left) && Number.isFinite(top) && Number.isFinite(width) && Number.isFinite(height) && left >= 0 && top >= 0 && width > 0 && height > 0;
+}
+
+// ../media-core/src/aspectTransforms.ts
+var DEFAULT_RECT_EPSILON = 0.5;
+function parseAspectRatioValue(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) && value > 0 ? value : void 0;
+  }
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim();
+  if (!normalized) return void 0;
+  if (normalized === "auto") return void 0;
+  if (normalized.includes(":") || normalized.includes("/")) {
+    const delimiter = normalized.includes(":") ? ":" : "/";
+    const [wRaw, hRaw] = normalized.split(delimiter);
+    const width = Number(wRaw?.trim());
+    const height = Number(hRaw?.trim());
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+      return void 0;
+    }
+    return width / height;
+  }
+  const numeric = Number(normalized);
+  if (!Number.isFinite(numeric) || numeric <= 0) return void 0;
+  return numeric;
+}
+var MAX_ASPECT_DISTANCE = 0.25;
+function resolveMediaTransformForAspect(transform, targetAspect) {
+  if (!transform) return {};
+  const base = {
+    rect: transform.rect,
+    hotspot: transform.hotspot,
+    rotation: transform.rotation
+  };
+  const target = parseAspectRatioValue(targetAspect);
+  const crops = transform.aspectCrops;
+  if (!target || !crops || Object.keys(crops).length === 0) {
+    return base;
+  }
+  let best = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const [key, candidate] of Object.entries(crops)) {
+    const candidateAspect = parseAspectRatioValue(candidate.aspect ?? key);
+    if (!candidateAspect) continue;
+    const distance = Math.abs(Math.log(candidateAspect / target));
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  if (!best) return base;
+  if (bestDistance > MAX_ASPECT_DISTANCE) return base;
+  return {
+    rect: best.rect ?? base.rect,
+    hotspot: best.hotspot ?? base.hotspot,
+    rotation: best.rotation ?? base.rotation
+  };
+}
+function isValidTransformRect(rect) {
+  return isValidTransformRectStructure(rect);
+}
+function isExplicitRectCrop(rect, sourceWidth, sourceHeight, epsilon = DEFAULT_RECT_EPSILON) {
+  if (!isValidTransformRect(rect)) return false;
+  const hasSourceDimensions = typeof sourceWidth === "number" && Number.isFinite(sourceWidth) && sourceWidth > 0 && typeof sourceHeight === "number" && Number.isFinite(sourceHeight) && sourceHeight > 0;
+  if (!hasSourceDimensions) {
+    return true;
+  }
+  const [x, y, width, height] = rect;
+  const isFullFrame = Math.abs(x) <= epsilon && Math.abs(y) <= epsilon && Math.abs(width - sourceWidth) <= epsilon && Math.abs(height - sourceHeight) <= epsilon;
+  return !isFullFrame;
+}
+
+// ../media-core/src/deliveryContracts.ts
+var DEFAULT_MEDIA_WIDTH_CANDIDATES = [
+  320,
+  480,
+  640,
+  768,
+  960,
+  1200,
+  1536,
+  1920,
+  2560
+];
+function normalizeWidthCandidates(candidates, max = 2560) {
+  const source = (candidates ?? DEFAULT_MEDIA_WIDTH_CANDIDATES).filter((value) => Number.isFinite(value) && value > 0);
+  const uniqueSorted = [...new Set(source.map((value) => Math.round(value)))].filter((value) => value > 0 && value <= max).sort((a, b) => a - b);
+  if (uniqueSorted.length > 0) {
+    return uniqueSorted;
+  }
+  return DEFAULT_MEDIA_WIDTH_CANDIDATES.filter((value) => value <= max);
+}
+
+// ../media-core/src/rotation.ts
+function rotateNormalizedPoint(point, rotation) {
+  const x = point.x;
+  const y = point.y;
+  switch (rotation) {
+    case 90:
+      return { x: 1 - y, y: x };
+    case 180:
+      return { x: 1 - x, y: 1 - y };
+    case 270:
+      return { x: y, y: 1 - x };
+    default:
+      return { x, y };
+  }
+}
+
+// ../blocks/src/system/media/slotContracts.ts
+var DEFAULT_MIN_SOURCE_WIDTH = 1200;
+var LARGE_MIN_SOURCE_WIDTH = 1400;
+var SECTION_BACKGROUND_MIN_SOURCE_WIDTH = 1920;
+var SECTION_BACKGROUND_MIN_SOURCE_HEIGHT = 900;
+var TEAM_MEMBER_MIN_SOURCE_WIDTH = 1e3;
+var DEFAULT_DELIVERY_MAX_WIDTH = 2560;
+var DEFAULT_MARQUEE_IMAGE_PX = 256;
+function normalizeSlotPath(path) {
+  return path.split(".").map((segment) => /^\d+$/.test(segment) ? "[]" : segment).join(".");
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function asFiniteNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  return value;
+}
+function asPositiveIntArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const numbers = value.map((entry) => asFiniteNumber(entry)).filter((entry) => entry !== void 0 && entry > 0).map((entry) => Math.round(entry));
+  return numbers.length > 0 ? numbers : void 0;
+}
+function getValueAtPath(values, path) {
+  const segments = path.split(".").filter((segment) => segment.length > 0);
+  let current = values;
+  for (const segment of segments) {
+    if (Array.isArray(current)) {
+      const numericIndex = Number.parseInt(segment, 10);
+      if (!Number.isFinite(numericIndex)) return void 0;
+      const next2 = current[numericIndex];
+      if (next2 === void 0) return void 0;
+      current = next2;
+      continue;
+    }
+    const record = asRecord(current);
+    if (!record) return void 0;
+    const next = record[segment];
+    if (next === void 0) return void 0;
+    current = next;
+  }
+  return current;
+}
+function resolveSiblingAspectRatio(fieldPath, values) {
+  if (!values) return void 0;
+  const lastDotIndex = fieldPath.lastIndexOf(".");
+  if (lastDotIndex < 0) {
+    return asString(values.aspectRatio);
+  }
+  const parentPath = fieldPath.slice(0, lastDotIndex);
+  const parentValue = getValueAtPath(values, parentPath);
+  const parentRecord = asRecord(parentValue);
+  return asString(parentRecord?.aspectRatio);
+}
+function getMinSourceConstraints(aspectRatio, minSourceWidth) {
+  const parsedAspect = parseAspectRatioValue(aspectRatio);
+  if (!parsedAspect) {
+    return { minSourceWidth };
+  }
+  return {
+    minSourceWidth,
+    minSourceHeight: Math.max(1, Math.round(minSourceWidth / parsedAspect))
+  };
+}
+function resolveColumnsGridCols(content) {
+  const items = Array.isArray(content.columns) ? content.columns : [];
+  const count = Math.min(4, Math.max(1, items.length || 1));
+  const configuredDesktopColumnsRaw = typeof content.desktopColumns === "string" ? content.desktopColumns : "auto";
+  const configuredDesktopColumnsMap = {
+    "2": 2,
+    "3": 3,
+    "4": 4
+  };
+  const desktopColumns = configuredDesktopColumnsMap[configuredDesktopColumnsRaw] ?? count;
+  if (desktopColumns <= 1) {
+    return { base: 1 };
+  }
+  if (desktopColumns === 2) {
+    return { base: 1, md: 2 };
+  }
+  if (desktopColumns === 3) {
+    return { base: 1, md: 2, lg: 3 };
+  }
+  return { base: 1, md: 2, lg: 3, xl: 4 };
+}
+function formatVw(value) {
+  const rounded = Math.round(value * 100) / 100;
+  return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded.toFixed(2)}vw`;
+}
+function fractionToVw(numerator, denominator) {
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0) {
+    return "100vw";
+  }
+  const clampedNumerator = Math.max(1, Math.min(numerator, denominator));
+  return formatVw(clampedNumerator / denominator * 100);
+}
+function resolveColumnsDeliveryContract(fieldPath, values) {
+  const defaultCandidates = normalizeWidthCandidates(void 0, DEFAULT_DELIVERY_MAX_WIDTH);
+  if (!values) {
+    return {
+      strategy: "columnsAuto",
+      sizes: "100vw",
+      widthCandidates: defaultCandidates
+    };
+  }
+  const match = fieldPath.match(/^columns\.(\d+)\.media$/);
+  const matchIndex = match?.[1];
+  const columnIndex = typeof matchIndex === "string" ? Number.parseInt(matchIndex, 10) : void 0;
+  const columns = Array.isArray(values.columns) ? values.columns : [];
+  const columnValue = columnIndex !== void 0 ? asRecord(columns[columnIndex]) : void 0;
+  const rawSpan = asString(columnValue?.desktopSpan);
+  const desktopSpan = rawSpan === "2" || rawSpan === "3" || rawSpan === "4" ? Number.parseInt(rawSpan, 10) : 1;
+  const cols = resolveColumnsGridCols(values);
+  const mobileCols = cols.base;
+  const mdCols = cols.md ?? mobileCols;
+  const lgCols = cols.lg ?? mdCols;
+  const xlCols = cols.xl ?? lgCols;
+  const sizes = [
+    `(min-width: 1280px) ${fractionToVw(desktopSpan, xlCols)}`,
+    `(min-width: 1024px) ${fractionToVw(desktopSpan, lgCols)}`,
+    `(min-width: 768px) ${fractionToVw(1, mdCols)}`,
+    fractionToVw(1, mobileCols)
+  ].join(", ");
+  return {
+    strategy: "columnsAuto",
+    sizes,
+    widthCandidates: defaultCandidates
+  };
+}
+function parseSlidesToShow(value, fallback) {
+  const asText = asString(value);
+  if (!asText) return fallback;
+  const parsed = Number.parseInt(asText, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+function resolveMarqueeImageSizePixels(values) {
+  const size = asString(values?.marqueeImageSize) ?? "md";
+  if (size === "sm") return 200;
+  if (size === "lg") return 320;
+  if (size === "xl") return 400;
+  return DEFAULT_MARQUEE_IMAGE_PX;
+}
+function resolveMarqueeMinSourceWidth(values) {
+  const pixels = resolveMarqueeImageSizePixels(values);
+  return Math.max(600, Math.round(pixels * 3));
+}
+function resolveImageGalleryDeliveryContract(values) {
+  const variant = asString(values?.variant) ?? "grid";
+  const defaultCandidates = normalizeWidthCandidates(void 0, DEFAULT_DELIVERY_MAX_WIDTH);
+  if (variant === "carousel") {
+    const mobile = parseSlidesToShow(values?.slidesToShow, 1);
+    const tablet = parseSlidesToShow(values?.slidesToShowTablet, mobile);
+    const desktop = parseSlidesToShow(values?.slidesToShowDesktop, tablet);
+    return {
+      strategy: "imageGalleryVariant",
+      sizes: [
+        `(min-width: 1280px) ${fractionToVw(1, desktop)}`,
+        `(min-width: 768px) ${fractionToVw(1, tablet)}`,
+        fractionToVw(1, mobile)
+      ].join(", "),
+      widthCandidates: defaultCandidates
+    };
+  }
+  if (variant === "marquee") {
+    const marqueePixels = resolveMarqueeImageSizePixels(values);
+    return {
+      strategy: "imageGalleryVariant",
+      sizes: `${marqueePixels}px`,
+      widthCandidates: defaultCandidates
+    };
+  }
+  return {
+    strategy: "imageGalleryVariant",
+    sizes: "(min-width: 1280px) 31vw, (min-width: 768px) 47vw, 96vw",
+    widthCandidates: defaultCandidates
+  };
+}
+function parseRatioToken(value) {
+  const raw = asString(value);
+  if (!raw) return null;
+  const [numRaw, denomRaw] = raw.split("/").map((part) => part.trim());
+  const numerator = Number(numRaw);
+  const denominator = Number(denomRaw);
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) return null;
+  if (numerator <= 0 || denominator <= 0) return null;
+  return { numerator, denominator };
+}
+function resolveResponsiveTwoColumnImageSizes(values) {
+  const ratio = parseRatioToken(values?.ratio) ?? { numerator: 1, denominator: 2 };
+  return fractionToVw(ratio.numerator, ratio.denominator);
+}
+function parseColumnsCount(raw, fallback) {
+  const cols = typeof raw === "number" ? raw : typeof raw === "string" ? Number.parseInt(raw, 10) : fallback;
+  const safe = Number.isFinite(cols) ? cols : fallback;
+  return Math.max(1, Math.min(6, safe));
+}
+function resolveTeamMembersDeliveryContract(values) {
+  const defaultCandidates = normalizeWidthCandidates(void 0, DEFAULT_DELIVERY_MAX_WIDTH);
+  const variant = asString(values?.variant) ?? "grid";
+  if (variant === "stack") {
+    const ratio = parseRatioToken(values?.imageColSize) ?? { numerator: 1, denominator: 3 };
+    const desktop = fractionToVw(ratio.numerator, ratio.denominator);
+    return {
+      strategy: "default",
+      sizes: `(min-width: 768px) ${desktop}, 100vw`,
+      widthCandidates: defaultCandidates
+    };
+  }
+  const clamped = parseColumnsCount(values?.columns, 3);
+  return {
+    strategy: "default",
+    sizes: fractionToVw(1, clamped),
+    widthCandidates: defaultCandidates
+  };
+}
+function resolveMediaTextDeliveryContract(values) {
+  const defaultCandidates = normalizeWidthCandidates(void 0, DEFAULT_DELIVERY_MAX_WIDTH);
+  const desktop = resolveResponsiveTwoColumnImageSizes(values);
+  return {
+    strategy: "default",
+    sizes: `(min-width: 768px) ${desktop}, 100vw`,
+    widthCandidates: defaultCandidates
+  };
+}
+function resolveCollectionDeliveryContract(values) {
+  const defaultCandidates = normalizeWidthCandidates(void 0, DEFAULT_DELIVERY_MAX_WIDTH);
+  const layout = asString(values?.layout) ?? "grid";
+  if (layout !== "grid") {
+    return { strategy: "default", sizes: "100vw", widthCandidates: defaultCandidates };
+  }
+  const clamped = parseColumnsCount(values?.columns, 3);
+  return {
+    strategy: "default",
+    sizes: fractionToVw(1, clamped),
+    widthCandidates: defaultCandidates
+  };
+}
+function resolveSmallLogoDeliveryContract() {
+  const defaultCandidates = normalizeWidthCandidates(void 0, DEFAULT_DELIVERY_MAX_WIDTH);
+  return {
+    strategy: "default",
+    sizes: "256px",
+    widthCandidates: defaultCandidates
+  };
+}
+function resolveDefaultDeliveryContract(slotPath) {
+  const widthCandidates = normalizeWidthCandidates(void 0, DEFAULT_DELIVERY_MAX_WIDTH);
+  if (slotPath.endsWith("_sectionStyles.background.image")) {
+    return {
+      strategy: "default",
+      sizes: "100vw",
+      widthCandidates,
+      maxCssWidth: DEFAULT_DELIVERY_MAX_WIDTH
+    };
+  }
+  return {
+    strategy: "default",
+    sizes: "100vw",
+    widthCandidates
+  };
+}
+function parseMediaDeliveryConfig(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const strategyValue = asString(record.strategy);
+  const strategy = strategyValue === "default" || strategyValue === "columnsAuto" || strategyValue === "imageGalleryVariant" ? strategyValue : void 0;
+  const strategyOptions = asRecord(record.strategyOptions);
+  const parsed = {};
+  const sizes = asString(record.sizes);
+  if (sizes) parsed.sizes = sizes;
+  const widthCandidates = asPositiveIntArray(record.widthCandidates);
+  if (widthCandidates) parsed.widthCandidates = widthCandidates;
+  const maxCssWidth = asFiniteNumber(record.maxCssWidth);
+  if (maxCssWidth !== void 0) parsed.maxCssWidth = maxCssWidth;
+  const maxCssHeight = asFiniteNumber(record.maxCssHeight);
+  if (maxCssHeight !== void 0) parsed.maxCssHeight = maxCssHeight;
+  if (strategy) parsed.strategy = strategy;
+  if (strategyOptions) parsed.strategyOptions = strategyOptions;
+  return parsed;
+}
+function resolveFieldUiDeliveryConfig(fieldUi, variant) {
+  const ui = asRecord(fieldUi);
+  if (!ui) return void 0;
+  const defaultConfig = parseMediaDeliveryConfig(ui.mediaDelivery);
+  const byVariant = asRecord(ui.mediaDeliveryByVariant);
+  const variantConfig = variant ? parseMediaDeliveryConfig(byVariant?.[variant]) : void 0;
+  if (!defaultConfig && !variantConfig) return void 0;
+  return {
+    ...defaultConfig,
+    ...variantConfig,
+    strategyOptions: {
+      ...defaultConfig?.strategyOptions ?? {},
+      ...variantConfig?.strategyOptions ?? {}
+    }
+  };
+}
+function mergeDelivery(base, override) {
+  if (!override) return base;
+  const maxCssWidth = override.maxCssWidth ?? base.maxCssWidth;
+  const cap = maxCssWidth && maxCssWidth > 0 ? Math.round(maxCssWidth) : DEFAULT_DELIVERY_MAX_WIDTH;
+  const widthCandidates = normalizeWidthCandidates(
+    override.widthCandidates ?? base.widthCandidates,
+    cap
+  );
+  return {
+    ...base,
+    ...override,
+    widthCandidates
+  };
+}
+function buildContract(edit, delivery) {
+  return {
+    edit,
+    delivery
+  };
+}
+function resolveImageGalleryEditContract(slotPath, values) {
+  if (slotPath !== "images.[].image") {
+    return void 0;
+  }
+  const variant = asString(values?.variant) ?? "grid";
+  if (variant === "marquee") {
+    const aspectRatio = "1/1";
+    const minSourceWidth = resolveMarqueeMinSourceWidth(values);
+    return {
+      mode: "fixed-aspect",
+      aspectRatio,
+      ...getMinSourceConstraints(aspectRatio, minSourceWidth)
+    };
+  }
+  if (variant === "masonry") {
+    return {
+      mode: "original-aspect",
+      minSourceWidth: DEFAULT_MIN_SOURCE_WIDTH
+    };
+  }
+  const configuredAspect = asString(values?.aspectRatio);
+  if (!configuredAspect || configuredAspect === "auto") {
+    return {
+      mode: "original-aspect",
+      minSourceWidth: DEFAULT_MIN_SOURCE_WIDTH
+    };
+  }
+  return {
+    mode: "fixed-aspect",
+    aspectRatio: configuredAspect,
+    ...getMinSourceConstraints(configuredAspect, DEFAULT_MIN_SOURCE_WIDTH)
+  };
+}
+function resolveEditContract(blockKind, fieldPath, slotPath, values, fieldAspectRatio) {
+  const normalizedFieldAspect = asString(fieldAspectRatio);
+  if (slotPath.endsWith("_sectionStyles.background.image")) {
+    return {
+      mode: "original-aspect",
+      minSourceWidth: SECTION_BACKGROUND_MIN_SOURCE_WIDTH,
+      minSourceHeight: SECTION_BACKGROUND_MIN_SOURCE_HEIGHT
+    };
+  }
+  if (blockKind === "block.image-gallery") {
+    const imageGalleryContract = resolveImageGalleryEditContract(slotPath, values);
+    if (imageGalleryContract) return imageGalleryContract;
+  }
+  if (blockKind === "block.team-members" && slotPath === "members.[].photo") {
+    return {
+      mode: "fixed-aspect",
+      aspectRatio: "1/1",
+      ...getMinSourceConstraints("1/1", TEAM_MEMBER_MIN_SOURCE_WIDTH)
+    };
+  }
+  if (blockKind === "block.media-text" && slotPath === "images.[].image") {
+    const blockAspectRatio = asString(values?.aspectRatio);
+    if (blockAspectRatio && blockAspectRatio !== "auto") {
+      return {
+        mode: "fixed-aspect",
+        aspectRatio: blockAspectRatio,
+        ...getMinSourceConstraints(blockAspectRatio, LARGE_MIN_SOURCE_WIDTH)
+      };
+    }
+    return {
+      mode: "original-aspect",
+      minSourceWidth: LARGE_MIN_SOURCE_WIDTH
+    };
+  }
+  const siblingAspectRatio = resolveSiblingAspectRatio(fieldPath, values);
+  if (siblingAspectRatio && siblingAspectRatio !== "auto") {
+    return {
+      mode: "fixed-aspect",
+      aspectRatio: siblingAspectRatio,
+      ...getMinSourceConstraints(siblingAspectRatio, DEFAULT_MIN_SOURCE_WIDTH)
+    };
+  }
+  if (siblingAspectRatio === "auto") {
+    return {
+      mode: "original-aspect",
+      minSourceWidth: DEFAULT_MIN_SOURCE_WIDTH
+    };
+  }
+  if (!normalizedFieldAspect || normalizedFieldAspect === "auto") {
+    return {
+      mode: "original-aspect",
+      minSourceWidth: DEFAULT_MIN_SOURCE_WIDTH
+    };
+  }
+  return {
+    mode: "fixed-aspect",
+    aspectRatio: normalizedFieldAspect,
+    ...getMinSourceConstraints(normalizedFieldAspect, DEFAULT_MIN_SOURCE_WIDTH)
+  };
+}
+function resolveStrategyDelivery(blockKind, fieldPath, slotPath, values) {
+  if (blockKind === "block.columns" && slotPath === "columns.[].media") {
+    return resolveColumnsDeliveryContract(fieldPath, values);
+  }
+  if (blockKind === "block.image-gallery" && slotPath === "images.[].image") {
+    return resolveImageGalleryDeliveryContract(values);
+  }
+  if (blockKind === "block.team-members" && slotPath === "members.[].photo") {
+    return resolveTeamMembersDeliveryContract(values);
+  }
+  if (blockKind === "block.media-text" && slotPath === "images.[].image") {
+    return resolveMediaTextDeliveryContract(values);
+  }
+  if (blockKind === "block.collection" && slotPath.startsWith("items.[].")) {
+    return resolveCollectionDeliveryContract(values);
+  }
+  if (blockKind === "block.site-header" && slotPath === "logo") {
+    return resolveSmallLogoDeliveryContract();
+  }
+  if (blockKind === "block.site-footer" && slotPath === "logo") {
+    return resolveSmallLogoDeliveryContract();
+  }
+  return void 0;
+}
+function resolveMediaSlotContract({
+  blockKind,
+  fieldPath,
+  values,
+  fieldAspectRatio,
+  fieldUi
+}) {
+  const slotPath = normalizeSlotPath(fieldPath);
+  const variant = asString(values?.variant);
+  const edit = resolveEditContract(blockKind, fieldPath, slotPath, values, fieldAspectRatio);
+  const defaultDelivery = resolveDefaultDeliveryContract(slotPath);
+  const fieldDelivery = resolveFieldUiDeliveryConfig(fieldUi, variant);
+  const strategyDelivery = resolveStrategyDelivery(blockKind, fieldPath, slotPath, values);
+  const mergedField = mergeDelivery(defaultDelivery, fieldDelivery);
+  const merged = mergeDelivery(mergedField, strategyDelivery);
+  return buildContract(edit, merged);
+}
+
+// ../theme-core/src/tokens/colorTokenParts.ts
+function parseOpacityPercent(source) {
+  const trimmed = source.trim();
+  if (!trimmed) return null;
+  if (!/^\d{1,3}(?:\.\d+)?$/.test(trimmed)) return null;
+  const value = Number(trimmed);
+  if (!Number.isFinite(value)) return null;
+  if (value < 0 || value > 100) return null;
+  return value;
+}
+function parseColorTokenParts(source) {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("raw:")) {
+    return { kind: "raw", value: trimmed.slice(4) };
+  }
+  const [token, opacityRaw, extra] = trimmed.split("/");
+  if (!token || extra !== void 0) {
+    return { kind: "invalid", token: trimmed };
+  }
+  if (opacityRaw === void 0) {
+    return { kind: "token", token, opacityPercent: null };
+  }
+  const opacityPercent = parseOpacityPercent(opacityRaw);
+  if (opacityPercent === null) {
+    return { kind: "invalid", token: trimmed };
+  }
+  return { kind: "token", token, opacityPercent };
+}
+
+// ../theme-core/src/utils/colorStyles.ts
+var COLOR_VAR_PREFIX = "--tb-";
+function parseToken(source) {
+  const parts = parseColorTokenParts(source);
+  if (parts.kind === "raw") {
+    return { token: source, raw: parts.value };
+  }
+  if (parts.kind === "invalid") {
+    return { token: source };
+  }
+  return {
+    token: parts.token,
+    alpha: parts.opacityPercent === null ? void 0 : parts.opacityPercent / 100
+  };
+}
+function rgbColorValue(token) {
+  const { token: baseToken, alpha, raw } = parseToken(token);
+  if (raw) {
+    return raw;
+  }
+  const cssVar = `${COLOR_VAR_PREFIX}${baseToken}`;
+  if (alpha === void 0) {
+    return `rgb(var(${cssVar}))`;
+  }
+  return `rgba(var(${cssVar}), ${alpha})`;
+}
+function backgroundColorStyle(token) {
+  return { backgroundColor: rgbColorValue(token) };
+}
+function textColorStyle(token) {
+  return { color: rgbColorValue(token) };
+}
+function borderColorStyle(token) {
+  return { borderColor: rgbColorValue(token) };
+}
+function mergeStyles(...styles) {
+  const merged = {};
+  for (const style of styles) {
+    if (!style) continue;
+    Object.assign(merged, style);
+  }
+  return Object.keys(merged).length ? merged : void 0;
+}
+function buildMediaAssetIndex(assets) {
+  if (!assets || assets.length === 0) return void 0;
+  const byId = /* @__PURE__ */ new Map();
+  const byIdentifier = /* @__PURE__ */ new Map();
+  for (const asset of assets) {
+    if (!asset?.id) continue;
+    byId.set(asset.id, asset);
+    const identifier = typeof asset.identifier === "string" ? asset.identifier.trim() : "";
+    if (identifier) byIdentifier.set(identifier, asset);
+  }
+  return { byId, byIdentifier };
+}
+var MAX_RENDER_DIMENSION = 4096;
+var MAX_SRCSET_WIDTH = 2560;
+var RELATIVE_IMG_PROXY_BASE_PATH = "/api/img";
+function normalizeSupabaseUrl(value) {
+  return value?.replace(/\/$/, "");
+}
+function buildResolveImageUrlContext(input) {
+  return {
+    supabaseUrl: normalizeSupabaseUrl(input?.supabaseUrl),
+    siteId: input?.siteId,
+    mediaAssetIndex: input?.mediaAssetIndex ?? buildMediaAssetIndex(input?.mediaAssets)
+  };
+}
+function getValidSourceDimension(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function isExplicitCropProxyEnabled() {
+  const raw = process.env.NEXT_PUBLIC_MEDIA_EXPLICIT_CROP_PROXY_ENABLED ?? process.env.MEDIA_EXPLICIT_CROP_PROXY_ENABLED;
+  if (!raw) return true;
+  const normalized = raw.trim().toLowerCase();
+  return !(normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off");
+}
+function getRequestedDimension(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  return Math.min(MAX_RENDER_DIMENSION, Math.max(1, Math.round(value)));
+}
+function getPositiveAspectRatio(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return void 0;
+  return value;
+}
+function getHeightForAspect(width, aspectRatio) {
+  if (!aspectRatio) return void 0;
+  return Math.max(1, Math.round(width / aspectRatio));
+}
+function mapResizeToFit(resize) {
+  if (resize === "contain") return "clip";
+  return "crop";
+}
+function shouldUseExplicitRectProxy(value, options, resolvedTransform, sourceWidth, sourceHeight) {
+  if ("original" in options && options.original) return false;
+  if (!isExplicitCropProxyEnabled()) return false;
+  if (!value.assetId) return false;
+  if (typeof resolvedTransform.rotation === "number" && resolvedTransform.rotation !== 0) return true;
+  return isExplicitRectCrop(resolvedTransform.rect, sourceWidth, sourceHeight);
+}
+function buildProxyTransformParams(options, resolvedTransform) {
+  const requestedWidth = "width" in options ? getRequestedDimension(options.width) : void 0;
+  const requestedHeight = "height" in options ? getRequestedDimension(options.height) : void 0;
+  const params = {
+    w: requestedWidth,
+    h: requestedHeight,
+    q: "quality" in options ? options.quality : void 0,
+    fit: mapResizeToFit("resize" in options ? options.resize : void 0),
+    autoFormat: true
+  };
+  if (resolvedTransform.rect) {
+    params.rect = resolvedTransform.rect;
+  }
+  if (resolvedTransform.rotation) {
+    params.or = resolvedTransform.rotation;
+  }
+  return params;
+}
+function buildDirectTransformOptions(options) {
+  if ("original" in options && options.original) return void 0;
+  const requestedWidth = "width" in options ? getRequestedDimension(options.width) : void 0;
+  const requestedHeight = "height" in options ? getRequestedDimension(options.height) : void 0;
+  return {
+    width: requestedWidth,
+    height: requestedHeight,
+    quality: "quality" in options ? options.quality : void 0,
+    resize: "resize" in options ? options.resize : void 0
+  };
+}
+function resolveTransformResolution(value, targetAspectRatio) {
+  return {
+    resolvedTransform: resolveMediaTransformForAspect(value.transform, targetAspectRatio),
+    sourceWidth: getValidSourceDimension(value.width),
+    sourceHeight: getValidSourceDimension(value.height)
+  };
+}
+function buildCssRectStylePatch(value, rect) {
+  const sourceWidth = getValidSourceDimension(value.width);
+  const sourceHeight = getValidSourceDimension(value.height);
+  if (sourceWidth === void 0 || sourceHeight === void 0 || rect[2] <= 0 || rect[3] <= 0) {
+    return void 0;
+  }
+  const [x, y, width, height] = rect;
+  const centerX = (x + width / 2) / sourceWidth;
+  const centerY = (y + height / 2) / sourceHeight;
+  const zoomX = sourceWidth / width;
+  const zoomY = sourceHeight / height;
+  const uniformZoom = Math.max(1, Math.min(64, Math.max(zoomX, zoomY)));
+  return {
+    objectPosition: `${centerX * 100}% ${centerY * 100}%`,
+    transform: `scale(${uniformZoom})`,
+    transformOrigin: "center"
+  };
+}
+function appendTransform(base, transform) {
+  if (!base || base.length === 0) return transform;
+  return `${base} ${transform}`;
+}
+function applyRectTransform(existingStyle, patch) {
+  const next = { ...patch };
+  if (patch.transform) {
+    next.transform = appendTransform(existingStyle?.transform, patch.transform);
+  }
+  return next;
+}
+function getProxyImageUrl(value, options, transformAspectRatio, resolved) {
+  if (!value.assetId) return void 0;
+  const targetAspect = transformAspectRatio ?? resolveTargetAspectRatio(options);
+  const { resolvedTransform, sourceWidth, sourceHeight } = resolved ?? resolveTransformResolution(value, targetAspect);
+  if (!shouldUseExplicitRectProxy(value, options, resolvedTransform, sourceWidth, sourceHeight)) return void 0;
+  const params = buildProxyTransformParams(options, resolvedTransform);
+  const proxyBasePath = getImageProxyBasePath();
+  const proxyUrl = getImageUrl({ id: asMediaAssetId(value.assetId) }, params, proxyBasePath);
+  debugMediaNodeLog("resolve:proxy-img", { assetId: value.assetId, params, proxyBasePath, proxyUrl });
+  return proxyUrl;
+}
+function resolveMediaStorageUrl(value, context, transformOptions) {
+  const canonical = resolveMediaWithCanonicalAsset(value, context ?? void 0);
+  if (!canonical.storagePath || canonical.storagePath.length === 0) return void 0;
+  const supabaseUrl = context?.supabaseUrl?.replace(/\/$/, "") ?? getSupabaseUrl();
+  const siteId = context?.siteId ?? getSiteId();
+  const bucket = canonical.storageBucket ?? "media";
+  if (isRelativeDirectImageStoragePath(canonical.storagePath) && !siteId) {
+    console.warn(
+      `[blocks] Relative storagePath "${canonical.storagePath}" requires siteId context. Media URL may be incorrect. Ensure siteId is set via runWithMediaContext or setContextSiteId.`
+    );
+  }
+  const directUrl = getDirectImageUrlForStoragePath(
+    supabaseUrl,
+    canonical.storagePath,
+    bucket,
+    siteId,
+    transformOptions
+  );
+  debugMediaNodeLog("resolve:direct-supabase", {
+    storagePath: canonical.storagePath,
+    siteId,
+    bucket,
+    directUrl,
+    transformOptions
+  });
+  return directUrl;
+}
+function getDirectImageUrlForValue(value, options, context) {
+  return resolveMediaStorageUrl(value, context, buildDirectTransformOptions(options));
+}
+function resolveStorageImageUrl(value, options, context, transformAspectRatio, resolved) {
+  const proxyUrl = getProxyImageUrl(value, options, transformAspectRatio, resolved);
+  if (proxyUrl) return proxyUrl;
+  const directUrl = getDirectImageUrlForValue(value, options, context);
+  if (directUrl) return directUrl;
+  return void 0;
+}
+var ImagePresets = {
+  /** Small thumbnails (200px) - for block previews, lists */
+  thumbnail: { width: 200, quality: 80, resize: "contain" },
+  /** Card-sized images (600px) - for cards, grids */
+  card: { width: 600, quality: 80, resize: "contain" },
+  /** Hero images (1200px) - for above-fold content */
+  hero: { width: 1200, quality: 85, resize: "contain" },
+  /** Full-width images (1920px) - for backgrounds, large displays */
+  full: { width: 1920, quality: 85, resize: "contain" }
+};
+var _serverStorage = null;
+var _serverStorageChecked = false;
+function getServerStorage() {
+  if (typeof window !== "undefined") return null;
+  if (_serverStorageChecked) return _serverStorage;
+  _serverStorageChecked = true;
+  try {
+    const globalWithNonWebpackRequire = globalThis;
+    const nonWebpackRequire = typeof globalWithNonWebpackRequire.__non_webpack_require__ === "function" ? globalWithNonWebpackRequire.__non_webpack_require__ : new Function("id", "return require(id)");
+    const asyncHooks = nonWebpackRequire("async_hooks");
+    const AsyncLocalStorage = asyncHooks.AsyncLocalStorage;
+    if (AsyncLocalStorage) {
+      _serverStorage = new AsyncLocalStorage();
+      return _serverStorage;
+    }
+    return null;
+  } catch {
+    {
+      console.warn("[blocks] AsyncLocalStorage not available - using module-level state");
+    }
+    return null;
+  }
+}
+var RB_MEDIA_CONTEXT_KEY = /* @__PURE__ */ Symbol.for("riverbankcms.blocks.mediaContext");
+function getClientContextStore() {
+  const g = globalThis;
+  const existing = g[RB_MEDIA_CONTEXT_KEY];
+  if (existing && typeof existing === "object") return existing;
+  const next = {};
+  g[RB_MEDIA_CONTEXT_KEY] = next;
+  return next;
+}
+function getMediaContext() {
+  const storage = getServerStorage();
+  if (storage) {
+    return storage.getStore() ?? {};
+  }
+  return getClientContextStore();
+}
+function setContextSupabaseUrl(url) {
+  const normalizedUrl = normalizeSupabaseUrl(url);
+  const storage = getServerStorage();
+  if (storage) {
+    const current = storage.getStore();
+    if (current) {
+      current.supabaseUrl = normalizedUrl;
+    } else {
+      if (storage.enterWith) {
+        const next = { supabaseUrl: normalizedUrl };
+        storage.enterWith(next);
+      } else {
+        getClientContextStore().supabaseUrl = normalizedUrl;
+      }
+    }
+  } else {
+    getClientContextStore().supabaseUrl = normalizedUrl;
+  }
+}
+function setContextSiteId(siteId) {
+  const storage = getServerStorage();
+  if (storage) {
+    const current = storage.getStore();
+    if (current) {
+      current.siteId = siteId;
+    } else {
+      if (storage.enterWith) {
+        const next = { siteId };
+        storage.enterWith(next);
+      } else {
+        getClientContextStore().siteId = siteId;
+      }
+    }
+  } else {
+    getClientContextStore().siteId = siteId;
+  }
+}
+function setContextMediaAssetIndex(index) {
+  const storage = getServerStorage();
+  if (storage) {
+    const current = storage.getStore();
+    if (current) {
+      current.mediaAssetIndex = index;
+    } else {
+      if (storage.enterWith) {
+        const next = { mediaAssetIndex: index };
+        storage.enterWith(next);
+      } else {
+        getClientContextStore().mediaAssetIndex = index;
+      }
+    }
+  } else {
+    getClientContextStore().mediaAssetIndex = index;
+  }
+}
+function setContextResolveImageUrlContext(context) {
+  setContextSupabaseUrl(context?.supabaseUrl);
+  setContextSiteId(context?.siteId);
+  setContextMediaAssetIndex(context?.mediaAssetIndex);
+}
+function getCurrentResolveImageUrlContext() {
+  const context = getMediaContext();
+  if (!context.supabaseUrl && !context.siteId && !context.mediaAssetIndex) {
+    return void 0;
+  }
+  return {
+    supabaseUrl: context.supabaseUrl,
+    siteId: context.siteId,
+    mediaAssetIndex: context.mediaAssetIndex
+  };
+}
+function getSupabaseUrl() {
+  const context = getMediaContext();
+  if (context.supabaseUrl) {
+    return context.supabaseUrl;
+  }
+  const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  if (!url) {
+    throw new Error(
+      "NEXT_PUBLIC_SUPABASE_URL is not configured. Set it to your Supabase project URL (e.g., https://xxx.supabase.co)"
+    );
+  }
+  return url.replace(/\/$/, "");
+}
+function resolveDashboardOrigin(raw) {
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  const withoutTrailingSlash = trimmed.replace(/\/+$/, "");
+  const withoutApiSuffix = withoutTrailingSlash.replace(/\/api\/?$/, "");
+  const hasProtocol = /^https?:\/\//i.test(withoutApiSuffix);
+  const normalized = hasProtocol ? withoutApiSuffix : `http://${withoutApiSuffix.replace(/^\/+/, "")}`;
+  try {
+    return new URL(normalized).origin;
+  } catch {
+    return void 0;
+  }
+}
+function getImageProxyBasePath() {
+  const dashboardOrigin = resolveDashboardOrigin(process.env.NEXT_PUBLIC_DASHBOARD_URL);
+  if (!dashboardOrigin) return RELATIVE_IMG_PROXY_BASE_PATH;
+  return `${dashboardOrigin}${RELATIVE_IMG_PROXY_BASE_PATH}`;
+}
+function getSiteId() {
+  return getMediaContext().siteId;
+}
+function getMediaAssetIndex(context) {
+  return context?.mediaAssetIndex ?? getMediaContext().mediaAssetIndex;
+}
+function resolveCanonicalMediaAsset(value, context) {
+  const index = getMediaAssetIndex(context);
+  if (!index) return void 0;
+  if (value.assetId) {
+    const hit = index.byId.get(value.assetId);
+    if (hit) return hit;
+  }
+  const identifier = typeof value.identifier === "string" ? value.identifier.trim() : "";
+  if (identifier) {
+    const hit = index.byIdentifier.get(identifier);
+    if (hit) return hit;
+  }
+  return void 0;
+}
+function resolveMediaWithCanonicalAsset(value, context) {
+  const asset = resolveCanonicalMediaAsset(value, context);
+  if (!asset) return value;
+  return {
+    ...value,
+    assetId: asset.id ?? value.assetId,
+    identifier: typeof value.identifier === "string" && value.identifier.trim().length > 0 ? value.identifier : asset.identifier ?? value.identifier,
+    storageBucket: asset.storageBucket ?? value.storageBucket,
+    storagePath: asset.storagePath ?? value.storagePath,
+    width: asset.width ?? value.width,
+    height: asset.height ?? value.height
+  };
+}
+function resolveVideoPosterUrl(value, context) {
+  if (value.type !== "video") return void 0;
+  const poster = value.poster;
+  if (!poster) return void 0;
+  switch (poster.tag) {
+    case "external-src":
+      return poster.src;
+    case "storage":
+      return resolveMediaStorageUrl({
+        type: "image",
+        assetId: poster.assetId,
+        storageBucket: poster.storageBucket,
+        storagePath: poster.storagePath
+      }, context);
+  }
+}
+var debugMediaNodeLog = (...args) => {
+  if (typeof window === "undefined") return;
+  const debugFlag = Reflect.get(window, "__DEBUG_MEDIA_NODE__");
+  if (debugFlag === true) console.log("[MediaNode]", ...args);
+};
+function resolveMediaNodeResponsiveImage(value, size, style, slot, context) {
+  const styleAspectRatio = resolveStyleAspectRatio(style);
+  const transformAspectRatio = styleAspectRatio ?? resolveTargetAspectRatio(size);
+  const slotContract = resolveSlotContract(slot);
+  const targetAspectRatioToken = slotContract?.edit.mode === "fixed-aspect" ? slotContract.edit.aspectRatio : void 0;
+  const targetAspectRatio = parseAspectRatioValue(targetAspectRatioToken);
+  const responsive = slotContract ? resolveImageSourceSetWithContext(
+    value,
+    {
+      widthCandidates: slotContract.delivery.widthCandidates,
+      sizes: slotContract.delivery.sizes,
+      resize: "cover",
+      quality: "quality" in size ? size.quality : 80,
+      targetAspectRatio,
+      defaultWidth: "width" in size && typeof size.width === "number" ? size.width : 640
+    },
+    context
+  ) : void 0;
+  const imageUrl = responsive?.src ?? resolveImageUrlWithContext(value, size, context, transformAspectRatio);
+  const resolvedTransform = resolveMediaTransformForAspect(value.transform, transformAspectRatio);
+  const isProxy = typeof imageUrl === "string" && imageUrl.includes("/api/img/");
+  return { transformAspectRatio, responsive, imageUrl, resolvedTransform, isProxy };
+}
+function resolveSlotContract(slot) {
+  if (!slot.fieldPath) return void 0;
+  const values = asRecord(slot.blockContent);
+  if (!values) return void 0;
+  return resolveMediaSlotContract({
+    blockKind: slot.blockKind,
+    fieldPath: slot.fieldPath,
+    values,
+    fieldAspectRatio: void 0,
+    fieldUi: void 0
+  });
+}
+function resolveStyleAspectRatio(style) {
+  const raw = style?.aspectRatio;
+  if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) return raw;
+  if (typeof raw === "string" && raw.trim().length > 0) return raw.trim();
+  return void 0;
+}
+function renderVideo(value, className, style, context, options = {}) {
+  if (value.type !== "video") return null;
+  const src = resolvePublicMediaUrl(value, context);
+  if (!src) return null;
+  if (options.playback === "background") {
+    const poster2 = resolveVideoPosterUrl(value, context);
+    return /* @__PURE__ */ jsx(
+      "video",
+      {
+        className,
+        style,
+        src,
+        ...poster2 ? { poster: poster2 } : {},
+        autoPlay: true,
+        muted: true,
+        loop: true,
+        playsInline: true,
+        preload: "metadata",
+        "aria-hidden": "true",
+        "data-rb-background-video": "true"
+      }
+    );
+  }
+  const poster = resolveVideoPosterUrl(value, context);
+  return /* @__PURE__ */ jsx(
+    "video",
+    {
+      className,
+      style,
+      src,
+      ...poster ? { poster } : {},
+      controls: true,
+      controlsList: "nodownload",
+      preload: "metadata",
+      ...value.alt ? { "aria-label": value.alt } : {}
+    }
+  );
+}
+function resolvePublicMediaUrl(value, context) {
+  return resolveMediaStorageUrl(value, context) ?? value.src;
+}
+function renderAudio(value, className, style, context) {
+  if (value.type !== "audio") return null;
+  const src = resolvePublicMediaUrl(value, context);
+  if (!src) return null;
+  return /* @__PURE__ */ jsx(
+    "audio",
+    {
+      className,
+      style,
+      src,
+      controls: true,
+      controlsList: "nodownload",
+      "aria-label": value.alt ?? "Audio"
+    }
+  );
+}
+function computeMediaTransformStyle(value, style, targetAspectRatio, options) {
+  const transform = options?.resolvedTransform ?? resolveMediaTransformForAspect(value.transform, targetAspectRatio);
+  const rect = transform.rect;
+  const hotspot = transform.hotspot;
+  const rotation = transform.rotation;
+  if (!rect && !hotspot && !rotation) return style;
+  const stylePatch = {};
+  const heuristicSuppressCss = Boolean(
+    isExplicitCropProxyEnabled() && value.assetId && (typeof rotation === "number" && rotation !== 0 || isExplicitRectCrop(rect, getValidSourceDimension(value.width), getValidSourceDimension(value.height)))
+  );
+  const shouldSuppressCss = options?.isProxy ?? heuristicSuppressCss;
+  if (rect && !shouldSuppressCss) {
+    const rectPatch = buildCssRectStylePatch(value, rect);
+    if (rectPatch) {
+      const mergedRect = applyRectTransform(style, rectPatch);
+      Object.assign(stylePatch, mergedRect);
+    }
+  }
+  if (hotspot) {
+    const effectiveObjectFit = stylePatch.objectFit ?? style?.objectFit;
+    const shouldApplyHotspot = !effectiveObjectFit || effectiveObjectFit === "cover" || effectiveObjectFit === "contain";
+    if (shouldApplyHotspot && stylePatch.objectPosition === void 0) {
+      const resolved = shouldSuppressCss && rotation ? rotateNormalizedPoint({ x: hotspot.x, y: hotspot.y }, rotation) : { x: hotspot.x, y: hotspot.y };
+      stylePatch.objectPosition = `${resolved.x * 100}% ${resolved.y * 100}%`;
+    }
+  }
+  if (rotation && !shouldSuppressCss) {
+    const existingTransform = stylePatch.transform ?? style?.transform;
+    stylePatch.transform = existingTransform ? `${existingTransform} rotate(${rotation}deg)` : `rotate(${rotation}deg)`;
+    if (!stylePatch.transformOrigin) {
+      stylePatch.transformOrigin = "center";
+    }
+  }
+  return mergeStyles(style, stylePatch);
+}
+function resolveTargetAspectRatio(size) {
+  if ("original" in size) return void 0;
+  if ("width" in size && "height" in size && typeof size.width === "number" && typeof size.height === "number") {
+    return size.width / size.height;
+  }
+  return void 0;
+}
+function MediaPlaceholder({
+  className,
+  style
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: clsx_default("rb-flex rb-h-48 rb-w-full rb-items-center rb-justify-center", className),
+      style: mergeStyles(backgroundColorStyle("surface"), style),
+      children: /* @__PURE__ */ jsx("span", { className: "rb-caption", style: textColorStyle("mutedText"), children: "Image unavailable" })
+    }
+  );
+}
+function resolveImageUrlWithContext(value, options, context, transformAspectRatio) {
+  return resolveImageUrlWithContextInternal(value, options, context ?? void 0, transformAspectRatio);
+}
+function resolveImageUrlWithContextInternal(value, options, context, transformAspectRatio, resolved) {
+  if (value.type !== "image") return void 0;
+  const canonical = resolveMediaWithCanonicalAsset(value, context);
+  debugMediaNodeLog("resolveImageUrl input", {
+    assetId: canonical.assetId,
+    storagePath: canonical.storagePath,
+    src: canonical.src,
+    type: canonical.type,
+    options
+  });
+  if (canonical.storagePath && canonical.storagePath.length > 0) {
+    const resolvedStorageUrl = resolveStorageImageUrl(canonical, options, context, transformAspectRatio, resolved);
+    if (resolvedStorageUrl) {
+      return resolvedStorageUrl;
+    }
+  }
+  if (typeof canonical.src === "string" && canonical.src.length > 0) {
+    debugMediaNodeLog("resolve:explicit-src", { src: canonical.src });
+    return canonical.src;
+  }
+  const legacyUrl = typeof canonical === "object" && canonical !== null ? Reflect.get(canonical, "url") : void 0;
+  debugMediaNodeLog("resolve:fallback-url", { fallbackUrl: typeof legacyUrl === "string" ? legacyUrl : null });
+  return typeof legacyUrl === "string" ? legacyUrl : void 0;
+}
+function resolveImageSourceSetWithContext(value, options, context) {
+  const normalizedContext = context ?? void 0;
+  if (value.type !== "image") return void 0;
+  const canonical = resolveMediaWithCanonicalAsset(value, normalizedContext);
+  const widthCandidates = normalizeWidthCandidates(options.widthCandidates, MAX_SRCSET_WIDTH);
+  if (widthCandidates.length === 0) return void 0;
+  const targetAspectRatio = getPositiveAspectRatio(options.targetAspectRatio);
+  const quality = options.quality;
+  const resize = options.resize;
+  const resolvedTransform = resolveMediaTransformForAspect(canonical.transform, targetAspectRatio);
+  const sourceWidth = getValidSourceDimension(canonical.width);
+  const sourceHeight = getValidSourceDimension(canonical.height);
+  const hasExplicitRectCrop = isExplicitRectCrop(resolvedTransform.rect, sourceWidth, sourceHeight);
+  const coverFactor = resolveCoverFactor({
+    resize,
+    targetAspectRatio,
+    hasExplicitRectCrop,
+    sourceWidth,
+    sourceHeight
+  });
+  const shouldProxy = Boolean(
+    isExplicitCropProxyEnabled() && canonical.assetId && (hasExplicitRectCrop || typeof resolvedTransform.rotation === "number" && resolvedTransform.rotation !== 0)
+  );
+  const effectiveSizes = coverFactor > 1 && typeof options.sizes === "string" && options.sizes.length > 0 ? scaleSizesAttribute(options.sizes, coverFactor) : options.sizes;
+  const srcSetParts = widthCandidates.map((width) => {
+    const height = shouldProxy && hasExplicitRectCrop ? getHeightForAspect(width, targetAspectRatio) : void 0;
+    const effectiveResize = height ? resize : "contain";
+    const url = resolveImageUrlWithContextInternal(
+      canonical,
+      height ? { width, height, resize: effectiveResize, quality } : { width, resize: effectiveResize, quality },
+      normalizedContext,
+      targetAspectRatio,
+      { resolvedTransform, sourceWidth, sourceHeight }
+    );
+    if (!url) return null;
+    return `${url} ${width}w`;
+  }).filter((entry) => entry !== null);
+  if (srcSetParts.length === 0) return void 0;
+  const fallbackWidth = widthCandidates[Math.min(2, widthCandidates.length - 1)];
+  if (fallbackWidth === void 0) return void 0;
+  const defaultWidth = options.defaultWidth ?? fallbackWidth;
+  const scaledDefaultWidth = coverFactor > 1 ? Math.round(defaultWidth * coverFactor) : defaultWidth;
+  const nearestWidth = widthCandidates.find((candidate) => candidate >= scaledDefaultWidth) ?? widthCandidates[widthCandidates.length - 1];
+  if (nearestWidth === void 0) return void 0;
+  const defaultHeight = shouldProxy && hasExplicitRectCrop ? getHeightForAspect(nearestWidth, targetAspectRatio) : void 0;
+  const effectiveDefaultResize = defaultHeight ? resize : "contain";
+  const src = resolveImageUrlWithContextInternal(
+    canonical,
+    defaultHeight ? { width: nearestWidth, height: defaultHeight, resize: effectiveDefaultResize, quality } : { width: nearestWidth, resize: effectiveDefaultResize, quality },
+    normalizedContext,
+    targetAspectRatio,
+    { resolvedTransform, sourceWidth, sourceHeight }
+  );
+  if (!src) return void 0;
+  const fallbackSrc = shouldProxy ? getDirectImageUrlForValue(
+    canonical,
+    { width: nearestWidth, resize: "contain", quality },
+    normalizedContext
+  ) : void 0;
+  return {
+    src,
+    srcSet: srcSetParts.join(", "),
+    sizes: effectiveSizes,
+    fallbackSrc
+  };
+}
+function resolveCoverFactor(input) {
+  if (input.resize !== "cover") return 1;
+  if (!input.targetAspectRatio) return 1;
+  if (input.hasExplicitRectCrop) return 1;
+  if (!input.sourceWidth || !input.sourceHeight) return 1;
+  const sourceAspect = input.sourceWidth / input.sourceHeight;
+  if (!Number.isFinite(sourceAspect) || sourceAspect <= 0) return 1;
+  return sourceAspect > input.targetAspectRatio ? sourceAspect / input.targetAspectRatio : 1;
+}
+function scaleSizesAttribute(sizes, factor) {
+  const parts = splitSizesAttributeList(sizes).map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) return sizes;
+  return parts.map((part) => {
+    const parsed = parseLeadingMediaCondition(part);
+    if (parsed) {
+      const scaled2 = scaleCssLengthExpression(parsed.length, factor);
+      return scaled2 ? `${parsed.media} ${scaled2}` : part;
+    }
+    const scaled = scaleCssLengthExpression(part, factor);
+    return scaled ?? part;
+  }).join(", ");
+}
+function splitSizesAttributeList(sizes) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < sizes.length; i++) {
+    const ch = sizes[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if (ch === "," && depth === 0) {
+      out.push(sizes.slice(start, i));
+      start = i + 1;
+    }
+  }
+  out.push(sizes.slice(start));
+  return out;
+}
+function parseLeadingMediaCondition(part) {
+  const trimmed = part.trim();
+  if (!trimmed.startsWith("(")) return null;
+  let depth = 0;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) {
+        const media = trimmed.slice(0, i + 1).trim();
+        const length = trimmed.slice(i + 1).trim();
+        if (!length) return null;
+        return { media, length };
+      }
+    }
+  }
+  return null;
+}
+function scaleCssLengthExpression(token, factor) {
+  const simple = scaleCssLengthToken(token, factor);
+  if (simple) return simple;
+  if (!/\d/.test(token)) return null;
+  let didReplace = false;
+  const scaled = token.replace(/(-?\d+(?:\.\d+)?)([a-z%]+)/gi, (_full, rawNum, unit) => {
+    const raw = Number(rawNum);
+    if (!Number.isFinite(raw)) return _full;
+    didReplace = true;
+    const value = raw * factor;
+    if (!Number.isFinite(value)) return _full;
+    if (unit.toLowerCase() === "px") return `${Math.round(value)}px`;
+    const rounded = Math.round(value * 100) / 100;
+    return `${rounded}${unit}`;
+  });
+  return didReplace ? scaled : null;
+}
+function scaleCssLengthToken(token, factor) {
+  const match = token.match(/^(-?\d+(?:\.\d+)?)([a-z%]+)$/i);
+  if (!match) return null;
+  const raw = Number(match[1]);
+  const unit = match[2];
+  if (!unit) return null;
+  if (!Number.isFinite(raw)) return null;
+  const scaled = raw * factor;
+  if (!Number.isFinite(scaled)) return null;
+  if (unit.toLowerCase() === "px") {
+    return `${Math.round(scaled)}px`;
+  }
+  const rounded = Math.round(scaled * 100) / 100;
+  return `${rounded}${unit}`;
+}
+
+export { DEFAULT_BOOKING_TIME_ZONE, ImagePresets, MediaPlaceholder, addIntervalPreservingMonthAnchor, addLocalScheduleDays, asAppointmentResourceId, asAppointmentServiceId, asCustomerPassId, asFormId, asPassId, backgroundColorStyle, borderColorStyle, buildResolveImageUrlContext, clampConfiguredAmount, clsx_default, computeMediaTransformStyle, formatBookingDate, formatBookingDateParts, formatBookingDateTime, formatBookingInstant, formatBookingTime, formatLocalScheduleDate, getBookingInstalmentDepositRefundability, getBookingInstalmentPlanIntervalCount, getBookingLocalDateKey, getCurrentResolveImageUrlContext, mergeStyles, normalizeLocationAddressText, omitZeroAmountFutureRows, parseAspectRatioValue, parseBookingLocalDate, parseColorTokenParts, renderAudio, renderVideo, resolveBookingTimeZoneId, resolveFlexibleBalanceDueAt, resolveFlexibleBalanceInitialPaymentCents, resolveImageUrlWithContext, resolveMediaNodeResponsiveImage, resolvePlanningDateInput, rgbColorValue, setContextResolveImageUrlContext, splitAmountWithRemainderInFirst, textColorStyle, toBookingTimeZone, toLocationCoordinates, toScheduledBookingDateRange, toScheduledBookingDateTime };