@flocon-ai/react 0.0.0-stage → 0.0.0

package/dist/index.cjs

@@ -0,0 +1,805 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FloconPage: () => FloconPage,
+  createFloconClient: () => createFloconClient,
+  floconLlmsTxt: () => floconLlmsTxt,
+  floconSitemap: () => floconSitemap,
+  getAllPages: () => getAllPages,
+  getFloconMetadata: () => getFloconMetadata,
+  getPage: () => getPage
+});
+module.exports = __toCommonJS(index_exports);
+
+// node_modules/openapi-fetch/dist/index.mjs
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    pathSerializer: globalPathSerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const globalMiddlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      pathSerializer: requestPathSerializer,
+      body,
+      middleware: requestMiddlewares = [],
+      ...init
+    } = fetchOptions || {};
+    let finalBaseUrl = baseUrl;
+    if (localBaseUrl) {
+      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(
+      body,
+      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
+      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
+      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
+      // setting the content-type at the very beginning to be overwritten.
+      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
+      mergeHeaders(baseHeaders, headers, params.header)
+    );
+    const finalHeaders = mergeHeaders(
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      },
+      baseHeaders,
+      headers,
+      params.header
+    );
+    const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: finalHeaders
+    };
+    let id;
+    let options;
+    let request = new Request(
+      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer, pathSerializer }),
+      requestInit
+    );
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (finalMiddlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl: finalBaseUrl,
+        fetch,
+        parseAs,
+        querySerializer,
+        bodySerializer,
+        pathSerializer
+      });
+      for (const m of finalMiddlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof Request) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch(request, requestInitExt);
+      } catch (error2) {
+        let errorAfterMiddleware = error2;
+        if (finalMiddlewares.length) {
+          for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+            const m = finalMiddlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (finalMiddlewares.length) {
+        for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+          const m = finalMiddlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    const contentLength = response.headers.get("Content-Length");
+    if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      const getResponseData = async () => {
+        if (parseAs === "stream") {
+          return response.body;
+        }
+        if (parseAs === "json" && !contentLength) {
+          const raw = await response.text();
+          return raw ? JSON.parse(raw) : void 0;
+        }
+        return await response[parseAs]();
+      };
+      return { data: await getResponseData(), response };
+    }
+    let error = await response.text();
+    try {
+      error = JSON.parse(error);
+    } catch {
+    }
+    return { error, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        globalMiddlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = globalMiddlewares.indexOf(m);
+        if (i !== -1) {
+          globalMiddlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+    } else {
+      values.push(serializePrimitiveParam(name, v, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (headers) {
+    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
+    if (contentType === "application/x-www-form-urlencoded") {
+      return new URLSearchParams(body).toString();
+    }
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = options.pathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v] of iterator) {
+      if (v === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v)) {
+        for (const v2 of v) {
+          finalHeaders.append(k, v2);
+        }
+      } else if (v !== void 0) {
+        finalHeaders.set(k, v);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// src/client.ts
+var PACKAGES_API_URL = "https://api.flocon-ai.com";
+function createFloconClient() {
+  if (typeof window !== "undefined") {
+    throw new Error("Flocon: call this on the server only (route loader, server function), never in the browser");
+  }
+  const token = process.env.FLOCON_TOKEN;
+  if (!token) throw new Error("FLOCON_TOKEN is missing");
+  return createClient({
+    baseUrl: PACKAGES_API_URL,
+    headers: { Authorization: `Bearer ${token}` }
+  });
+}
+async function getPage({ path, locale }) {
+  const client = createFloconClient();
+  const { data: website, error: websiteError } = await client.GET("/website");
+  if (!website) throw new Error(`Flocon: could not load the website: ${JSON.stringify(websiteError)}`);
+  const res = await client.GET("/pages/{locale}/{path}", {
+    // The API takes the rest of the URL as the path: keep its slashes.
+    params: { path: { locale: locale ?? website.defaultLocale, path: path.replace(/^\//, "") } },
+    // openapi-fetch would encode "/" as %2F: encode each segment instead.
+    pathSerializer: (url, params) => url.replace("{locale}", encodeURIComponent(String(params?.locale))).replace("{path}", String(params?.path).split("/").map((s) => s === "." || s === ".." ? s.replace(/\./g, "%2E") : encodeURIComponent(s)).join("/"))
+  });
+  if (res.response.status === 404) return null;
+  if (!res.data) {
+    throw new Error(`Flocon: Packages API answered ${res.response.status}: ${JSON.stringify(res.error)}`);
+  }
+  return { ...res.data, badge: website.badge, defaultLocale: website.defaultLocale };
+}
+
+// src/pages.ts
+async function getAllPages() {
+  const { data, error } = await createFloconClient().GET("/pages");
+  if (!data) throw new Error(`Flocon getAllPages failed: ${JSON.stringify(error)}`);
+  return data;
+}
+var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+async function floconSitemap({ url }) {
+  const pages = await getAllPages();
+  const entries = pages.map((page) => {
+    const links = [page.locale, ...page.alternates].map((l) => `<xhtml:link rel="alternate" hreflang="${xml(l)}" href="${xml(url({ locale: l, path: page.path }))}"/>`).join("");
+    return `<url><loc>${xml(url(page))}</loc><lastmod>${xml(page.updatedAt)}</lastmod>${links}</url>`;
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">
+` + entries.join("\n") + `
+</urlset>
+`;
+}
+async function floconLlmsTxt({ url }) {
+  const pages = await getAllPages();
+  return pages.map((page) => `- [${page.title}](${url(page)})`).join("\n") + "\n";
+}
+
+// src/markdown.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var INLINE = /`([^`]+)`|\*\*(.+?)\*\*|\*(.+?)\*|\[([^\]]+)\]\(([^)\s]+)\)/;
+function isSafeUrl(url) {
+  return /^(https?:\/\/|mailto:|\/|#)/i.test(url) && !url.startsWith("//") && !url.includes("\\");
+}
+function renderInline(text, key = "") {
+  const out = [];
+  let rest = text;
+  let i = 0;
+  while (rest) {
+    const m = INLINE.exec(rest);
+    if (!m) {
+      out.push(rest);
+      break;
+    }
+    if (m.index > 0) out.push(rest.slice(0, m.index));
+    const k = `${key}${i++}`;
+    if (m[1] !== void 0) out.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: m[1] }, k));
+    else if (m[2] !== void 0) out.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: renderInline(m[2], `${k}-`) }, k));
+    else if (m[3] !== void 0) out.push(/* @__PURE__ */ (0, import_jsx_runtime.jsx)("em", { children: renderInline(m[3], `${k}-`) }, k));
+    else if (isSafeUrl(m[5])) {
+      out.push(
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", { href: m[5], children: renderInline(m[4], `${k}-`) }, k)
+      );
+    } else out.push(m[0]);
+    rest = rest.slice(m.index + m[0].length);
+  }
+  return out;
+}
+
+// src/styles.ts
+var FLOCON_CSS = `@layer flocon{
+.dark .flocon-page{color-scheme:dark}
+.flocon-page{--flocon-primary:var(--primary,light-dark(#1E6EBE,#6CB2F0));--flocon-background:var(--background,transparent);--flocon-foreground:var(--foreground,light-dark(#121A24,#E8EEF4));--flocon-card:var(--card,transparent);--flocon-muted:var(--muted,light-dark(#F3F6F9,#151E28));--flocon-muted-foreground:var(--muted-foreground,light-dark(#566373,#98A6B5));--flocon-border:var(--border,light-dark(#E4E9EF,#212C38));--flocon-radius:var(--radius,14px);--flocon-font:var(--font-sans);max-width:48rem;margin:0 auto;padding:2rem 1rem;background:var(--flocon-background);color:var(--flocon-foreground);font-family:var(--flocon-font,inherit);line-height:1.7;overflow-wrap:anywhere}
+.flocon-page h1{font-size:clamp(1.75rem,1.4rem + 1.5vw,2.25rem);line-height:1.2;margin:0 0 1.5rem;font-weight:700}
+.flocon-page h2{font-size:clamp(1.25rem,1.1rem + .7vw,1.5rem);line-height:1.3;margin:2rem 0 .75rem;font-weight:600}
+.flocon-page h3{font-size:clamp(1.1rem,1rem + .4vw,1.2rem);line-height:1.4;margin:1.5rem 0 .5rem;font-weight:600}
+.flocon-page p{margin:0 0 1rem}
+.flocon-page a{color:var(--flocon-primary);text-decoration:underline}
+.flocon-page a:focus-visible,.flocon-page summary:focus-visible{outline:2px solid var(--flocon-primary);outline-offset:2px;border-radius:calc(var(--flocon-radius)*.4)}
+.flocon-page code{background:var(--flocon-muted);border-radius:calc(var(--flocon-radius)*.4);padding:.1em .35em;font-size:.9em}
+.flocon-page .flocon-description{font-size:1.15rem;color:var(--flocon-muted-foreground)}
+.flocon-page ul,.flocon-page ol{margin:0 0 1rem;padding-left:1.5rem}
+.flocon-page li{margin:.25rem 0}
+.flocon-page .flocon-faq details{border:1px solid var(--flocon-border);border-radius:var(--flocon-radius);background:var(--flocon-card);margin:0 0 .5rem}
+.flocon-page .flocon-faq summary{cursor:pointer;font-weight:600;padding:.75rem 1rem;min-height:44px;box-sizing:border-box}
+.flocon-page .flocon-faq details p{margin:0;padding:0 1rem .75rem}
+.flocon-page .flocon-table{overflow-x:auto;margin:0 0 1rem}
+.flocon-page table{border-collapse:collapse;width:100%;font-size:.95rem;overflow-wrap:normal}
+.flocon-page th,.flocon-page td{border:1px solid var(--flocon-border);padding:.5rem .75rem;text-align:left}
+.flocon-page th{background:var(--flocon-muted)}
+.flocon-page .flocon-space{height:2rem}
+.flocon-page .flocon-related{margin-top:2rem;border-top:1px solid var(--flocon-border);padding-top:1rem}
+.flocon-page .flocon-related h2{margin-top:0;font-size:1.1rem}
+.flocon-page .flocon-related li{margin:0}
+.flocon-page .flocon-related a{display:inline-flex;align-items:center;min-height:44px}
+.flocon-page .flocon-badge{margin-top:2rem;font-size:.85rem;text-align:center}
+.flocon-page .flocon-badge a{display:inline-flex;align-items:center;min-height:44px;color:var(--flocon-muted-foreground);text-decoration:none}
+}
+`;
+
+// src/jsonld.ts
+var offer = (o) => o ? { "@type": "Offer", price: o.price, priceCurrency: o.currency } : void 0;
+function buildJsonLd(page) {
+  const { seo } = page;
+  const nodes = [];
+  const author = seo.author ? { "@type": "Person", name: seo.author.name, url: seo.author.url } : void 0;
+  for (const s of seo.schemas ?? []) {
+    switch (s.type) {
+      case "article":
+        nodes.push({
+          "@type": "Article",
+          headline: seo.title,
+          description: seo.description,
+          inLanguage: page.locale,
+          datePublished: page.createdAt,
+          dateModified: page.updatedAt,
+          author
+        });
+        break;
+      case "softwareApplication":
+        nodes.push({
+          "@type": "SoftwareApplication",
+          name: s.name,
+          description: seo.description,
+          applicationCategory: s.category,
+          operatingSystem: s.operatingSystem,
+          offers: offer(s.offers),
+          dateModified: page.updatedAt
+        });
+        break;
+      case "product":
+        nodes.push({
+          "@type": "Product",
+          name: s.name,
+          description: seo.description,
+          image: s.image,
+          offers: offer(s.offers)
+        });
+        break;
+      case "howTo":
+        nodes.push({
+          "@type": "HowTo",
+          name: s.name,
+          description: seo.description,
+          totalTime: s.totalTime,
+          step: s.steps.map((st) => ({ "@type": "HowToStep", name: st.name, text: st.text })),
+          dateModified: page.updatedAt
+        });
+        break;
+      case "event":
+        nodes.push({
+          "@type": "Event",
+          name: s.name,
+          description: seo.description,
+          startDate: s.startDate,
+          endDate: s.endDate,
+          eventAttendanceMode: s.online ? "https://schema.org/OnlineEventAttendanceMode" : s.location ? "https://schema.org/OfflineEventAttendanceMode" : void 0,
+          location: s.location ? { "@type": "Place", name: s.location.name, address: s.location.address } : void 0,
+          offers: offer(s.offers)
+        });
+        break;
+      case "localBusiness":
+        nodes.push({
+          "@type": "LocalBusiness",
+          name: s.name,
+          description: seo.description,
+          address: s.address,
+          telephone: s.telephone,
+          openingHours: s.openingHours,
+          priceRange: s.priceRange,
+          image: s.image
+        });
+        break;
+    }
+  }
+  const faq = page.blocks.flatMap((b) => b.type === "faq" ? b.items : []);
+  if (faq.length > 0) {
+    nodes.push({
+      "@type": "FAQPage",
+      mainEntity: faq.map((it) => ({
+        "@type": "Question",
+        name: it.question,
+        acceptedAnswer: { "@type": "Answer", text: it.answer }
+      }))
+    });
+  }
+  return nodes;
+}
+function jsonLdScript(page) {
+  const nodes = buildJsonLd(page);
+  if (nodes.length === 0) return null;
+  const graph = nodes.map((n) => ({ "@context": "https://schema.org", ...n }));
+  return JSON.stringify(graph).replace(/</g, "\\u003c");
+}
+
+// src/page.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var STRINGS = {
+  en: { related: "Related pages" },
+  fr: { related: "Pages associ\xE9es" }
+};
+function FloconPage({ page, url }) {
+  const t = STRINGS[page.locale] ?? STRINGS.en;
+  const jsonLd = jsonLdScript(page);
+  const href = (p) => url ? url({ locale: page.locale, path: p }) : p;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("article", { className: "flocon-page", lang: page.locale, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("style", { dangerouslySetInnerHTML: { __html: FLOCON_CSS } }),
+    jsonLd && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("script", { type: "application/ld+json", dangerouslySetInnerHTML: { __html: jsonLd } }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h1", { children: page.title }),
+    page.blocks.map((b, i) => {
+      switch (b.type) {
+        case "description":
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "flocon-description", children: renderInline(b.content) }, i);
+        case "heading":
+          return Number(b.level) === 3 ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h3", { children: b.content }, i) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h2", { children: b.content }, i);
+        case "text":
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { children: renderInline(b.content) }, i);
+        case "list": {
+          const items = b.items.map((it, j) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("li", { children: renderInline(it) }, j));
+          return b.ordered ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("ol", { children: items }, i) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("ul", { children: items }, i);
+        }
+        case "faq":
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flocon-faq", children: b.items.map((it, j) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("details", { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("summary", { children: it.question }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { children: renderInline(it.answer) })
+          ] }, j)) }, i);
+        case "table":
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flocon-table", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("table", { children: [
+            b.headers && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("thead", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: b.headers.map((h, j) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("th", { children: h }, j)) }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tbody", { children: b.rows.map((row, r) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("tr", { children: row.map((cell, c) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("td", { children: cell }, c)) }, r)) })
+          ] }) }, i);
+        case "related":
+          return b.pages.length === 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("nav", { className: "flocon-related", "aria-label": t.related, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("h2", { children: t.related }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("ul", { children: b.pages.map((p) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("li", { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("a", { href: href(p.path), children: p.title }) }, p.path)) })
+          ] }, i);
+        case "space":
+          return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { className: "flocon-space", "aria-hidden": "true" }, i);
+      }
+    }),
+    page.badge && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("p", { className: "flocon-badge", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("a", { href: "https://flocon-ai.com", children: "\u2744 Made with Flocon AI" }) })
+  ] });
+}
+
+// src/metadata.ts
+function getFloconMetadata({ page, url }) {
+  const locales = [page.locale, ...page.alternates];
+  const languages = Object.fromEntries(
+    locales.map((l) => [l, url({ locale: l, path: page.path })])
+  );
+  if (page.defaultLocale && locales.includes(page.defaultLocale)) {
+    languages["x-default"] = languages[page.defaultLocale];
+  }
+  const canonical = url({ locale: page.locale, path: page.path });
+  return {
+    title: page.seo.title,
+    description: page.seo.description,
+    keywords: page.seo.keywords,
+    canonical,
+    /** hreflang: locale (or "x-default") → URL. */
+    languages,
+    openGraph: {
+      type: "article",
+      title: page.seo.title,
+      description: page.seo.description,
+      url: canonical,
+      locale: page.locale
+    },
+    twitter: { card: "summary_large_image", title: page.seo.title, description: page.seo.description }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FloconPage,
+  createFloconClient,
+  floconLlmsTxt,
+  floconSitemap,
+  getAllPages,
+  getFloconMetadata,
+  getPage
+});