@uptrademedia/site-kit 1.0.5 → 1.0.8

package/dist/seo/index.js

@@ -3,15 +3,206 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var chunkHCFPU7TU_js = require('../chunk-HCFPU7TU.js');
-var chunkSBVEYCSV_js = require('../chunk-SBVEYCSV.js');
-var chunkQP5NCO2E_js = require('../chunk-QP5NCO2E.js');
-require('../chunk-EQCVQC35.js');
+var chunkQQB4FO4Q_js = require('../chunk-QQB4FO4Q.js');
+var chunkVDI7KYME_js = require('../chunk-VDI7KYME.js');
+require('../chunk-ZSMWDLMK.js');
+var react = require('react');
+require('server-only');
 var jsxRuntime = require('react/jsx-runtime');
 
+function getSecureApiConfig() {
+  const apiUrl = process.env.UPTRADE_API_URL || process.env.NEXT_PUBLIC_UPTRADE_API_URL || "https://api.uptrademedia.com";
+  const apiKey = process.env.UPTRADE_API_KEY || "";
+  const projectId = process.env.UPTRADE_PROJECT_ID || "";
+  if (!apiKey) {
+    throw new Error("@uptrade/seo: UPTRADE_API_KEY environment variable is required for server-side SEO functions");
+  }
+  return { apiUrl, apiKey, projectId };
+}
+async function secureApiPost(endpoint, body = {}) {
+  const { apiUrl, apiKey } = getSecureApiConfig();
+  try {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify(body),
+      next: { revalidate: 60 }
+      // Cache for 60 seconds
+    });
+    if (!response.ok) {
+      console.error(`@uptrade/seo: API error ${response.status}: ${response.statusText}`);
+      return null;
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("@uptrade/seo: Network error:", error);
+    return null;
+  }
+}
+var getSEOPageData = react.cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/page", {
+    projectId,
+    path
+  });
+  return result?.page || null;
+});
+var getSchemaMarkups2 = react.cache(async (projectId, path, options) => {
+  const result = await secureApiPost("/api/public/seo/schemas", {
+    projectId,
+    path,
+    includeTypes: options?.includeTypes,
+    excludeTypes: options?.excludeTypes
+  });
+  return result?.schemas || [];
+});
+var getFAQData2 = react.cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/faq", {
+    projectId,
+    path
+  });
+  return result?.faq || null;
+});
+var getInternalLinks2 = react.cache(async (projectId, sourcePath, options) => {
+  const result = await secureApiPost("/api/public/seo/internal-links", {
+    projectId,
+    sourcePath,
+    position: options?.position,
+    limit: options?.limit
+  });
+  return result?.links || [];
+});
+var getContentBlock2 = react.cache(async (projectId, path, section) => {
+  const result = await secureApiPost("/api/public/seo/content", {
+    projectId,
+    path,
+    section
+  });
+  return result?.content || null;
+});
+var getABTest = react.cache(async (projectId, path, field) => {
+  const result = await secureApiPost("/api/public/seo/ab-test", {
+    projectId,
+    path,
+    field
+  });
+  return result?.test || null;
+});
+async function recordABImpression(testId, variant, sessionId) {
+  await secureApiPost("/api/public/seo/ab-impression", { testId, variant, sessionId });
+}
+var getRedirectData = react.cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/redirect", {
+    projectId,
+    path
+  });
+  return result?.redirect || null;
+});
+var getManagedScripts2 = react.cache(async (projectId, position, currentPath) => {
+  const result = await secureApiPost("/api/public/seo/scripts", {
+    projectId,
+    position,
+    currentPath
+  });
+  return result?.scripts || [];
+});
+var getRobotsData = react.cache(async (projectId, path) => {
+  const result = await secureApiPost("/api/public/seo/page", {
+    projectId,
+    path
+  });
+  return result?.page?.managed_robots || null;
+});
+var getSitemapEntries = react.cache(async (projectId, options) => {
+  const result = await secureApiPost("/api/public/seo/sitemap", {
+    projectId,
+    publishedOnly: options?.publishedOnly
+  });
+  return result?.entries || [];
+});
+async function registerSitemap(entries) {
+  const { apiUrl, apiKey, projectId } = getSecureApiConfig();
+  try {
+    const response = await fetch(`${apiUrl}/api/public/seo/register-sitemap`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      body: JSON.stringify({ projectId, entries })
+    });
+    if (!response.ok) {
+      console.error(`@uptrade/seo: Sitemap registration failed: ${response.statusText}`);
+      return { success: false, created: 0, updated: 0 };
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("@uptrade/seo: Sitemap registration error:", error);
+    return { success: false, created: 0, updated: 0 };
+  }
+}
+function getSignalApiConfig() {
+  const apiUrl = process.env.SIGNAL_API_URL || process.env.NEXT_PUBLIC_SIGNAL_API_URL || "https://signal.uptrademedia.com";
+  const apiKey = process.env.UPTRADE_API_KEY || "";
+  return { apiUrl, apiKey };
+}
+async function signalApiGet(endpoint) {
+  const { apiUrl, apiKey } = getSignalApiConfig();
+  if (!apiKey) {
+    return null;
+  }
+  try {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey
+      },
+      next: { revalidate: 300 }
+      // Cache for 5 minutes
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const result = await response.json();
+    return result?.data || result;
+  } catch (error) {
+    console.error("@uptrade/seo: Signal API error:", error);
+    return null;
+  }
+}
+var getEntities2 = react.cache(async (projectId, options) => {
+  let endpoint = `/skills/seo/entities/${projectId}`;
+  if (options?.type) {
+    endpoint += `?type=${options.type}`;
+  }
+  const result = await signalApiGet(endpoint);
+  return result || [];
+});
+var getPrimaryEntity = react.cache(async (projectId) => {
+  return signalApiGet(`/skills/seo/entities/${projectId}/primary`);
+});
+var getEntityEnhancedSchema2 = react.cache(async (projectId, pagePath) => {
+  const result = await signalApiGet(
+    `/skills/seo/schema/${projectId}/entity-enhanced?pagePath=${encodeURIComponent(pagePath)}`
+  );
+  return result?.schemas || [];
+});
+var getVisibilityScore = react.cache(async (projectId, pagePath) => {
+  const result = await signalApiGet(`/skills/seo/visibility/${projectId}`);
+  if (!result) return null;
+  return result.find((s) => s.page_path === pagePath) || null;
+});
+var getVisibilitySummary = react.cache(async (projectId) => {
+  return signalApiGet(`/skills/seo/visibility/${projectId}/summary`);
+});
+
 // src/seo/getManagedMetadata.ts
 async function getManagedMetadata(options) {
   const { projectId, path, fallback = {}, overrides = {} } = options;
-  const pageData = await chunkQP5NCO2E_js.getSEOPageData(projectId, path);
+  const pageData = await getSEOPageData(projectId, path);
   if (!pageData) {
     return {
       ...fallback,
@@ -29,8 +220,8 @@ async function getManagedMetadata(options) {
   } else if (fallback.title) {
     metadata.title = fallback.title;
   }
-  if (pageData.managed_description) {
-    metadata.description = pageData.managed_description;
+  if (pageData.managed_meta_description || pageData.managed_description) {
+    metadata.description = pageData.managed_meta_description || pageData.managed_description;
   } else if (fallback.description) {
     metadata.description = fallback.description;
   }
@@ -49,7 +240,7 @@ async function getManagedMetadata(options) {
     };
   }
   const ogTitle = pageData.managed_og_title || pageData.managed_title;
-  const ogDescription = pageData.managed_og_description || pageData.managed_description;
+  const ogDescription = pageData.managed_og_description || pageData.managed_meta_description || pageData.managed_description;
   const ogImage = pageData.managed_og_image;
   if (ogTitle || ogDescription || ogImage) {
     metadata.openGraph = {
@@ -75,7 +266,7 @@ async function getManagedMetadata(options) {
 }
 async function getABVariant(options) {
   const { projectId, path, field, sessionId } = options;
-  const test = await chunkQP5NCO2E_js.getABTest(projectId, path, field);
+  const test = await getABTest(projectId, path, field);
   if (!test) {
     return null;
   }
@@ -88,7 +279,7 @@ async function getABVariant(options) {
   } else {
     variant = Math.random() < test.traffic_split ? "a" : "b";
   }
-  chunkQP5NCO2E_js.recordABImpression(test.id, variant, sessionId).catch(() => {
+  recordABImpression(test.id, variant, sessionId).catch(() => {
   });
   return {
     testId: test.id,
@@ -119,21 +310,47 @@ async function getManagedMetadataWithAB(options) {
   }
   return metadata;
 }
+var DEFAULT_SPEAKABLE_SELECTORS = [
+  "h1",
+  '[data-speakable="true"]',
+  ".page-summary",
+  ".key-points",
+  '.aeo-block[data-speakable="true"]'
+];
 async function ManagedSchema({
   projectId,
   path,
   additionalSchemas = [],
   includeTypes,
-  excludeTypes
+  excludeTypes,
+  speakable,
+  pageType = "WebPage",
+  pageName,
+  pageUrl,
+  includeEntityGraph = false
 }) {
-  const schemas = await chunkQP5NCO2E_js.getSchemaMarkups(projectId, path, {
+  const schemas = await chunkVDI7KYME_js.getSchemaMarkups(projectId, path, {
     includeTypes,
     excludeTypes
   });
+  let entitySchemas = [];
+  if (includeEntityGraph) {
+    entitySchemas = await chunkVDI7KYME_js.getEntityEnhancedSchema(projectId, path);
+  }
   const allSchemas = [
+    ...entitySchemas,
     ...schemas.map((s) => s.schema_json),
     ...additionalSchemas
   ];
+  if (speakable && pageName && pageUrl) {
+    const speakableSchema = createSpeakableWebPageSchema(
+      pageType,
+      pageName,
+      pageUrl,
+      typeof speakable === "object" ? speakable : void 0
+    );
+    allSchemas.push(speakableSchema);
+  }
   if (allSchemas.length === 0) {
     return null;
   }
@@ -162,6 +379,25 @@ function createSchema(type, data) {
     ...data
   };
 }
+function createSpeakableWebPageSchema(type, name, url, speakable) {
+  const speakableSpec = {
+    "@type": "SpeakableSpecification"
+  };
+  if (speakable?.cssSelector?.length) {
+    speakableSpec.cssSelector = speakable.cssSelector;
+  } else if (speakable?.xpath?.length) {
+    speakableSpec.xpath = speakable.xpath;
+  } else {
+    speakableSpec.cssSelector = DEFAULT_SPEAKABLE_SELECTORS;
+  }
+  return {
+    "@context": "https://schema.org",
+    "@type": type,
+    name,
+    url,
+    speakable: speakableSpec
+  };
+}
 function createBreadcrumbSchema(baseUrl, path, labels) {
   const segments = path.split("/").filter(Boolean);
   const items = segments.map((segment, index) => {
@@ -219,7 +455,7 @@ async function ManagedFAQ({
   includeSchema = true,
   showTitle = true
 }) {
-  const faqData = await chunkQP5NCO2E_js.getFAQData(projectId, path);
+  const faqData = await chunkVDI7KYME_js.getFAQData(projectId, path);
   if (!faqData || !faqData.items?.length) {
     return null;
   }
@@ -268,7 +504,7 @@ async function ManagedInternalLinks({
   className,
   renderLink
 }) {
-  const links = await chunkQP5NCO2E_js.getInternalLinks(projectId, path, { position, limit });
+  const links = await chunkVDI7KYME_js.getInternalLinks(projectId, path, { position, limit });
   if (!links.length) {
     return null;
   }
@@ -301,33 +537,80 @@ async function ManagedInternalLinks({
 function renderMarkdown(content) {
   return content.replace(/^### (.*$)/gim, "<h3>$1</h3>").replace(/^## (.*$)/gim, "<h2>$1</h2>").replace(/^# (.*$)/gim, "<h1>$1</h1>").replace(/\*\*(.*)\*\*/gim, "<strong>$1</strong>").replace(/\*(.*)\*/gim, "<em>$1</em>").replace(/\[(.*?)\]\((.*?)\)/gim, '<a href="$2">$1</a>').replace(/\n\n/gim, "</p><p>").replace(/^(.+)$/gim, "<p>$1</p>");
 }
+function injectEntityAnnotations(html, entities) {
+  if (!entities.length) return html;
+  let annotatedHtml = html;
+  const sortedEntities = [...entities].sort((a, b) => b.name.length - a.name.length);
+  for (const entity of sortedEntities) {
+    if (entity.name.length < 3) continue;
+    const regex = new RegExp(
+      `(?<![\\w-])(?<!data-sonor-entity=")${escapeRegExp(entity.name)}(?![\\w-])`,
+      "gi"
+    );
+    const schemaType = getSchemaTypeForEntity(entity.entity_type);
+    annotatedHtml = annotatedHtml.replace(regex, (match) => {
+      return `<span class="aeo-entity aeo-entity-${entity.entity_type}" data-sonor-entity="${entity.id}" data-sonor-entity-type="${entity.entity_type}" data-sonor-entity-name="${entity.name}" itemscope itemtype="https://schema.org/${schemaType}"><span itemprop="name">${match}</span></span>`;
+    });
+  }
+  return annotatedHtml;
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getSchemaTypeForEntity(entityType) {
+  const typeMap = {
+    organization: "Organization",
+    person: "Person",
+    service: "Service",
+    product: "Product",
+    location: "Place",
+    concept: "Thing",
+    credential: "EducationalOccupationalCredential"
+  };
+  return typeMap[entityType] || "Thing";
+}
 async function ManagedContent({
   projectId,
   path,
   section,
   fallback,
   className,
-  components = {}
+  components = {},
+  injectEntityAnnotations: shouldInjectEntities = false
 }) {
-  const block = await chunkQP5NCO2E_js.getContentBlock(projectId, path, section);
+  const block = await chunkVDI7KYME_js.getContentBlock(projectId, path, section);
   if (!block) {
     if (fallback) {
       return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
     }
     return null;
   }
+  let entities = [];
+  if (shouldInjectEntities) {
+    try {
+      entities = await chunkVDI7KYME_js.getEntities(projectId);
+    } catch (err) {
+      console.warn("@uptrade/seo: Failed to fetch entities for annotation:", err);
+    }
+  }
   const containerClass = className || `uptrade-content uptrade-content--${section}`;
+  const processHtml = (html) => {
+    if (shouldInjectEntities && entities.length > 0) {
+      return injectEntityAnnotations(html, entities);
+    }
+    return html;
+  };
   switch (block.content_type) {
     case "html":
       return /* @__PURE__ */ jsxRuntime.jsx(
         "div",
         {
           className: containerClass,
-          dangerouslySetInnerHTML: { __html: block.content }
+          dangerouslySetInnerHTML: { __html: processHtml(block.content) }
         }
       );
     case "markdown":
-      const htmlContent = renderMarkdown(block.content);
+      const htmlContent = processHtml(renderMarkdown(block.content));
       return /* @__PURE__ */ jsxRuntime.jsx(
         "div",
         {
@@ -366,14 +649,14 @@ async function ManagedContent({
   }
 }
 async function getManagedContentData(projectId, path, section) {
-  return chunkQP5NCO2E_js.getContentBlock(projectId, path, section);
+  return chunkVDI7KYME_js.getContentBlock(projectId, path, section);
 }
 async function ManagedScripts({
   projectId,
   position,
   path
 }) {
-  const scripts = await chunkQP5NCO2E_js.getManagedScripts(projectId, position, path);
+  const scripts = await chunkVDI7KYME_js.getManagedScripts(projectId, position, path);
   if (!scripts.length) {
     return null;
   }
@@ -402,13 +685,120 @@ async function ManagedNoScripts({
   projectId,
   path
 }) {
-  const scripts = await chunkQP5NCO2E_js.getManagedScripts(projectId, "body-start", path);
+  const scripts = await chunkVDI7KYME_js.getManagedScripts(projectId, "body-start", path);
   const noscriptContent = scripts.filter((s) => s.attributes?.noscript).map((s) => s.attributes?.noscript).join("");
   if (!noscriptContent) {
     return null;
   }
   return /* @__PURE__ */ jsxRuntime.jsx("noscript", { dangerouslySetInnerHTML: { __html: noscriptContent } });
 }
+function getApiConfig() {
+  const apiUrl = process.env.UPTRADE_API_URL || process.env.NEXT_PUBLIC_UPTRADE_API_URL || "https://api.uptrademedia.com";
+  return { apiUrl };
+}
+var getLocationSection = react.cache(async (projectId, path, section) => {
+  const { apiUrl } = getApiConfig();
+  try {
+    const response = await fetch(`${apiUrl}/api/public/seo/location-content`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        project_id: projectId,
+        path,
+        section
+      }),
+      next: { revalidate: 3600 }
+      // Cache for 1 hour
+    });
+    if (!response.ok) {
+      console.error(`LocationPageContent: Failed to fetch section "${section}" for path "${path}"`);
+      return null;
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error("LocationPageContent: API error:", error);
+    return null;
+  }
+});
+function HeroRenderer({ data, className }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("section", { className: className || "location-hero", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("h1", { children: data.title }),
+    data.subtitle && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "subtitle", children: data.subtitle }),
+    data.stats && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "stats-grid", children: data.stats.map((stat, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "stat", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-value", children: stat.value }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "stat-label", children: stat.label })
+    ] }, i)) }),
+    data.cta_text && data.cta_href && /* @__PURE__ */ jsxRuntime.jsx("a", { href: data.cta_href, className: "cta-button", children: data.cta_text })
+  ] });
+}
+function TextRenderer({ data, className }) {
+  if (data.html) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "section",
+      {
+        className: className || "location-text",
+        dangerouslySetInnerHTML: { __html: data.html }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs("section", { className: className || "location-text", children: [
+    data.heading && /* @__PURE__ */ jsxRuntime.jsx("h2", { children: data.heading }),
+    data.paragraphs.map((p, i) => /* @__PURE__ */ jsxRuntime.jsx("p", { children: p }, i))
+  ] });
+}
+function ServicesGridRenderer({ data, className }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("section", { className: className || "location-services-grid", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "services-list", children: data.services.map((service, i) => /* @__PURE__ */ jsxRuntime.jsxs("a", { href: service.href, className: "service-card", children: [
+    service.icon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "service-icon", children: service.icon }),
+    /* @__PURE__ */ jsxRuntime.jsx("h3", { children: service.title }),
+    /* @__PURE__ */ jsxRuntime.jsx("p", { children: service.description })
+  ] }, i)) }) });
+}
+function DefaultRenderer({ data, className }) {
+  if (process.env.NODE_ENV === "development") {
+    return /* @__PURE__ */ jsxRuntime.jsx("section", { className, children: /* @__PURE__ */ jsxRuntime.jsx("pre", { style: { fontSize: "12px", background: "#f0f0f0", padding: "1rem" }, children: JSON.stringify(data, null, 2) }) });
+  }
+  if (typeof data.content === "string") {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "section",
+      {
+        className,
+        dangerouslySetInnerHTML: { __html: data.content }
+      }
+    );
+  }
+  return null;
+}
+async function LocationPageContent({
+  projectId,
+  path,
+  section,
+  fallback = null,
+  className,
+  render
+}) {
+  const data = await getLocationSection(projectId, path, section);
+  if (!data) {
+    return fallback;
+  }
+  if (render) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: render(data) });
+  }
+  switch (data.type) {
+    case "hero":
+      return /* @__PURE__ */ jsxRuntime.jsx(HeroRenderer, { data: data.content, className });
+    case "text":
+    case "intro":
+    case "about":
+    case "about_location":
+      return /* @__PURE__ */ jsxRuntime.jsx(TextRenderer, { data: data.content, className });
+    case "services_grid":
+    case "services":
+      return /* @__PURE__ */ jsxRuntime.jsx(ServicesGridRenderer, { data: data.content, className });
+    default:
+      return /* @__PURE__ */ jsxRuntime.jsx(DefaultRenderer, { data, className });
+  }
+}
 
 Object.defineProperty(exports, "SitemapSync", {
   enumerable: true,
@@ -416,20 +806,21 @@ Object.defineProperty(exports, "SitemapSync", {
 });
 Object.defineProperty(exports, "generateSitemap", {
   enumerable: true,
-  get: function () { return chunkSBVEYCSV_js.generateSitemap; }
+  get: function () { return chunkQQB4FO4Q_js.generateSitemap; }
 });
 Object.defineProperty(exports, "getRedirect", {
   enumerable: true,
-  get: function () { return chunkSBVEYCSV_js.getRedirect; }
+  get: function () { return chunkQQB4FO4Q_js.getRedirect; }
 });
 Object.defineProperty(exports, "getRobotsDirective", {
   enumerable: true,
-  get: function () { return chunkSBVEYCSV_js.getRobotsDirective; }
+  get: function () { return chunkQQB4FO4Q_js.getRobotsDirective; }
 });
 Object.defineProperty(exports, "isIndexable", {
   enumerable: true,
-  get: function () { return chunkSBVEYCSV_js.isIndexable; }
+  get: function () { return chunkQQB4FO4Q_js.isIndexable; }
 });
+exports.LocationPageContent = LocationPageContent;
 exports.ManagedContent = ManagedContent;
 exports.ManagedFAQ = ManagedFAQ;
 exports.ManagedInternalLinks = ManagedInternalLinks;
@@ -439,9 +830,27 @@ exports.ManagedScripts = ManagedScripts;
 exports.createBreadcrumbSchema = createBreadcrumbSchema;
 exports.createSchema = createSchema;
 exports.default = ManagedSchema;
+exports.getABTest = getABTest;
 exports.getABVariant = getABVariant;
+exports.getContentBlock = getContentBlock2;
+exports.getEntities = getEntities2;
+exports.getEntityEnhancedSchema = getEntityEnhancedSchema2;
+exports.getFAQData = getFAQData2;
+exports.getInternalLinks = getInternalLinks2;
+exports.getLocationSection = getLocationSection;
 exports.getManagedContentData = getManagedContentData;
 exports.getManagedMetadata = getManagedMetadata;
 exports.getManagedMetadataWithAB = getManagedMetadataWithAB;
+exports.getManagedScripts = getManagedScripts2;
+exports.getPrimaryEntity = getPrimaryEntity;
+exports.getRedirectData = getRedirectData;
+exports.getRobotsData = getRobotsData;
+exports.getSEOPageData = getSEOPageData;
+exports.getSchemaMarkups = getSchemaMarkups2;
+exports.getSitemapEntries = getSitemapEntries;
+exports.getVisibilityScore = getVisibilityScore;
+exports.getVisibilitySummary = getVisibilitySummary;
+exports.recordABImpression = recordABImpression;
+exports.registerSitemap = registerSitemap;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map