@websolutespa/bom-mixer-models 2.0.1-next.2 → 2.0.2

package/dist/index.js

@@ -1,55 +1,1464 @@
-import { getPublicUrl, resolveHref } from "./page-BLbZbnWg.js";
-import { categoryToRouteLink, newRouteLink, resolveRoute, routeToRouteLink } from "./route-k0W3AKyo.js";
-import { isBrowser } from "@websolutespa/bom-core";
+"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 src_exports = {};
+__export(src_exports, {
+  LAZY_PROPS: () => LAZY_PROPS,
+  NotFound: () => NotFound,
+  detectCountry: () => detectCountry,
+  detectLocale: () => detectLocale,
+  escapeHtml: () => escapeHtml,
+  findManyPages: () => findManyPages,
+  findOnePage: () => findOnePage,
+  getAddressOptions: () => getAddressOptions,
+  getBreadcrumbFromSegments: () => getBreadcrumbFromSegments,
+  getCaptionsVttProps: () => getCaptionsVttProps,
+  getCategories: () => getCategories,
+  getCategory: () => getCategory,
+  getConsentPreference: () => getConsentPreference,
+  getConsentPreferences: () => getConsentPreferences,
+  getConsentPreferencesPagination: () => getConsentPreferencesPagination,
+  getCountries: () => getCountries,
+  getCountriesPagination: () => getCountriesPagination,
+  getCountry: () => getCountry,
+  getDecoratedComponents: () => getDecoratedComponents,
+  getErrorPageLayout: () => getErrorPageLayout,
+  getLabel: () => getLabel,
+  getLabels: () => getLabels,
+  getLayout: () => getLayout,
+  getLink: () => getLink,
+  getLocale: () => getLocale,
+  getLocaleFromProps: () => getLocaleFromProps,
+  getLocales: () => getLocales,
+  getMarket: () => getMarket,
+  getMarkets: () => getMarkets,
+  getMenu: () => getMenu,
+  getMenus: () => getMenus,
+  getPage: () => getPage,
+  getPageCategory: () => getPageCategory,
+  getPageProps: () => getPageProps,
+  getPageRoutes: () => getPageRoutes,
+  getProvince: () => getProvince,
+  getProvinces: () => getProvinces,
+  getProvincesPagination: () => getProvincesPagination,
+  getPublicUrl: () => getPublicUrl,
+  getRedirect: () => getRedirect,
+  getRedirects: () => getRedirects,
+  getRedirectsPagination: () => getRedirectsPagination,
+  getRegion: () => getRegion,
+  getRegions: () => getRegions,
+  getRegionsPagination: () => getRegionsPagination,
+  getRoute: () => getRoute,
+  getRouteLinkCategory: () => getRouteLinkCategory,
+  getRouteLinkTree: () => getRouteLinkTree,
+  getRoutes: () => getRoutes,
+  getRoutesForSchemas: () => getRoutesForSchemas,
+  getRoutesForTemplates: () => getRoutesForTemplates,
+  getSegments: () => getSegments,
+  getSeoWeight: () => getSeoWeight,
+  getSession: () => getSession,
+  getSessionToken: () => getSessionToken,
+  getSiteMapIndex: () => getSiteMapIndex,
+  getSiteMapIndexProps: () => getSiteMapIndexProps,
+  getSiteMapXML: () => getSiteMapXML,
+  getSiteMapXMLProps: () => getSiteMapXMLProps,
+  getSiteMapXSL: () => getSiteMapXSL,
+  getSiteMapXSLProps: () => getSiteMapXSLProps,
+  getStaticPathsForSchema: () => getStaticPathsForSchema,
+  getStaticPathsForSchemaAndFallback: () => getStaticPathsForSchemaAndFallback,
+  getUtmz: () => getUtmz,
+  newRouteLink: () => newRouteLink,
+  pushDataLayer: () => pushDataLayer,
+  redirectTo: () => redirectTo,
+  resolveHref: () => resolveHref,
+  resolveLabel: () => resolveLabel,
+  resolveRoute: () => resolveRoute,
+  routeAutoDetection: () => routeAutoDetection,
+  routeInterceptor: () => routeInterceptor,
+  routeRevalidateHandler: () => routeRevalidateHandler,
+  routeToRouteLink: () => routeToRouteLink,
+  withLazyProps: () => withLazyProps
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/country/country.service.ts
+var import_bom_mixer_store = require("@websolutespa/bom-mixer-store");
+async function getCountries(locale) {
+  const store = await (0, import_bom_mixer_store.getStore)();
+  const items = await store.i18n_country.findMany({ locale });
+  return items;
+}
+async function getCountry(id, params = {}) {
+  const store = await (0, import_bom_mixer_store.getStore)();
+  const item = await store.i18n_country.findOne(id, params);
+  return item;
+}
+async function getCountriesPagination(params = {}) {
+  const store = await (0, import_bom_mixer_store.getStore)();
+  const pagination = await store.i18n_country.findPaged(params);
+  return pagination;
+}
+
+// src/province/province.service.ts
+var import_bom_mixer_store2 = require("@websolutespa/bom-mixer-store");
+async function getProvinces(locale) {
+  const store = await (0, import_bom_mixer_store2.getStore)();
+  const items = await store.i18n_province.findMany({ locale });
+  return items;
+}
+async function getProvince(id, params = {}) {
+  const store = await (0, import_bom_mixer_store2.getStore)();
+  const item = await store.i18n_province.findOne(id, params);
+  return item;
+}
+async function getProvincesPagination(params = {}) {
+  const store = await (0, import_bom_mixer_store2.getStore)();
+  const pagination = await store.i18n_province.findPaged(params);
+  return pagination;
+}
+
+// src/region/region.service.ts
+var import_bom_mixer_store3 = require("@websolutespa/bom-mixer-store");
+async function getRegions(locale) {
+  const store = await (0, import_bom_mixer_store3.getStore)();
+  const items = await store.i18n_region.findMany({ locale });
+  return items;
+}
+async function getRegion(id, params = {}) {
+  const store = await (0, import_bom_mixer_store3.getStore)();
+  const item = await store.i18n_region.findOne(id, params);
+  return item;
+}
+async function getRegionsPagination(params = {}) {
+  const store = await (0, import_bom_mixer_store3.getStore)();
+  const pagination = await store.i18n_region.findPaged(params);
+  return pagination;
+}
+
+// src/address/address.service.ts
+async function getAddressOptions(locale) {
+  const countries = await getCountries(locale);
+  const provinces = await getProvinces(locale);
+  const regions = await getRegions(locale);
+  return {
+    countries,
+    regions,
+    provinces
+  };
+}
+
+// src/captions/captions.handler.ts
+var getCaptionsVttProps = async (context) => {
+  const { req, res, params, query } = context;
+  const locale = query?.locale;
+  const title = query?.title;
+  const captions = (
+    /* html */
+    `WEBVTT
+
+00:00:01.000 --> 00:00:03.000
+- This video has no audio.
+
+${title ? `
+00:00:04.000 --> 00:00:06.000
+- The title of the video is "${title}".
+` : ""}`
+  );
+  res.setHeader("Content-Type", "text/plain; charset=UTF-8");
+  res.setHeader("X-Frame-Options", "SAMEORIGIN");
+  res.setHeader("X-Robots-Tag", "noindex, follow");
+  res.write(captions);
+  res.end();
+  return {
+    props: {}
+  };
+};
+
+// src/category/category.service.ts
+var import_bom_core = require("@websolutespa/bom-core");
+var import_bom_mixer_store4 = require("@websolutespa/bom-mixer-store");
+async function getCategories(params = {}) {
+  const store = await (0, import_bom_mixer_store4.getStore)();
+  const categories = await store.category.findMany(params);
+  return categories;
+}
+async function getCategory(id, params = {}) {
+  const store = await (0, import_bom_mixer_store4.getStore)();
+  const item = await store.category.findOne(id, params);
+  return item;
+}
+async function getSegments(item, params = {}) {
+  const categories = await getCategories(params);
+  return (0, import_bom_core.getCategorySegments)(categories, item);
+}
+
+// src/consent_preference/consent_preference.service.ts
+var import_bom_mixer_store5 = require("@websolutespa/bom-mixer-store");
+async function getConsentPreference(id, params = {}) {
+  const store = await (0, import_bom_mixer_store5.getStore)();
+  const item = await store.consent_preference.findOne(id, params);
+  return item;
+}
+async function getConsentPreferences(params = {}) {
+  const store = await (0, import_bom_mixer_store5.getStore)();
+  const items = await store.consent_preference.findMany(params);
+  return items;
+}
+async function getConsentPreferencesPagination(params = {}) {
+  const store = await (0, import_bom_mixer_store5.getStore)();
+  const pagination = await store.consent_preference.findPaged(params);
+  return pagination;
+}
 
-//#region src/gtm/gtm.service.ts
+// src/gtm/gtm.service.ts
+var import_bom_core2 = require("@websolutespa/bom-core");
 function pushDataLayer(record) {
-	if (isBrowser) window.dataLayer?.push(record);
+  if (import_bom_core2.isBrowser) {
+    window.dataLayer?.push(record);
+  }
+}
+
+// src/label/label.service.ts
+var import_bom_mixer_store6 = require("@websolutespa/bom-mixer-store");
+async function getLabels(params = {}) {
+  const store = await (0, import_bom_mixer_store6.getStore)();
+  const items = await store.label.findMany(params);
+  return items;
+}
+async function getLabel(id, params = {}) {
+  const store = await (0, import_bom_mixer_store6.getStore)();
+  const item = await store.label.findOne(id, params);
+  return item;
+}
+function resolveLabel(labels, id) {
+  const label = labels.find((x) => x.id === id);
+  return label && label.text ? label.text.toString() : id;
+}
+
+// src/app/app.service.ts
+var import_bom_mixer_store7 = require("@websolutespa/bom-mixer-store");
+async function getApp(params = {}) {
+  const store = await (0, import_bom_mixer_store7.getStore)();
+  const item = await store.app.findGlobal(params);
+  return item;
+}
+
+// src/locale/locale.service.ts
+var import_bom_mixer_store8 = require("@websolutespa/bom-mixer-store");
+async function getLocales(params = {}) {
+  const store = await (0, import_bom_mixer_store8.getStore)();
+  const items = await store.locale.findMany(params);
+  return items;
+}
+async function getLocale(id, params = {}) {
+  const store = await (0, import_bom_mixer_store8.getStore)();
+  const item = await store.locale.findOne(id, params);
+  return item;
+}
+function getLocaleFromProps(props) {
+  return props?.__NEXT_DATA__?.query?.locale;
+}
+
+// src/market/market.service.ts
+var import_bom_mixer_store9 = require("@websolutespa/bom-mixer-store");
+async function getMarkets(params = {}) {
+  const store = await (0, import_bom_mixer_store9.getStore)();
+  const items = await store.market.findMany(params);
+  return items;
+}
+async function getMarket(id, params = {}) {
+  const store = await (0, import_bom_mixer_store9.getStore)();
+  const item = await store.market.findOne(id, params);
+  return item;
+}
+
+// src/menu/menu.service.ts
+var import_bom_mixer_store10 = require("@websolutespa/bom-mixer-store");
+async function getMenus(params = {}) {
+  const store = await (0, import_bom_mixer_store10.getStore)();
+  const items = await store.menu.findMany(params);
+  return items;
+}
+async function getMenu(id, params = {}) {
+  const store = await (0, import_bom_mixer_store10.getStore)();
+  const item = await store.menu.findOne(id, params);
+  return item;
+}
+
+// src/route/route.service.ts
+var import_bom_core3 = require("@websolutespa/bom-core");
+var import_bom_mixer_store11 = require("@websolutespa/bom-mixer-store");
+async function getRoutes(params = {}) {
+  const store = await (0, import_bom_mixer_store11.getStore)();
+  const routes = await store.route.findMany(params);
+  return routes;
+}
+async function getRoute(id) {
+  const store = await (0, import_bom_mixer_store11.getStore)();
+  const route = await store.route.findOne(id);
+  return route;
+}
+async function getRoutesForSchemas(schemas, market, locale) {
+  const store = await (0, import_bom_mixer_store11.getStore)();
+  const routes = await store.route.findMany({
+    where: {
+      schema: {
+        in: schemas
+      },
+      market: {
+        equals: market
+      },
+      locale: {
+        equals: locale
+      }
+    }
+  });
+  const items = {};
+  routes.forEach((route) => {
+    items[route.schema] = route.id;
+  });
+  return items;
+}
+async function getRoutesForTemplates(templates, market, locale) {
+  const store = await (0, import_bom_mixer_store11.getStore)();
+  const routes = await store.route.findMany({
+    where: {
+      template: {
+        in: templates
+      },
+      market: {
+        equals: market
+      },
+      locale: {
+        equals: locale
+      }
+    }
+  });
+  const items = {};
+  routes.forEach((route) => {
+    if (route.template) {
+      items[route.template] = route.id;
+    }
+  });
+  return items;
+}
+async function getStaticPathsForSchema(schema, template) {
+  if (import_bom_mixer_store11.buildStrategy === import_bom_mixer_store11.BuildStrategy.Runtime) {
+    return [];
+  }
+  const store = await (0, import_bom_mixer_store11.getStore)();
+  const routes = await store.route.findMany({
+    where: template ? {
+      and: [{
+        template: {
+          equals: template
+        }
+      }, {
+        schema: {
+          equals: schema
+        }
+      }]
+    } : {
+      schema: {
+        equals: schema
+      }
+    }
+  });
+  return routes.map((x) => ({ params: { id: x.page.toString(), market: x.market, locale: x.locale } }));
+}
+async function getStaticPathsForSchemaAndFallback(schema, fallback = "blocking", template) {
+  if (import_bom_mixer_store11.buildStrategy === import_bom_mixer_store11.BuildStrategy.Runtime || fallback === "blocking" && import_bom_mixer_store11.storeStrategy !== import_bom_mixer_store11.StoreStrategy.Mock) {
+    return { paths: [], fallback };
+  }
+  const paths = await getStaticPathsForSchema(schema, template);
+  return {
+    paths,
+    fallback
+    // fallback: 'blocking', // runs before initial render
+    // fallback: true, // runs in the background
+  };
+}
+async function getBreadcrumbFromSegments(segments, route) {
+  const market = route.market || import_bom_core3.defaultMarket;
+  const locale = route.locale || import_bom_core3.defaultLocale;
+  const routes = await getRoutes({
+    where: {
+      market: {
+        equals: market
+      },
+      locale: {
+        equals: locale
+      }
+    }
+  });
+  const tree = segments.map((segment) => {
+    const route2 = (0, import_bom_core3.findRouteOfCategory)(routes, segment.id);
+    return {
+      segment,
+      route: route2
+    };
+  }).filter((x) => Boolean(x.route)).map((x) => {
+    const category = x.segment;
+    const route2 = x.route;
+    const routeLink = newRouteLink(category, route2, locale);
+    return routeLink;
+  });
+  if (!route.isDefault) {
+    tree.push(routeToRouteLink(route));
+  }
+  return tree;
+}
+async function getRouteLinkTree(market, locale) {
+  const store = await (0, import_bom_mixer_store11.getStore)();
+  const routes = await store.route.findMany({
+    where: {
+      market: {
+        equals: market
+      },
+      locale: {
+        equals: locale
+      }
+    }
+  });
+  const categories = await store.category.findMany({ market, locale });
+  const rootCategory = (0, import_bom_core3.getRootCategory)(categories);
+  if (rootCategory) {
+    const root = getRouteLinkCategory(locale, routes, categories, rootCategory, rootCategory);
+    return root;
+  }
+  return void 0;
+}
+function getRouteLinkCategory(locale, routes, categories, rootCategory, category) {
+  const route = (0, import_bom_core3.findRouteOfCategory)(routes, category.id);
+  const otherCategories = categories.filter((x) => x.id !== category.id);
+  const childCategories = otherCategories.filter((x) => (0, import_bom_core3.asCategoryId)(x.category) === category.id);
+  const routeLink = newRouteLink(category, route, locale);
+  const items = [];
+  for (const childCategory of childCategories) {
+    const itemOrItems = getRouteLinkCategory(locale, routes, otherCategories, rootCategory, childCategory);
+    if (Array.isArray(itemOrItems)) {
+      items.push(...itemOrItems);
+    } else if (itemOrItems) {
+      items.push(itemOrItems);
+    }
+  }
+  if (!route || category.isHidden && category.id !== rootCategory.id) {
+    return items;
+  }
+  routeLink.items = items;
+  return routeLink;
+}
+function newRouteLink(category, route, locale) {
+  const href = route && route.id ? route.id.toString() : "/";
+  const id = route?.page || category.id;
+  const media = category.media || route?.media;
+  const schema = route?.template || route?.schema || category?.schema || "unknown";
+  const title = (0, import_bom_core3.localize)(category.title || route?.title || "untitled", locale);
+  const routeLink = {
+    category: category.id,
+    href,
+    id,
+    items: [],
+    media,
+    schema,
+    title
+  };
+  return routeLink;
+}
+function routeToRouteLink(route) {
+  const routeLink = {
+    category: (0, import_bom_core3.asCategoryId)(route.category),
+    href: route.id,
+    id: route.page,
+    items: [],
+    media: route.media,
+    schema: route.schema,
+    title: route.title
+  };
+  return routeLink;
+}
+function resolveRoute(route) {
+  const routepath = route.template || route.schema;
+  const resolvedPathname = `/${route.market}/${route.locale}/${routepath}/${route.page}${route.splat || ""}`;
+  return resolvedPathname;
+}
+
+// src/layout/layout.service.ts
+async function getLayout(market, locale) {
+  const markets = await getMarkets({ locale });
+  const locales = await getLocales({ locale });
+  const labels = await getLabels({ locale });
+  const app = await getApp({ locale }) || {};
+  const tree = await getRouteLinkTree(market, locale);
+  const firstLevelRoutes = tree?.items || [];
+  const flatTopLevelRoutes = tree ? [tree, ...firstLevelRoutes] : [];
+  const topLevelRoutes = flatTopLevelRoutes.reduce((object, routeLink) => {
+    if (!object[routeLink.schema] || routeLink.schema === routeLink.category) {
+      object[routeLink.schema] = routeLink;
+    }
+    return object;
+  }, {});
+  const topLevelHrefs = flatTopLevelRoutes.reduce((object, routeLink) => {
+    if (routeLink.href && (!object[routeLink.schema] || routeLink.schema === routeLink.category)) {
+      object[routeLink.schema] = routeLink.href;
+    }
+    return object;
+  }, {});
+  const menu = {};
+  const menus = await getMenus({ market, locale });
+  menus.forEach((x) => {
+    menu[x.id] = x;
+  });
+  return {
+    labels,
+    locale,
+    locales,
+    market,
+    markets,
+    app,
+    menu,
+    topLevelHrefs,
+    topLevelRoutes,
+    tree
+  };
 }
 
-//#endregion
-//#region src/link/link.service.ts
+// src/lazy/lazy.ts
+var LAZY_PROPS = {};
+function withLazyProps(key, getComponentProps) {
+  LAZY_PROPS[key] = getComponentProps;
+}
+async function getDecoratedComponents(props, extraComponents) {
+  const page = props.page;
+  const components = [
+    ...page.components || [],
+    ...extraComponents || []
+  ];
+  const decoratedComponents = [];
+  for (const component of components) {
+    const key = component.blockType || component.schema || "unkown_type";
+    const getComponentProps = LAZY_PROPS[key];
+    if (typeof getComponentProps === "function") {
+      const decoratedComponent = await getComponentProps({ ...props, component });
+      decoratedComponents.push(decoratedComponent);
+    } else {
+      decoratedComponents.push(component);
+    }
+  }
+  page.components = decoratedComponents;
+}
+
+// src/link/link.service.ts
 function getLink_(category, routeLink) {
-	if (routeLink) {
-		if (routeLink.category === category) return routeLink.href;
-		if (routeLink.items) return routeLink.items.reduce((p, c) => {
-			return getLink_(category, c) || p;
-		}, void 0);
-	}
-	return void 0;
+  if (routeLink) {
+    if (routeLink.category === category) {
+      return routeLink.href;
+    }
+    if (routeLink.items) {
+      return routeLink.items.reduce((p, c) => {
+        return getLink_(category, c) || p;
+      }, void 0);
+    }
+  }
+  return void 0;
 }
 function getLink(category, layout) {
-	return getLink_(category, layout.tree);
+  return getLink_(category, layout.tree);
 }
 
-//#endregion
-//#region src/locale/locale.ts
-function getLocaleFromProps(props) {
-	return props?.__NEXT_DATA__?.query?.locale;
+// src/page/page.service.ts
+var import_bom_core4 = require("@websolutespa/bom-core");
+var import_bom_mixer_store12 = require("@websolutespa/bom-mixer-store");
+async function findOnePage(schema, id, params) {
+  const store = await (0, import_bom_mixer_store12.getStore)();
+  const collection = store[schema];
+  if (!collection) {
+    throw `PageService.findOnePage: Collection not found [${schema}]`;
+  }
+  const page = await collection.findOne(id, params);
+  if (page) {
+    return page;
+  } else {
+    console.log("PageService.findOnePage.notfound", schema, params);
+    return;
+  }
+}
+async function findManyPages(schema, params) {
+  const store = await (0, import_bom_mixer_store12.getStore)();
+  const collection = store[schema];
+  if (!collection) {
+    throw `PageService.findManyPages: Collection not found [${schema}]`;
+  }
+  const pages = await collection.findMany(params);
+  return pages;
+}
+async function getPage(schema, id, market, locale, options) {
+  const { depth = 3, draftMode = false, previewData } = options || {};
+  const draft = draftMode === true;
+  const page = await findOnePage(schema, id, { market, locale, depth, draft });
+  if (page) {
+    const routes = await getPageRoutes(schema, id);
+    const currentRoute = routes.find((x) => x.market === market && x.locale === locale);
+    const alternates = routes;
+    const segments = await getSegments(page, { market, locale });
+    const breadcrumb = currentRoute ? await getBreadcrumbFromSegments(segments, currentRoute) : [];
+    const parentRoute = breadcrumb.length > 1 ? breadcrumb[breadcrumb.length - 2] : void 0;
+    const pageResult = {
+      ...page,
+      href: currentRoute?.id,
+      // !!! route?
+      alternates,
+      breadcrumb,
+      parentRoute
+    };
+    return pageResult;
+  } else {
+    console.log("PageService.getPage.notfound", schema, id, locale);
+    return;
+  }
+}
+async function NotFound(market, locale) {
+  const routes = await getRoutes({
+    where: {
+      market: {
+        equals: market
+      },
+      locale: {
+        equals: locale
+      },
+      schema: {
+        equals: "notfound"
+      }
+    }
+  });
+  if (routes.length > 0) {
+    return {
+      redirect: {
+        destination: routes[0].id,
+        permanent: false
+      }
+    };
+  }
+  return;
+}
+async function getPageRoutes(schema, id) {
+  const store = await (0, import_bom_mixer_store12.getStore)();
+  let routes = [];
+  try {
+    routes = await store.route.findMany({
+      where: {
+        page: {
+          equals: id
+        },
+        schema: {
+          equals: schema
+        }
+      }
+    });
+  } catch (error) {
+    console.error("No routes found for page " + schema + ":" + id);
+  }
+  return routes;
+}
+async function getPageCategory(schema, page, market, locale) {
+  if (!page) {
+    return;
+  }
+  const store = await (0, import_bom_mixer_store12.getStore)();
+  const pages = await findManyPages(schema, {
+    where: {
+      category: {
+        equals: (0, import_bom_core4.asCategoryId)(page.category)
+      }
+    },
+    market,
+    locale
+  });
+  const category = pages.length ? pages[0] : null;
+  if (category) {
+    const routes = await store.route.findMany({
+      where: {
+        schema: {
+          equals: schema
+        },
+        page: {
+          equals: category.id
+        }
+      }
+    });
+    const currentRoute = routes.find((x) => x.market === market && x.locale === locale);
+    if (!currentRoute) {
+      throw "No route found for page " + schema + ":" + category.id + " in market " + market + " and locale " + locale;
+    }
+    return {
+      ...category,
+      href: currentRoute.id
+    };
+  } else {
+    console.log("PageService.getPageCategory.notfound", schema, locale);
+    return;
+  }
+}
+async function getErrorPageLayout() {
+  const layout = await getLayout(import_bom_core4.defaultMarket, import_bom_core4.defaultLocale);
+  const title = resolveLabel(layout.labels, "notfound.title");
+  const abstract = resolveLabel(layout.labels, "notfound.abstract");
+  const category = layout.tree ? {
+    id: layout.tree.category,
+    title: layout.tree.title,
+    href: layout.tree.href,
+    slug: ""
+  } : {
+    id: "homepage",
+    title: "Homepage",
+    slug: "",
+    href: "/"
+  };
+  const page = {
+    abstract,
+    alternates: [],
+    breadcrumb: [],
+    category,
+    slug: "",
+    href: "",
+    id: "notfound",
+    locale: layout.locale,
+    market: layout.market,
+    markets: [],
+    meta: {
+      title,
+      description: abstract,
+      keywords: "",
+      robots: "all"
+    },
+    schema: "notfound",
+    title
+  };
+  return { layout, page };
+}
+async function getPageProps(props, extraComponents) {
+  if (props.page) {
+    await getDecoratedComponents(props, extraComponents);
+  }
+  return (0, import_bom_core4.asServerProps)(props);
+}
+function getPublicUrl() {
+  const publicUrl = process.env && process.env.NEXT_PUBLIC_URL ? process.env.NEXT_PUBLIC_URL : "";
+  return publicUrl;
+}
+function resolveHref(href) {
+  href = href || "";
+  return href.startsWith("http") ? href : `${getPublicUrl()}${href}`;
+}
+
+// src/redirect/redirect.service.ts
+var import_bom_mixer_store13 = require("@websolutespa/bom-mixer-store");
+async function getRedirects(locale) {
+  const store = await (0, import_bom_mixer_store13.getStore)();
+  const items = await store.redirect.findMany({ locale });
+  return items;
+}
+async function getRedirect(id, params = {}) {
+  const store = await (0, import_bom_mixer_store13.getStore)();
+  const item = await store.redirect.findOne(id, params);
+  return item;
+}
+async function getRedirectsPagination(params = {}) {
+  const store = await (0, import_bom_mixer_store13.getStore)();
+  const pagination = await store.redirect.findPaged(params);
+  return pagination;
+}
+function redirectTo(layout, key = "not_found") {
+  return {
+    redirect: {
+      permanent: false,
+      destination: layout.topLevelHrefs[key] || "/"
+    }
+  };
+}
+
+// src/route/route-revalidate.handler.ts
+var import_bom_mixer_store14 = require("@websolutespa/bom-mixer-store");
+function routeRevalidateHandler() {
+  return (0, import_bom_mixer_store14.apiHandler)({
+    post: async (request, response) => {
+      const authorization = request.headers.authorization;
+      const bearer = authorization && authorization.replace("Bearer ", "");
+      if (bearer !== process.env.HOOKS_SECRET) {
+        return response.status(401).json({ message: "Invalid token" });
+      }
+      try {
+        const { href } = request.body;
+        const routes = await getRoutes({
+          where: {
+            id: { equals: href }
+          }
+        });
+        if (routes.length === 0) {
+          return response.status(404).send(`routeRevalidateHandler.notFound ${href}`);
+        }
+        for (const route of routes) {
+          const resolvedRoute = resolveRoute(route);
+          console.log("route.revalidating", resolvedRoute);
+          await response.revalidate(resolvedRoute);
+        }
+        return response.json({ revalidated: true });
+      } catch (error) {
+        return response.status(500).send("Error revalidating");
+      }
+    }
+  });
 }
 
-//#endregion
-//#region src/seo/seo.service.ts
-const getSeoWeight = (index = 0, seoWeight) => {
-	const getter = (subIndex = 0) => {
-		const i = seoWeight ? parseInt(seoWeight.replace(/\D/g, "")) : index === 0 ? 1 : 2;
-		return `h${Math.min(i + subIndex, 6)}`;
-	};
-	return getter;
+// src/route/route.interceptor.ts
+var import_bom_core5 = require("@websolutespa/bom-core");
+var import_bom_mixer_store15 = require("@websolutespa/bom-mixer-store");
+var import_server = require("next/server");
+async function detectLocale(request, defaultLocale4) {
+  const acceptLanguage = request.headers.get("accept-language")?.split(",")[0];
+  const detectedLocale = request.cookies.get("NEXT_LOCALE")?.value || acceptLanguage || defaultLocale4 || process.env.DEFAULT_LOCALE;
+  return detectedLocale;
+}
+async function detectCountry(request, defaultMarket4) {
+  const ip = request.ip || request.headers.get("X-Forwarded-For") || request.headers.get("x-real-ip");
+  const isValidIp = ip?.match(/^(\d+?)\.(\d+?)\.(\d+?)\.(\d+?)$/);
+  let detectedCountry = "";
+  try {
+    const token = process.env.IPINFO_TOKEN;
+    if (token) {
+      const url = isValidIp ? `https://api.ipinfo.io/lite/${ip}/country_code?token=${token}` : `https://api.ipinfo.io/lite/me/country_code?token=${token}`;
+      const response = await fetch(url);
+      if (response.ok) {
+        const data = await response.text();
+        detectedCountry = data.toLowerCase();
+      }
+    } else {
+      const url = `https://geoip.websolute.it/Ip2Location/get_info.aspx?ipaddress=${isValidIp ? ip : ""}`;
+      const response = await fetch(url);
+      if (response.ok) {
+        const xml = await response.text();
+        detectedCountry = ((xml.split("<CountryCode><![CDATA[")[1] || "").split("]]></CountryCode>")[0] || "").replace("-", "").toLowerCase();
+      }
+    }
+    return detectedCountry || defaultMarket4 || process.env.DEFAULT_MARKET;
+  } catch (error) {
+    console.log("routeInterceptor.detectCountry.error", error);
+  }
+  return defaultMarket4 || process.env.DEFAULT_MARKET;
+}
+async function getMarkets2() {
+  const apiGet = import_bom_mixer_store15.storeStrategy === import_bom_mixer_store15.StoreStrategy.DecoratedApi ? import_bom_mixer_store15.localApiGet : import_bom_mixer_store15.storeApiGet;
+  const markets = await apiGet("/market?pagination=false");
+  return markets;
+}
+async function getRootRoutes() {
+  const apiGet = import_bom_mixer_store15.storeStrategy === import_bom_mixer_store15.StoreStrategy.DecoratedApi ? import_bom_mixer_store15.localApiGet : import_bom_mixer_store15.storeApiGet;
+  const routes = await apiGet("/route?where[isRoot][equals]=true");
+  return routes;
+}
+async function routeAutoDetection(request, next) {
+  let route;
+  const url = request.nextUrl;
+  if (url.pathname === "/") {
+    const cookie = request.cookies.get("detectedRoute");
+    if (cookie?.value) {
+      return cookie.value;
+    }
+    const rootRoutes = await getRootRoutes();
+    const defaultRoute = rootRoutes.find((x) => x.id === "/");
+    if (defaultRoute) {
+      return;
+    }
+    const markets = await getMarkets2();
+    const market = markets.find((x) => x.isDefault) || markets.find((x) => x.id === import_bom_core5.defaultMarket) || markets[0];
+    const detectedCountry = await detectCountry(request, market.id);
+    const detectedMarket = detectedCountry ? markets.filter((x) => Array.isArray(x.countries)).find((x) => {
+      const countries = (x.countries || []).map((x2) => typeof x2 === "string" ? x2 : x2.id);
+      return countries.includes(detectedCountry);
+    }) || markets.find((x) => !Array.isArray(x.countries)) : void 0;
+    let detectedMarketRoutes = rootRoutes.filter((x) => x.market === detectedMarket?.id);
+    if (detectedMarketRoutes.length === 0) {
+      detectedMarketRoutes = rootRoutes.filter((x) => x.market === market.id);
+    }
+    const defaultMarketLocale = market.defaultLanguage ? typeof market.defaultLanguage === "string" ? market.defaultLanguage : market.defaultLanguage.id : import_bom_core5.defaultLocale;
+    const detectedLocale = await detectLocale(request, defaultMarketLocale);
+    const detectedLocaleRoutes = detectedMarketRoutes.filter((x) => x.locale === detectedLocale);
+    const detectedRoute = detectedLocaleRoutes.length > 0 ? detectedLocaleRoutes[0] : detectedMarketRoutes.find((x) => {
+      const market2 = markets.find((m) => m.id === x.market);
+      const marketLocale = market2.defaultLanguage ? (0, import_bom_core5.asEquatable)(market2.defaultLanguage) : defaultMarketLocale;
+      return x.locale === marketLocale;
+    });
+    if (detectedRoute && detectedRoute.id !== url.pathname) {
+      console.log("routeInterceptor.routeAutoDetection", detectedLocale, detectedCountry, detectedRoute.id);
+      route = detectedRoute.id;
+    }
+  }
+  return route;
+}
+async function routeInterceptor(request, next) {
+  let route;
+  let url = request.nextUrl;
+  const hrefBeforeRedirect = getHrefBeforeRedirect(request);
+  try {
+    const redirectUrl = await routeAutoDetection(request, next);
+    if (redirectUrl) {
+      const response2 = import_server.NextResponse.redirect(resolveHref(redirectUrl), import_bom_core5.isDevelopment ? 307 : 301);
+      response2.cookies.set({
+        expires: new Date(Date.now() + 1 * 24 * 60 * 60 * 1e3),
+        httpOnly: true,
+        name: "detectedRoute",
+        path: "/",
+        sameSite: "lax",
+        secure: true,
+        value: redirectUrl
+      });
+      return response2;
+    }
+    if (import_bom_mixer_store15.storeStrategy === import_bom_mixer_store15.StoreStrategy.DecoratedApi) {
+      route = await (0, import_bom_mixer_store15.localApiPost)("/route", { pathname: url.pathname, href: url.href, hrefBeforeRedirect });
+    } else {
+      route = await (0, import_bom_mixer_store15.storeApiPost)("/route", { pathname: url.pathname, href: url.href, hrefBeforeRedirect });
+    }
+    if (!route) {
+      console.log("routeInterceptor.route.notfound", url.pathname);
+      return;
+    }
+  } catch (error) {
+    if (error.status >= 300 && error.status < 400) {
+      console.log("routeInterceptor.3xx", url.pathname, error.status, error.statusText);
+      try {
+        const { redirectUrl } = await error.json();
+        const response2 = import_server.NextResponse.redirect(redirectUrl, error.status);
+        return response2;
+      } catch (error2) {
+        const publicUrl = getPublicUrl();
+        console.log("routeInterceptor.3xx.error", `cannot parse response, redirecting to ${publicUrl}`);
+        const response2 = import_server.NextResponse.redirect(publicUrl, 307);
+        return response2;
+      }
+    } else if (error.status === 410) {
+      console.log("routeInterceptor.410", url.pathname, error.status, error.statusText);
+      url = request.nextUrl.clone();
+      url.pathname = `/${error.status}`;
+      const response2 = import_server.NextResponse.rewrite(url, {
+        status: error.status,
+        statusText: error.statusText,
+        request
+      });
+      return response2;
+    } else if (error.status >= 400 && error.status < 500) {
+      console.log("routeInterceptor.4xx", url.pathname, error.status, error.statusText);
+      const response2 = import_server.NextResponse.next({
+        status: error.status,
+        statusText: error.statusText,
+        request
+      });
+      return response2;
+    }
+    console.log("routeInterceptor.error", url.pathname, error.url, error.status, error.statusText || error);
+    return;
+  }
+  url = request.nextUrl.clone();
+  const resolvedPathname = resolveRoute(route);
+  url.pathname = resolvedPathname;
+  const response = import_server.NextResponse.rewrite(url);
+  return response;
+}
+function getHrefBeforeRedirect(request) {
+  let hrefBeforeRedirect = null;
+  const urlBeforeRedirect = request.nextUrl.clone();
+  const host = (0, import_bom_core5.getHost)(request.headers);
+  if (host) {
+    urlBeforeRedirect.host = host;
+    urlBeforeRedirect.port = host.split(":")[1] || "";
+    hrefBeforeRedirect = urlBeforeRedirect.href;
+  }
+  return hrefBeforeRedirect;
+}
+
+// src/seo/seo.service.ts
+var getSeoWeight = (index = 0, seoWeight) => {
+  const getter = (subIndex = 0) => {
+    const i = seoWeight ? parseInt(seoWeight.replace(/\D/g, "")) : index === 0 ? 1 : 2;
+    return `h${Math.min(i + subIndex, 6)}`;
+  };
+  return getter;
 };
 
-//#endregion
-//#region src/utmz/utmz.service.ts
+// src/session/session.service.ts
+var import_bom_core6 = require("@websolutespa/bom-core");
+var import_iron_session = require("iron-session");
+async function getSession(request, response) {
+  const COOKIE_NAME = "websolutespa-next-js";
+  const COOKIE_PASSWORD = process.env.SECRET_COOKIE_PASSWORD || "SECRET_COOKIE_PASSWORD_32_CHARS_LONG";
+  const sessionOptions = {
+    cookieName: COOKIE_NAME,
+    // secure: true should be used in production (HTTPS) but can't be used in development (HTTP)
+    cookieOptions: {
+      secure: !import_bom_core6.isDevelopment
+    },
+    password: COOKIE_PASSWORD
+  };
+  const session = await (0, import_iron_session.getIronSession)(request, response, sessionOptions);
+  return session;
+}
+async function getSessionToken(request, response) {
+  const session = await getSession(request, response);
+  if (session.token && session.exp && session.exp > Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3)) {
+    return session.token;
+  } else {
+    session.token = void 0;
+    session.exp = void 0;
+    await session.save();
+    session.destroy();
+    return;
+  }
+}
+
+// src/sitemap/sitemap.handler.ts
+var import_bom_core8 = require("@websolutespa/bom-core");
+
+// src/sitemap/sitemap.service.ts
+var import_bom_core7 = require("@websolutespa/bom-core");
+async function getSiteMapIndex(origin) {
+  let markets = await getMarkets();
+  let locales = await getLocales();
+  markets = markets.filter((x) => x.isActive !== false);
+  locales = locales.filter((x) => x.isActive !== false);
+  const routes = await getRoutes();
+  const sitemaps = [];
+  const getTime = (date) => {
+    return typeof date !== "undefined" ? (typeof date === "string" ? new Date(date) : date).getTime() : 0;
+  };
+  (0, import_bom_core7.eachMarketLocale)(markets, locales, (market, locale, markets2, locales2) => {
+    const sitemapRoutes = routes.filter((x) => x.market === market.id && x.locale === locale.id);
+    sitemapRoutes.sort((a, b) => getTime(a.updatedAt) - getTime(b.updatedAt));
+    sitemaps.push({
+      id: `/${market.id}/${locale.id}/sitemap.xml`,
+      updatedAt: sitemapRoutes.length > 0 ? sitemapRoutes[sitemapRoutes.length - 1].updatedAt : void 0
+    });
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${origin}/sitemap.xsl"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sitemaps.map((sitemap) => `
+  <sitemap>
+    <loc>${escapeHtml(encodeURI(`${origin}${sitemap.id}`))}</loc>${sitemap.updatedAt ? `
+    <lastmod>${escapeHtml(String(sitemap.updatedAt))}</lastmod>` : ""}
+  </sitemap>
+`).join("")}
+</sitemapindex>`;
+}
+function getSiteMapXMLLastMod(canonical) {
+  return canonical.updatedAt ? `
+    <lastmod>${escapeHtml(String(canonical.updatedAt))}</lastmod>` : "";
+}
+function getSiteMapXMLImage(canonical) {
+  return canonical.media ? `
+    <image:image>
+      <image:loc>${escapeHtml(encodeURI(`${canonical.media.src || canonical.media.url}`))}</image:loc>
+    </image:image>` : "";
+}
+function getSiteMapXMLAlternates(origin, canonical) {
+  return canonical.alternates.map((alternate) => `
+    <xhtml:link href="${escapeHtml(encodeURI(`${origin}${alternate.id}`))}" hreflang="${alternate.locale}-${alternate.market}" rel="alternate" />`).join("");
+}
+function getSiteMapXMLUrl(origin, canonical) {
+  return `
+  <url>
+    <loc>${escapeHtml(encodeURI(`${origin}${canonical.id}`))}</loc>${getSiteMapXMLLastMod(canonical)}${getSiteMapXMLAlternates(origin, canonical)}${getSiteMapXMLImage(canonical)}
+  </url>`;
+}
+function escapeHtml(string) {
+  const matchHtmlRegExp = /["'&<>]/;
+  const str = "" + string;
+  const match = matchHtmlRegExp.exec(str);
+  if (!match) {
+    return str;
+  }
+  let escape;
+  let html = "";
+  let index = 0;
+  let lastIndex = 0;
+  for (index = match.index; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escape = "&quot;";
+        break;
+      case 38:
+        escape = "&amp;";
+        break;
+      case 39:
+        escape = "&#39;";
+        break;
+      case 60:
+        escape = "&lt;";
+        break;
+      case 62:
+        escape = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+    lastIndex = index + 1;
+    html += escape;
+  }
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+function getSiteMapXMLUrls(origin, canonicalRoutes) {
+  return canonicalRoutes.map((canonicalRoute) => getSiteMapXMLUrl(origin, canonicalRoute)).join("");
+}
+async function getSiteMapXML(origin, marketId, localeId) {
+  let markets = await getMarkets();
+  let locales = await getLocales();
+  markets = markets.filter((x) => x.isActive !== false);
+  locales = locales.filter((x) => x.isActive !== false);
+  const defaultMarket4 = markets.find((x) => marketId ? x.id === marketId : x.isDefault) || markets[0];
+  const defaultLocale4 = locales.find((x) => localeId ? x.id === localeId : x.isDefault) || locales[0];
+  const defaultMarketLocale = defaultMarket4 && defaultMarket4.defaultLanguage ? defaultMarket4.defaultLanguage : defaultLocale4.id;
+  const routes = await getRoutes();
+  const isCanonicalRoute = marketId && localeId ? (route) => {
+    return route.noindex !== true && route.market === defaultMarket4.id && route.locale === defaultLocale4.id;
+  } : (route) => {
+    return route.noindex !== true && route.market === defaultMarket4.id && route.locale === defaultMarketLocale;
+  };
+  const getCanonicalAlternates = marketId && localeId ? (canonical) => {
+    return [];
+  } : (canonical) => {
+    return routes.filter((alternate) => {
+      return alternate !== canonical && alternate.schema === canonical.schema && alternate.page === canonical.page;
+    });
+  };
+  const routeToRouteCanonical = (canonical) => {
+    const alternates = getCanonicalAlternates(canonical);
+    return { ...canonical, alternates };
+  };
+  const canonicalRoutes = routes.filter(isCanonicalRoute).map(routeToRouteCanonical);
+  return `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${origin}/sitemap.xsl"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xhtml="http://www.w3.org/1999/xhtml"
+        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
+${getSiteMapXMLUrls(origin, canonicalRoutes)}
+</urlset>
+ `;
+}
+async function getSiteMapXSL(localeId) {
+  let locales = await getLocales();
+  locales = locales.filter((x) => x.isActive !== false);
+  const defaultLocale4 = locales.find((x) => localeId ? x.id === localeId : x.isDefault) || locales[0];
+  return (
+    /* html */
+    `<?xml version="1.0" encoding="UTF-8"?>
+	<xsl:stylesheet version="2.0"
+		xmlns:html="http://www.w3.org/TR/REC-html40"
+		xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
+		xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
+		xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+	<xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
+	<xsl:template match="/">
+		<html lang="${defaultLocale4.id}" xmlns="http://www.w3.org/1999/xhtml">
+		<head>
+			<title>XML Sitemap</title>
+			<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+			<style type="text/css">
+        html {
+          padding: 0;
+          background: #09090A;
+					color: #fefefe;
+        }
+				body {
+          padding: 15px;
+					font-family: Inter,-apple-system,'Helvetica Neue','Segoe UI',Roboto,Arial,'Noto Sans',sans-serif;
+					font-size: 13px;
+          background: #09090A;
+					color: #fefefe;
+				}
+				.container {
+					margin: 0 auto;
+					max-width: 1280px;
+				}
+				a {
+					color: #fefefe;
+					text-decoration: none;
+				}
+				a:visited {
+					color: #9e9e9e;
+				}
+				a:hover {
+					text-decoration: underline;
+				}
+				table {
+          width: 100%;
+          margin: 10px 0;
+					border: none;
+					border-collapse: collapse;
+				}
+				td,
+        th {
+					text-align: left;
+					font-size: 12px;
+          padding: 3px;
+				}
+				th:not(:last-child),
+        td:not(:last-child) {
+					padding-right: 30px;
+				}
+				thead th {
+					border-bottom: 1px solid #0e0e0f;
+				}
+				#sitemap tr:nth-child(odd) td {
+					background-color: #0e0e0f;
+				}
+				#sitemap tbody tr:hover td {
+					background-color: #1A1A1B;
+				}
+				#sitemap tbody tr:hover td,
+        #sitemap tbody tr:hover td a {
+					color: #fefefe;
+				}
+				.wysiwyg {
+          margin: 0;
+					padding: 0 0 10px 0;
+					line-height: 1.2em;
+				}
+				.wysiwyg a {
+					color: #00ea4e;
+					font-weight: 600;
+				}
+				.wysiwyg a:visited {
+					color: #00ea4e;
+				}
+			</style>
+		</head>
+		<body>
+		<div class="container">
+			<h1>XML Sitemap</h1>
+			<p class="wysiwyg">
+        This is an XML Sitemap meant for consumption by search engines, generated by <a href="https://github.com/websolutespa/bom" target="_blank" rel="noopener">Mixer</a>.
+      </p>
+      <p class="wysiwyg">
+				You can find more information about XML sitemaps on <a href="https://sitemaps.org" target="_blank" rel="noopener">sitemaps.org</a>.
+			</p>
+			<xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &gt; 0">
+				<p class="wysiwyg">
+					This sitemap index file contains <xsl:value-of select="count(sitemap:sitemapindex/sitemap:sitemap)"/> sitemaps.
+				</p>
+				<table id="sitemap" cellpadding="3">
+					<thead>
+            <tr>
+              <th width="75%">Sitemap</th>
+              <th width="25%" title="Last Modification Time">Updated At</th>
+            </tr>
+					</thead>
+					<tbody>
+					<xsl:for-each select="sitemap:sitemapindex/sitemap:sitemap">
+						<xsl:variable name="sitemapURL">
+							<xsl:value-of select="sitemap:loc"/>
+						</xsl:variable>
+						<tr>
+							<td>
+								<a href="{$sitemapURL}"><xsl:value-of select="sitemap:loc"/></a>
+							</td>
+							<td>
+								<xsl:value-of select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
+							</td>
+						</tr>
+					</xsl:for-each>
+					</tbody>
+				</table>
+			</xsl:if>
+			<xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &lt; 1">
+				<p class="wysiwyg">
+					This sitemap contains <xsl:value-of select="count(sitemap:urlset/sitemap:url)"/> URLs.
+				</p>
+				<table id="sitemap" cellpadding="3">
+					<thead>
+					<tr>
+						<th width="75%">URL</th>
+						<th width="15%" title="Last Modification Time">Updated At</th>
+						<th width="10%">Images</th>
+					</tr>
+					</thead>
+					<tbody>
+					<xsl:variable name="lower" select="'abcdefghijklmnopqrstuvwxyz'"/>
+					<xsl:variable name="upper" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"/>
+					<xsl:for-each select="sitemap:urlset/sitemap:url">
+						<tr>
+							<td>
+								<xsl:variable name="itemURL">
+									<xsl:value-of select="sitemap:loc"/>
+								</xsl:variable>
+								<a href="{$itemURL}">
+									<xsl:value-of select="sitemap:loc"/>
+								</a>
+							</td>
+							<td>
+								<xsl:value-of select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
+							</td>
+							<td>
+								<xsl:value-of select="count(image:image)"/>
+							</td>
+						</tr>
+					</xsl:for-each>
+					</tbody>
+				</table>
+			</xsl:if>
+		</div>
+		</body>
+		</html>
+	</xsl:template>
+	</xsl:stylesheet>`
+  );
+}
+
+// src/sitemap/sitemap.handler.ts
+var getSiteMapIndexProps = async (context) => {
+  const { req, res } = context;
+  const sitemap = await getSiteMapIndex((0, import_bom_core8.getOrigin)(req.headers));
+  res.setHeader("Content-Type", "application/xml; charset=UTF-8");
+  res.setHeader("X-Frame-Options", "SAMEORIGIN");
+  res.setHeader("X-Robots-Tag", "noindex, follow");
+  res.write(sitemap);
+  res.end();
+  return {
+    props: {}
+  };
+};
+var getSiteMapXMLProps = async (context) => {
+  const { req, res } = context;
+  const params = context.params;
+  const market = params?.market;
+  const locale = params?.locale;
+  const sitemap = await getSiteMapXML((0, import_bom_core8.getOrigin)(req.headers), market, locale);
+  res.setHeader("Content-Type", "application/xml; charset=UTF-8");
+  res.setHeader("X-Frame-Options", "SAMEORIGIN");
+  res.setHeader("X-Robots-Tag", "noindex, follow");
+  res.write(sitemap);
+  res.end();
+  return {
+    props: {}
+  };
+};
+var getSiteMapXSLProps = async (context) => {
+  const { req, res } = context;
+  const params = context.params;
+  const market = params?.market;
+  const locale = params?.locale;
+  const sitemap = await getSiteMapXSL(locale);
+  res.setHeader("Content-Type", "application/xml; charset=UTF-8");
+  res.setHeader("X-Frame-Options", "SAMEORIGIN");
+  res.setHeader("X-Robots-Tag", "noindex, follow");
+  res.write(sitemap);
+  res.end();
+  return {
+    props: {}
+  };
+};
+
+// src/utmz/utmz.service.ts
 function getUtmz(request) {
-	let utmz = "N/A";
-	if (typeof request.cookies.__utmz === "string") {
-		utmz = request.cookies.__utmz;
-		const i = utmz.indexOf("utmcsr");
-		utmz = utmz.substring(i === -1 ? 0 : i);
-	}
-	return utmz;
-}
-
-//#endregion
-export { categoryToRouteLink, getLink, getLocaleFromProps, getPublicUrl, getSeoWeight, getUtmz, newRouteLink, pushDataLayer, resolveHref, resolveRoute, routeToRouteLink };
-//# sourceMappingURL=index.js.map
+  let utmz = "N/A";
+  if (typeof request.cookies.__utmz === "string") {
+    utmz = request.cookies.__utmz;
+    const i = utmz.indexOf("utmcsr");
+    utmz = utmz.substring(i === -1 ? 0 : i);
+  }
+  return utmz;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAZY_PROPS,
+  NotFound,
+  detectCountry,
+  detectLocale,
+  escapeHtml,
+  findManyPages,
+  findOnePage,
+  getAddressOptions,
+  getBreadcrumbFromSegments,
+  getCaptionsVttProps,
+  getCategories,
+  getCategory,
+  getConsentPreference,
+  getConsentPreferences,
+  getConsentPreferencesPagination,
+  getCountries,
+  getCountriesPagination,
+  getCountry,
+  getDecoratedComponents,
+  getErrorPageLayout,
+  getLabel,
+  getLabels,
+  getLayout,
+  getLink,
+  getLocale,
+  getLocaleFromProps,
+  getLocales,
+  getMarket,
+  getMarkets,
+  getMenu,
+  getMenus,
+  getPage,
+  getPageCategory,
+  getPageProps,
+  getPageRoutes,
+  getProvince,
+  getProvinces,
+  getProvincesPagination,
+  getPublicUrl,
+  getRedirect,
+  getRedirects,
+  getRedirectsPagination,
+  getRegion,
+  getRegions,
+  getRegionsPagination,
+  getRoute,
+  getRouteLinkCategory,
+  getRouteLinkTree,
+  getRoutes,
+  getRoutesForSchemas,
+  getRoutesForTemplates,
+  getSegments,
+  getSeoWeight,
+  getSession,
+  getSessionToken,
+  getSiteMapIndex,
+  getSiteMapIndexProps,
+  getSiteMapXML,
+  getSiteMapXMLProps,
+  getSiteMapXSL,
+  getSiteMapXSLProps,
+  getStaticPathsForSchema,
+  getStaticPathsForSchemaAndFallback,
+  getUtmz,
+  newRouteLink,
+  pushDataLayer,
+  redirectTo,
+  resolveHref,
+  resolveLabel,
+  resolveRoute,
+  routeAutoDetection,
+  routeInterceptor,
+  routeRevalidateHandler,
+  routeToRouteLink,
+  withLazyProps
+});