@tokenoftrust/storefront-runner 3.11.0 → 3.12.0

package/apps/storefront/src/lib/content/seo/faqItems.ts

@@ -2,7 +2,8 @@
  * The question/answer pairs a page visibly carries, for a declared FAQPage node
  * (lib/content/seo/structuredData.ts). Derived from the rendered content itself, so the markup can never
  * claim an answer the page does not show: a heading phrased as a question, answered by the text
- * up to the next heading. Fewer than two pairs is not an FAQ.
+ * up to the next heading, or a details/summary pair whose summary is the question and whose
+ * remaining text is the answer. A summary need not end in ?. Fewer than two pairs is not an FAQ.
  */
 import type { ProseSection } from "@/lib/content/prose";
 import { plainText } from "@/lib/content/richtext";
@@ -29,7 +30,17 @@ function atLeastTwo(items: FaqItem[]): FaqItem[] {
   return answered.length >= MIN_PAIRS ? answered : [];
 }
 
-/** FAQ pairs from sanitized body HTML: each question-phrased h2–h4 and the text after it. */
+/** One details element: its summary is the question, the rest of the element is the answer. */
+function detailsPair(block: string): FaqItem | null {
+  const summary = /<summary\b[^>]*>[\s\S]*?<\/summary>/i.exec(block);
+  if (!summary) return null;
+  const q = textOf(summary[0]);
+  const at = summary.index ?? 0;
+  const rest = block.slice(0, at) + block.slice(at + summary[0].length);
+  return { q, a: textOf(rest) };
+}
+
+/** FAQ pairs from sanitized body HTML: question-phrased h2–h4, plus every details/summary pair. */
 export function faqFromHtml(html: string | undefined): FaqItem[] {
   if (!html) return [];
   const parts = html.split(/(<h[2-4][^>]*>[\s\S]*?<\/h[2-4]>)/i);
@@ -38,6 +49,10 @@ export function faqFromHtml(html: string | undefined): FaqItem[] {
     const q = textOf(parts[i]!);
     if (isQuestion(q)) items.push({ q, a: textOf(parts[i + 1] ?? "") });
   }
+  for (const block of html.matchAll(/<details\b[^>]*>[\s\S]*?<\/details>/gi)) {
+    const pair = detailsPair(block[0]);
+    if (pair) items.push(pair);
+  }
   return atLeastTwo(items);
 }
 

package/apps/storefront/src/middleware/renderChain.ts

@@ -49,6 +49,13 @@ import {
   resolveCapabilities,
   capabilitiesArtifactPath,
   resolveServableChannelVersion,
+  resolveChannelVersion,
+  serveTenantAsset,
+  parseTenantAssetPath,
+  compileRouteTierIndexV1,
+  parsePublicationVersionStateV1Json,
+  publicationVersionStateKey,
+  readPublicationRootAssetV1,
   channelFromEnv,
   resolveEnvironmentOnlyPlan,
   INTEGRATION_NONCE_PLACEHOLDER,
@@ -66,6 +73,17 @@ import {
 } from "@tot/public-runtime";
 import { readBakedManagedInstalls } from "@/lib/integrations/integration/bakedManagedInstalls";
 import { readWithImagePreviewRewriteOverlay } from "@tot/public-runtime/image-preview-rewrite-overlay";
+import { publicationRecoveryActiveV1, publicationRecoveryKeyV1 } from "@tot/public-runtime/publication-recovery";
+import {
+  distinctTenantThemeGroups,
+  inlineDistinctTenantThemeGroups,
+  previewThemeInlineApplies,
+  selectServedThemeCss,
+} from "@tot/public-runtime/theme-stylesheets";
+import {
+  resolvePreviewVersionFromCookies,
+  resolveSharedPreviewAssetVersion,
+} from "@/lib/assets/preview-version-cookie";
 import type {
   CapabilityConfig,
   ConsentSnapshot,
@@ -75,7 +93,10 @@ import type {
   ThemeTokens,
   BrowserEnvironment,
   PublicationArtifactBucketV1,
+  PublicationArtifactReadBucketV1,
+  PublicationChannelV1,
   PublicationRoutePlanV1,
+  R2BucketLike,
   RouteTierIndexV1,
 } from "@tot/public-runtime";
 import {
@@ -359,7 +380,6 @@ export async function runRenderChain(input: RenderChainInput): Promise<Response>
   // Digest-addressed static-bundle serving. Deliberately before the edge page
   // cache/catalog/theme machinery. A selected publication bypasses this legacy
   // whole-site bundle until B1 can compose mounted spaces into it reproducibly.
-  const { resolvePreviewVersionFromCookies } = await import("@/lib/assets/preview-version-cookie");
   const cookieRevision = await resolvePreviewVersionFromCookies({
     tenantId: tenant.tenant_id,
     previewVersionCookie: context.cookies.get("tot_preview_version")?.value,
@@ -787,6 +807,21 @@ export async function runRenderChain(input: RenderChainInput): Promise<Response>
     nonce: cspNonce,
   });
 
+  // Distinct tenant theme sheets are render-blocking `/tenants/` fetches. Inline
+  // them into this preview document. Publication capture keeps the source links
+  // so the asset pipeline concatenates the same run for both CDNs.
+  response = await inlinePreviewTenantThemes(response, {
+    request,
+    customizationEnv: customization.env,
+    tenant,
+    kvGet,
+    isPreviewHost,
+    previewToken,
+    previewSecret,
+    nowSeconds,
+    pinnedVersionId: cookieRevision,
+  });
+
   // Baseline security headers on every response — set before the page-cache
   // store below so cached copies carry them too.
   applySecurityHeaders(response.headers);
@@ -919,3 +954,169 @@ export async function runRenderChain(input: RenderChainInput): Promise<Response>
   // matching nonce/CSP pair, and no nonce is reused across responses (ADR 0018).
   return await stampResponseNonce(response, freshNonce());
 }
+
+/**
+ * Inline a run of distinct tenant theme stylesheets into a preview document.
+ * Bytes follow the `/tenants/<id>/` route: publication root, then the preview
+ * overlay, then the asset store. A miss leaves that run as links.
+ */
+async function inlinePreviewTenantThemes(response: Response, input: {
+  request: Request;
+  customizationEnv: "live" | "test";
+  tenant: TenantConfig;
+  kvGet: (key: string) => Promise<string | null>;
+  isPreviewHost: boolean;
+  previewToken: string | null;
+  previewSecret: string | null;
+  nowSeconds: number;
+  pinnedVersionId: string | null;
+}): Promise<Response> {
+  if (!previewThemeInlineApplies({
+    method: input.request.method,
+    customizationEnv: input.customizationEnv,
+    captureProbe: input.request.headers.get(HTML_CACHE_POLICY_CAPTURE_PROBE),
+    contentType: response.headers.get("content-type") ?? "",
+  }) || response.status !== 200) return response;
+
+  const html = await response.text();
+  if (distinctTenantThemeGroups(html).length === 0) return htmlResponse(response, html);
+
+  try {
+    const shared = input.pinnedVersionId
+      ? { preview: false, versionId: null }
+      : await resolveSharedPreviewAssetVersion({
+          tenantId: input.tenant.tenant_id,
+          previewHost: input.isPreviewHost,
+          previewToken: input.previewToken,
+          secret: input.previewSecret,
+          nowSeconds: input.nowSeconds,
+          readPreviewChannelVersion: () =>
+            resolveChannelVersion(input.kvGet, input.tenant.tenant_id, "preview"),
+        });
+    const previewVersionId = input.pinnedVersionId ?? shared.versionId;
+    const publicationChannel: PublicationChannelV1 =
+      shared.preview || input.customizationEnv === "test" ? "preview" : "live";
+    const assetChannel = shared.preview ? "test" as const : input.customizationEnv;
+    const bucket = await readR2("TENANT_ASSETS");
+    const paths = [...new Set(
+      distinctTenantThemeGroups(html).flatMap((group) => group.sheets.map((sheet) => sheet.path)),
+    )];
+    const css = new Map<string, string | null>();
+    await Promise.all(paths.map(async (pathname) => {
+      try {
+        css.set(pathname, bucket
+          ? await readPreviewThemeCss({
+              tenant: input.tenant,
+              pathname,
+              bucket: bucket as unknown as R2BucketLike,
+              kvGet: input.kvGet,
+              publicationChannel,
+              assetChannel,
+              previewVersionId,
+            })
+          : null);
+      } catch {
+        css.set(pathname, null);
+      }
+    }));
+    const next = inlineDistinctTenantThemeGroups(html, (pathname) => css.get(pathname) ?? null);
+    return htmlResponse(response, next);
+  } catch {
+    return htmlResponse(response, html);
+  }
+}
+
+function htmlResponse(response: Response, html: string): Response {
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  return new Response(html, { status: response.status, statusText: response.statusText, headers });
+}
+
+async function readPreviewThemeCss(input: {
+  tenant: TenantConfig;
+  pathname: string;
+  bucket: R2BucketLike;
+  kvGet: (key: string) => Promise<string | null>;
+  publicationChannel: PublicationChannelV1;
+  assetChannel: "live" | "test";
+  previewVersionId: string | null;
+}): Promise<string | null> {
+  return selectServedThemeCss({
+    previewVersionId: input.previewVersionId,
+    publicationRoot: () => publicationRootThemeCss(input),
+    overlay: () => overlayThemeCss(input),
+    asset: () => assetThemeCss(input),
+  });
+}
+
+/** Same order as GET `/tenants/<id>/<path>`: a selected root file answers, including its 404. */
+async function publicationRootThemeCss(input: {
+  tenant: TenantConfig;
+  pathname: string;
+  bucket: R2BucketLike;
+  kvGet: (key: string) => Promise<string | null>;
+  publicationChannel: PublicationChannelV1;
+}): Promise<"legacy" | "absent" | string> {
+  const parsed = parseTenantAssetPath(input.pathname);
+  if (!parsed || parsed.tenantId !== input.tenant.tenant_id) return "legacy";
+  if (!input.tenant.publicationSpaces?.some((space) => space.routes.canonicalMount === "/")) return "legacy";
+  const [stateJson, recoveryJson] = await Promise.all([
+    input.kvGet(publicationVersionStateKey(input.tenant.tenant_id)),
+    input.publicationChannel === "live"
+      ? input.kvGet(publicationRecoveryKeyV1(input.tenant.tenant_id))
+      : Promise.resolve(null),
+  ]);
+  if (stateJson === null || publicationRecoveryActiveV1(recoveryJson)) return "legacy";
+  const state = parsePublicationVersionStateV1Json(stateJson);
+  if (!state.ok) return "legacy";
+  const read = await readPublicationRootAssetV1({
+    index: compileRouteTierIndexV1(input.tenant),
+    state: state.value,
+    channel: input.publicationChannel,
+    bucket: input.bucket as unknown as PublicationArtifactReadBucketV1,
+    relativePath: parsed.rel,
+  });
+  if (read.status === "legacy-root") return "legacy";
+  if (read.status === "absent") return "absent";
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(read.bytes);
+  } catch {
+    return "absent";
+  }
+}
+
+async function overlayThemeCss(input: {
+  tenant: TenantConfig;
+  pathname: string;
+  kvGet: (key: string) => Promise<string | null>;
+  previewVersionId: string | null;
+}): Promise<string | null> {
+  if (!input.previewVersionId) return null;
+  const parsed = parseTenantAssetPath(input.pathname);
+  if (!parsed || parsed.tenantId !== input.tenant.tenant_id) return null;
+  return readWithImagePreviewRewriteOverlay(
+    input.kvGet,
+    input.tenant.tenant_id,
+    input.previewVersionId,
+    `tenants/${input.tenant.tenant_id}/public/${parsed.rel}`,
+    async () => null,
+  );
+}
+
+async function assetThemeCss(input: {
+  pathname: string;
+  bucket: R2BucketLike;
+  kvGet: (key: string) => Promise<string | null>;
+  assetChannel: "live" | "test";
+  previewVersionId: string | null;
+}): Promise<string | null> {
+  const res = await serveTenantAsset({
+    bucket: input.bucket,
+    kvGet: input.kvGet,
+    channel: input.assetChannel,
+    ...(input.previewVersionId ? { versionId: input.previewVersionId } : {}),
+  }, input.pathname);
+  if (!res || res.status !== 200) return null;
+  return res.text();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenoftrust/storefront-runner",
-  "version": "3.11.0",
+  "version": "3.12.0",
   "license": "SEE LICENSE IN LICENSE",
   "description": "World-shareable storefront runner: multi-tenant renderer on Astro/Cloudflare. No control plane.",
   "packageManager": "pnpm@11.9.0",

package/packages/public-runtime/package.json

@@ -31,6 +31,7 @@
     "./publication-recovery": "./src/publication-recovery.ts",
     "./tenant-embed-defaults": "./src/tenant-embed-defaults.mjs",
     "./declared-tenant-config": "./src/declared-tenant-config.mjs",
+    "./theme-stylesheets": "./src/theme-stylesheets.mjs",
     "./compliance-coherence": "./src/compliance-coherence.mjs",
     "./integration/lifecycle-host-asset": "./src/integration/lifecycle-host-asset.mjs",
     "./integration/native-ga4-sandbox-asset": "./src/integration/native-ga4-sandbox-asset.mjs",

package/packages/public-runtime/src/theme-stylesheets.mjs

@@ -0,0 +1,321 @@
+// @ts-check
+/**
+ * Distinct tenant theme stylesheets.
+ *
+ * A run of two or more different `/tenants/<id>/themes/*.css` links is one
+ * theme sheet. `/shared/` and `/_astro/` stay their own links and split a run.
+ * The same path repeated is not this case. Print, disabled, alternate, and
+ * commented links are not members. Integrity and an unusual media query split
+ * a run and are left in place.
+ *
+ * Preview inlines the run into the document already being rendered. Publication
+ * concatenates the same run in the asset pipeline. Neither path branches on a
+ * tenant id, and neither adds a Worker in front of public HTML.
+ */
+
+const TENANT_THEME_STYLESHEET = /^\/tenants\/[^/]+\/themes\/[^/?#]+\.css$/i;
+const SIMPLE_MEDIA = new Set(["", "all", "screen"]);
+const CSS_REF_RE = /url\(\s*(['"]?)([^'")]+?)\1\s*\)|@import\s+(['"])([^'"]+)\3/g;
+
+/**
+ * @param {string} pathname
+ */
+export function isTenantThemeStylesheetPath(pathname) {
+  return TENANT_THEME_STYLESHEET.test(pathname);
+}
+
+/**
+ * Preview inlines only a dynamic HTML GET that is not the publication capture
+ * and not the live document. The capture must still see the source links so
+ * the asset pipeline can copy each file.
+ * @param {{ method: string, customizationEnv: string, captureProbe: string | null, contentType: string }} input
+ */
+export function previewThemeInlineApplies(input) {
+  if (input.method !== "GET") return false;
+  if (input.customizationEnv === "live") return false;
+  if (input.captureProbe != null) return false;
+  return input.contentType.toLowerCase().includes("text/html");
+}
+
+/**
+ * Publication-root, then the preview rewrite overlay, then the asset store.
+ * `"absent"` stops the cascade: that is a selected publication file the
+ * browser would 404, not a cue to serve a different copy.
+ * @param {{
+ *   previewVersionId: string | null,
+ *   publicationRoot: () => Promise<"legacy" | "absent" | string>,
+ *   overlay: () => Promise<string | null>,
+ *   asset: () => Promise<string | null>,
+ * }} input
+ * @returns {Promise<string | null>}
+ */
+export async function selectServedThemeCss(input) {
+  const root = await input.publicationRoot();
+  if (root === "absent") return null;
+  if (root !== "legacy") return root;
+  if (input.previewVersionId) {
+    const overlay = await input.overlay();
+    if (overlay != null) return overlay;
+  }
+  return input.asset();
+}
+
+/**
+ * @param {string} html
+ * @returns {{ sheets: { start: number, end: number, path: string }[] }[]}
+ */
+export function distinctTenantThemeGroups(html) {
+  /** @type {{ start: number, end: number, path: string }[]} */
+  let run = [];
+  /** @type {{ sheets: { start: number, end: number, path: string }[] }[]} */
+  const groups = [];
+  const flush = () => {
+    if (run.length >= 2 && new Set(run.map((sheet) => sheet.path)).size >= 2) {
+      groups.push({ sheets: run });
+    }
+    run = [];
+  };
+  for (const sheet of blockingStylesheetLinks(html)) {
+    if (sheet.member) run.push(sheet);
+    else flush();
+  }
+  flush();
+  return groups;
+}
+
+/**
+ * Replace each distinct theme run with one inline style. A run whose bytes
+ * are missing, not utf-8, or whose relative url escapes the site is left as links.
+ * @param {string} html
+ * @param {(pathname: string) => string | null} cssFor
+ */
+export function inlineDistinctTenantThemeGroups(html, cssFor) {
+  const groups = distinctTenantThemeGroups(html);
+  if (groups.length === 0) return html;
+  /** @type {{ start: number, end: number, replacement: string }[]} */
+  const edits = [];
+  for (const group of groups) {
+    /** @type {string[]} */
+    const parts = [];
+    let skip = false;
+    for (const sheet of group.sheets) {
+      const css = cssFor(sheet.path);
+      const prepared = css == null ? null : prepareInlineSheet(css, sheet.path);
+      if (prepared == null) {
+        skip = true;
+        break;
+      }
+      parts.push(prepared);
+    }
+    const first = group.sheets[0];
+    if (skip || !first) continue;
+    const style = `<style data-tot-theme>${escapeStyleBody(parts.join("\n"))}</style>`;
+    edits.push({ start: first.start, end: first.end, replacement: style });
+    for (const sheet of group.sheets.slice(1)) {
+      edits.push({ start: sheet.start, end: sheet.end, replacement: "" });
+    }
+  }
+  return applyStylesheetEdits(html, edits);
+}
+
+/**
+ * @param {string} html
+ * @param {{ start: number, end: number, replacement: string }[]} edits
+ */
+export function applyStylesheetEdits(html, edits) {
+  const ordered = [...edits].sort((a, b) => b.start - a.start || b.end - a.end);
+  let out = html;
+  for (const edit of ordered) {
+    out = out.slice(0, edit.start) + edit.replacement + out.slice(edit.end);
+  }
+  return out;
+}
+
+/**
+ * @param {string} css
+ * @param {string} stylesheetPath
+ * @returns {string | null}
+ */
+function prepareInlineSheet(css, stylesheetPath) {
+  const charset = /^\uFEFF?@charset\s+["']([^"']+)["']\s*;/.exec(css);
+  const charsetLabel = charset?.[1];
+  if (charset && charsetLabel) {
+    if (charsetLabel.toLowerCase() !== "utf-8") return null;
+    css = css.slice(charset[0].length).replace(/^\s+/, "");
+  }
+  return rewriteRelativeCssUrls(css, stylesheetPath);
+}
+
+/**
+ * Root-absolute urls, so an inlined sheet resolves the same files the link did.
+ * A relative reference that escapes the site cannot be rewritten; the caller
+ * leaves the links in place.
+ * @param {string} css
+ * @param {string} stylesheetPath
+ * @returns {string | null}
+ */
+function rewriteRelativeCssUrls(css, stylesheetPath) {
+  const cssRel = stylesheetPath.replace(/^\/+/, "");
+  let escaped = false;
+  const out = css.replace(CSS_REF_RE, (whole, q1, u1, q2, u2) => {
+    const raw = (u1 ?? u2 ?? "").trim();
+    if (!raw || raw.startsWith("#") || raw.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(raw)) return whole;
+    const cut = raw.search(/[?#]/);
+    const path = cut === -1 ? raw : raw.slice(0, cut);
+    const suffix = cut === -1 ? "" : raw.slice(cut);
+    if (path.startsWith("/")) return whole;
+    let rel = null;
+    try {
+      rel = resolveRelative(cssRel, decodeURIComponent(path));
+    } catch {
+      rel = null;
+    }
+    if (!rel) {
+      escaped = true;
+      return whole;
+    }
+    const target = `/${rel}${suffix}`;
+    return u1 !== undefined ? `url(${q1}${target}${q1})` : `@import ${q2}${target}${q2}`;
+  });
+  return escaped ? null : out;
+}
+
+/**
+ * @param {string} fromRel
+ * @param {string} ref
+ * @returns {string | null}
+ */
+function resolveRelative(fromRel, ref) {
+  const parts = fromRel.split("/").slice(0, -1);
+  for (const seg of ref.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") {
+      if (!parts.length) return null;
+      parts.pop();
+    } else parts.push(seg);
+  }
+  return parts.length ? parts.join("/") : null;
+}
+
+/**
+ * @param {string} css
+ */
+function escapeStyleBody(css) {
+  return css.replace(/<\/style/gi, "<\\/style");
+}
+
+/**
+ * @param {string} html
+ * @returns {{ start: number, end: number, path: string, member: boolean }[]}
+ */
+function blockingStylesheetLinks(html) {
+  const head = headSpan(html);
+  const comments = commentRanges(html);
+  /** @type {{ start: number, end: number, path: string, member: boolean }[]} */
+  const sheets = [];
+  for (const match of html.slice(head.start, head.end).matchAll(/<link\b([^>]*)>/gi)) {
+    const start = head.start + (match.index ?? 0);
+    if (inside(comments, start)) continue;
+    const attrs = match[1] ?? "";
+    const parsed = parseTagAttrs(attrs);
+    const rel = relTokens(parsed.rel);
+    if (!rel.includes("stylesheet") || rel.includes("alternate")) continue;
+    if (hasFlag(attrs, "disabled")) continue;
+    const media = (parsed.media || "").trim().toLowerCase();
+    if (media === "print") continue;
+    const href = (parsed.href || "").trim();
+    const path = pathnameOf(href);
+    const local = href.startsWith("/") && !href.startsWith("//");
+    const integrity = Object.prototype.hasOwnProperty.call(parsed, "integrity");
+    const odd = !SIMPLE_MEDIA.has(media);
+    if (!path) continue;
+    const member = local && !integrity && !odd && isTenantThemeStylesheetPath(path);
+    sheets.push({
+      start,
+      end: start + match[0].length,
+      path,
+      member,
+    });
+  }
+  return sheets;
+}
+
+/**
+ * @param {string} html
+ */
+function headSpan(html) {
+  const explicit = /<head[\s>][\s\S]*?<\/head>/i.exec(html);
+  if (explicit && explicit.index !== undefined) {
+    return { start: explicit.index, end: explicit.index + explicit[0].length };
+  }
+  const bodyAt = html.search(/<body[\s>]/i);
+  return { start: 0, end: bodyAt >= 0 ? bodyAt : html.length };
+}
+
+/**
+ * @param {string} html
+ * @returns {[number, number][]}
+ */
+function commentRanges(html) {
+  /** @type {[number, number][]} */
+  const ranges = [];
+  for (const match of html.matchAll(/<!--[\s\S]*?-->/g)) {
+    const start = match.index ?? 0;
+    ranges.push([start, start + match[0].length]);
+  }
+  return ranges;
+}
+
+/**
+ * @param {[number, number][]} ranges
+ * @param {number} index
+ */
+function inside(ranges, index) {
+  return ranges.some(([start, end]) => index >= start && index < end);
+}
+
+/**
+ * @param {string} href
+ * @returns {string}
+ */
+function pathnameOf(href) {
+  const bare = href.split(/[?#]/)[0] ?? "";
+  if (/^https?:/i.test(bare)) {
+    try {
+      return new URL(bare).pathname;
+    } catch {
+      return bare;
+    }
+  }
+  return bare;
+}
+
+/**
+ * @param {string} attrs
+ * @returns {Record<string, string>}
+ */
+function parseTagAttrs(attrs) {
+  /** @type {Record<string, string>} */
+  const out = {};
+  for (const match of attrs.matchAll(/([a-zA-Z_:][\w:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g)) {
+    const name = match[1];
+    if (!name) continue;
+    out[name.toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? "";
+  }
+  return out;
+}
+
+/**
+ * @param {string} attrs
+ * @param {string} name
+ */
+function hasFlag(attrs, name) {
+  return new RegExp(`(?:^|\\s)${name}(?=\\s|/|=|$)`, "i").test(attrs);
+}
+
+/**
+ * @param {string | undefined} rel
+ */
+function relTokens(rel) {
+  return String(rel || "").trim().toLowerCase().split(/\s+/).filter(Boolean);
+}