@websolutespa/payload-plugin-bowl 0.0.1

package/dist/index.js

@@ -0,0 +1,3835 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BlockDefaults: () => BlockDefaults,
+  CategoryDefaults: () => CategoryDefaults,
+  CheckboxDefaults: () => CheckboxDefaults,
+  CollectionDefault: () => CollectionDefault,
+  ColorCell: () => ColorCell,
+  ColorConfig: () => ColorConfig,
+  ColorField: () => ColorField,
+  ComponentsDefaults: () => ComponentsDefaults,
+  DateDefaults: () => DateDefaults,
+  DebugField: () => DebugField,
+  GlobalDefault: () => GlobalDefault,
+  InMemoryCache: () => InMemoryCache,
+  LocalizedField: () => LocalizedField,
+  MarketDefaults: () => MarketDefaults,
+  MediaDefaults: () => MediaDefaults,
+  MediasDefaults: () => MediasDefaults,
+  PageDefault: () => PageDefault,
+  RelatedDefaults: () => RelatedDefaults,
+  RichTextDefaults: () => RichTextDefaults,
+  SelectDefaults: () => SelectDefaults,
+  StaticCollectionDefault: () => StaticCollectionDefault,
+  TemplateDefaults: () => TemplateDefaults,
+  TextDefaults: () => TextDefaults,
+  UILanguagesCell: () => UILanguagesCell,
+  UILanguagesField: () => UILanguagesField,
+  UIStaticCell: () => UIStaticCell,
+  UIStaticField: () => UIStaticField,
+  afterPageChangeHook: () => afterPageChangeHook,
+  afterPageDeleteHook: () => afterPageDeleteHook,
+  appearanceOptions: () => appearanceOptions,
+  bowl: () => bowl,
+  collectionGet: () => collectionGet,
+  debugField: () => debugField,
+  deepMerge: () => deepMerge,
+  default: () => src_default,
+  defaultGroup: () => defaultGroup,
+  defaultLocale: () => defaultLocale,
+  defaultLocales: () => defaultLocales,
+  defaultSlug: () => defaultSlug,
+  fetchCollection: () => fetchCollection,
+  fetchCollectionItems: () => fetchCollectionItems,
+  fetchEndpoint: () => fetchEndpoint,
+  fetchGlobal: () => fetchGlobal,
+  fetchGlobalItems: () => fetchGlobalItems,
+  formatSlug: () => formatSlug,
+  getApiUrl: () => getApiUrl,
+  getLocale: () => getLocale,
+  getNumericParam: () => getNumericParam,
+  getObjectParam: () => getObjectParam,
+  getRoute: () => getRoute,
+  getRoutes: () => getRoutes,
+  getSearchUrl: () => getSearchUrl,
+  getStaticLoader: () => getStaticLoader,
+  getStore: () => getStore,
+  getStringParam: () => getStringParam,
+  getTranslation: () => getTranslation2,
+  getTranslations: () => getTranslations,
+  internalSlugs: () => internalSlugs,
+  isObject: () => isObject,
+  keyWithRequest: () => keyWithRequest,
+  localeGet: () => localeGet,
+  localizeCollection: () => localizeCollection,
+  localizedField: () => localizedField,
+  logMissingTranslations: () => logMissingTranslations,
+  options: () => options,
+  populateStaticFields: () => populateStaticFields,
+  richTextAfterReadHook: () => richTextAfterReadHook,
+  richTextSerialize: () => richTextSerialize,
+  routeGet: () => routeGet,
+  slugToLabel: () => slugToLabel,
+  slugToLabels: () => slugToLabels,
+  storeGet: () => storeGet,
+  toBlock: () => toBlock,
+  toCollection: () => toCollection,
+  toField: () => toField,
+  toGlobal: () => toGlobal,
+  toTab: () => toTab,
+  translateBlock: () => translateBlock,
+  translateBlocks: () => translateBlocks,
+  translateCollection: () => translateCollection,
+  translateField: () => translateField,
+  translateFields: () => translateFields,
+  translateGlobal: () => translateGlobal,
+  translateTab: () => translateTab,
+  translateTabs: () => translateTabs,
+  validateHexColor: () => validateHexColor,
+  whereCollection: () => whereCollection,
+  withAbstract: () => withAbstract,
+  withAbstractRequired: () => withAbstractRequired,
+  withBlock: () => withBlock,
+  withCategory: () => withCategory,
+  withCategoryRequired: () => withCategoryRequired,
+  withCheckbox: () => withCheckbox,
+  withCheckboxRequired: () => withCheckboxRequired,
+  withCollection: () => withCollection,
+  withCollectionHook: () => withCollectionHook,
+  withColor: () => withColor,
+  withColorRequired: () => withColorRequired,
+  withComponents: () => withComponents,
+  withDate: () => withDate,
+  withDateRequired: () => withDateRequired,
+  withDescription: () => withDescription,
+  withDescriptionRequired: () => withDescriptionRequired,
+  withFieldHook: () => withFieldHook,
+  withGlobal: () => withGlobal,
+  withGlobalHook: () => withGlobalHook,
+  withId: () => withId,
+  withIdRequired: () => withIdRequired,
+  withIsActive: () => withIsActive,
+  withIsActiveRequired: () => withIsActiveRequired,
+  withIsDefault: () => withIsDefault,
+  withIsDefaultRequired: () => withIsDefaultRequired,
+  withLink: () => withLink,
+  withLocalized: () => withLocalized,
+  withMarkets: () => withMarkets,
+  withMarketsRequired: () => withMarketsRequired,
+  withMedia: () => withMedia,
+  withMediaRequired: () => withMediaRequired,
+  withMedias: () => withMedias,
+  withMediasRequired: () => withMediasRequired,
+  withName: () => withName,
+  withNameRequired: () => withNameRequired,
+  withPage: () => withPage,
+  withRelated: () => withRelated,
+  withRichText: () => withRichText,
+  withRichTextRequired: () => withRichTextRequired,
+  withSelect: () => withSelect,
+  withSelectRequired: () => withSelectRequired,
+  withSlug: () => withSlug,
+  withSlugRequired: () => withSlugRequired,
+  withStaticCollection: () => withStaticCollection,
+  withTemplate: () => withTemplate,
+  withTemplateRequired: () => withTemplateRequired,
+  withText: () => withText,
+  withTextRequired: () => withTextRequired,
+  withTitle: () => withTitle,
+  withTitleRequired: () => withTitleRequired,
+  withUILanguages: () => withUILanguages,
+  withUIStatic: () => withUIStatic
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/collections/Category.ts
+var Category = /* @__PURE__ */ __name((options2) => ({
+  type: "withCollection",
+  slug: options2.slug.category,
+  admin: {
+    group: options2.group.nav,
+    useAsTitle: "id",
+    defaultColumns: ["id", "title", "category"]
+  },
+  fields: [
+    // inherited fields: id, createdAt, updatedAt
+    { type: "withId", required: true },
+    { type: "withTitle", required: true },
+    {
+      type: "withSlug",
+      fieldToUse: "title",
+      admin: {
+        position: "sidebar"
+      }
+    },
+    { type: "withMedia" },
+    { type: "withCategory" }
+  ]
+}), "Category");
+
+// src/collections/Continent.ts
+var Continent = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/continent.json",
+  slug: options2.slug.continent,
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text"
+    }
+  ]
+}), "Continent");
+
+// src/collections/Country.ts
+var Country = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/country.json",
+  slug: options2.slug.country,
+  /*
+  map: {
+    continentId: 'continent',
+    subContinentId: 'subContinent',
+  },
+  */
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text",
+      localized: true
+    },
+    {
+      name: "englishName",
+      label: "English Name",
+      type: "text"
+    },
+    {
+      name: "nativeName",
+      label: "Native Name",
+      type: "text"
+    },
+    {
+      name: "alpha2Code",
+      label: "Alpha2 Code",
+      type: "text"
+    },
+    {
+      name: "alpha3Code",
+      label: "Alpha3 Code",
+      type: "text"
+    },
+    {
+      name: "continent",
+      label: "Continent",
+      type: "relationship",
+      relationTo: options2.slug.continent,
+      hasMany: false,
+      required: true
+    },
+    {
+      name: "subContinent",
+      label: "Sub Continent",
+      type: "relationship",
+      relationTo: options2.slug.subContinent,
+      hasMany: false,
+      required: true
+    }
+  ]
+}), "Country");
+
+// src/collections/CountryZone.ts
+var CountryZone = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/countryZone.json",
+  slug: options2.slug.countryZone,
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text"
+    }
+  ]
+}), "CountryZone");
+
+// src/collections/Label.ts
+var Label = /* @__PURE__ */ __name((options2) => ({
+  type: "withCollection",
+  slug: options2.slug.label,
+  admin: {
+    group: options2.group.config,
+    useAsTitle: "id",
+    defaultColumns: ["id", "title"]
+  },
+  fields: [
+    // inherited fields: id, createdAt, updatedAt
+    { type: "withId", required: true },
+    { type: "withTitle", required: true }
+  ]
+}), "Label");
+
+// src/collections/Language.ts
+var Language = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/language.json",
+  slug: options2.slug.language,
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text",
+      localized: true
+    },
+    {
+      name: "englishName",
+      label: "English Name",
+      type: "text"
+    },
+    {
+      name: "nativeName",
+      label: "Native Name",
+      type: "text"
+    }
+  ]
+}), "Language");
+
+// src/collections/Market.ts
+var Market = /* @__PURE__ */ __name((options2) => ({
+  type: "withCollection",
+  slug: options2.slug.market,
+  admin: {
+    group: options2.group.config,
+    useAsTitle: "title",
+    defaultColumns: ["title", "id", "countries", "languages"]
+  },
+  fields: [
+    // inherited fields: id, createdAt, updatedAt
+    { type: "withId", required: true },
+    { type: "withTitle", required: true, localized: false },
+    { type: "withIsActive", required: true },
+    { type: "withIsDefault", required: true },
+    // !!! todo create a generic withRelation(slug.country) ?
+    {
+      name: "countries",
+      label: "Countries",
+      type: "relationship",
+      relationTo: options2.slug.country,
+      hasMany: true
+    },
+    {
+      name: "languages",
+      label: "Languages",
+      type: "relationship",
+      relationTo: options2.slug.language,
+      hasMany: true,
+      filterOptions: () => {
+        return {
+          "id": { in: options2.locales }
+        };
+      }
+    },
+    {
+      name: "defaultLanguage",
+      label: "Default language",
+      type: "relationship",
+      relationTo: options2.slug.language,
+      hasMany: false,
+      hooks: {
+        beforeChange: [({ data, value }) => {
+          const languages = data.languages;
+          if (languages && languages.length > 0)
+            return value;
+          return null;
+        }]
+      },
+      admin: {
+        condition: (data) => {
+          const languages = data.languages;
+          if (languages && languages.length > 0)
+            return true;
+          return false;
+        }
+      },
+      filterOptions: () => {
+        return {
+          "id": { in: options2.locales }
+        };
+      },
+      validate: async (val, { data }) => {
+        const languages = data.languages;
+        if (languages && languages.length > 0 && languages.indexOf(val) < 0) {
+          return "You must select a default language from the selected languages.";
+        }
+        return true;
+      }
+    }
+  ]
+}), "Market");
+
+// src/collections/Media.ts
+var Media = /* @__PURE__ */ __name((options2) => ({
+  type: "withCollection",
+  slug: options2.slug.media,
+  admin: {
+    group: options2.group.content
+    // !!! todo defaultColumns
+  },
+  access: {
+    read: () => true
+    // Everyone can read Media
+  },
+  upload: {
+    adminThumbnail: "card",
+    imageSizes: [
+      {
+        name: "card",
+        width: 640,
+        height: 480
+      },
+      {
+        name: "feature",
+        width: 1024,
+        height: 576
+      }
+    ]
+  },
+  fields: [
+    // inherited fields: id, createdAt, updatedAt
+    // !!! todo convert to localized text
+    {
+      name: "alt",
+      label: "Alt Text",
+      type: "text",
+      required: true
+    }
+  ]
+}), "Media");
+
+// src/collections/Municipality.ts
+var Municipality = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/municipality.json",
+  slug: options2.slug.municipality,
+  /*
+  map: {
+    countryId: 'country',
+    countryZoneId: 'countryZone',
+    regionId: 'region',
+    provinceId: 'province',
+  },
+  */
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text"
+    },
+    {
+      name: "code",
+      label: "Code",
+      type: "text"
+    },
+    {
+      name: "country",
+      label: "Country",
+      type: "relationship",
+      relationTo: options2.slug.country,
+      hasMany: false,
+      required: true
+    },
+    {
+      name: "countryZone",
+      label: "Country Zone",
+      type: "relationship",
+      relationTo: options2.slug.countryZone,
+      hasMany: false,
+      required: true
+    },
+    {
+      name: "region",
+      label: "Region",
+      type: "relationship",
+      relationTo: options2.slug.region,
+      hasMany: false,
+      required: true
+    },
+    {
+      name: "province",
+      label: "Province",
+      type: "relationship",
+      relationTo: options2.slug.province,
+      hasMany: false,
+      required: true
+    }
+  ]
+}), "Municipality");
+
+// src/collections/Page.ts
+var Page = /* @__PURE__ */ __name((options2) => ({
+  type: "withCollection",
+  slug: options2.slug.page,
+  admin: {
+    group: options2.group.nav
+  },
+  fields: [
+    {
+      name: "content",
+      label: "Content",
+      type: "relationship",
+      relationTo: options2.pages,
+      hasMany: false,
+      required: true,
+      admin: {
+        readOnly: true
+      }
+    }
+  ]
+}), "Page");
+
+// src/collections/Province.ts
+var Province = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/province.json",
+  slug: options2.slug.province,
+  /*
+  map: {
+    countryId: 'country',
+    countryZoneId: 'countryZone',
+    regionId: 'region',
+  },
+  */
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text"
+    },
+    {
+      name: "code",
+      label: "Code",
+      type: "text"
+    },
+    {
+      name: "country",
+      label: "Country",
+      type: "relationship",
+      relationTo: options2.slug.country,
+      hasMany: false,
+      required: true
+    },
+    {
+      name: "countryZone",
+      label: "Country Zone",
+      type: "relationship",
+      relationTo: options2.slug.countryZone,
+      hasMany: false,
+      required: true
+    },
+    {
+      name: "region",
+      label: "Region",
+      type: "relationship",
+      relationTo: options2.slug.region,
+      hasMany: false,
+      required: true
+    }
+  ]
+}), "Province");
+
+// src/collections/Region.ts
+var Region = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/region.json",
+  slug: options2.slug.region,
+  /*
+  map: {
+    countryId: 'country',
+    countryZoneId: 'countryZone',
+  },
+  */
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text"
+    },
+    {
+      name: "country",
+      label: "Country",
+      type: "relationship",
+      relationTo: options2.slug.country,
+      hasMany: false,
+      required: true
+    },
+    {
+      name: "countryZone",
+      label: "Country Zone",
+      type: "relationship",
+      relationTo: options2.slug.countryZone,
+      hasMany: false,
+      required: true
+    }
+  ]
+}), "Region");
+
+// src/collections/SubContinent.ts
+var SubContinent = /* @__PURE__ */ __name((options2) => ({
+  type: "withStatic",
+  src: "https://actarian.github.io/cms-i18n-react/api/subContinent.json",
+  slug: options2.slug.subContinent,
+  /*
+  map: {
+    continentId: 'continent',
+  },
+  */
+  fields: [
+    {
+      name: "id",
+      label: "ID",
+      type: "text"
+    },
+    {
+      name: "name",
+      label: "Name",
+      type: "text"
+    },
+    {
+      name: "continent",
+      label: "Continent",
+      type: "relationship",
+      relationTo: options2.slug.continent,
+      hasMany: false,
+      required: true
+    }
+  ]
+}), "SubContinent");
+
+// src/collections/Template.ts
+var Template = /* @__PURE__ */ __name((options2) => ({
+  type: "withCollection",
+  slug: options2.slug.template,
+  admin: {
+    group: options2.group.config,
+    useAsTitle: "name",
+    defaultColumns: ["name", "id"]
+  },
+  fields: [
+    // inherited fields: id, createdAt, updatedAt
+    { type: "withId", required: true },
+    { type: "withName", required: true },
+    // !!! todo withSelect ?
+    {
+      name: "compatibleCollections",
+      label: "Compatible pages",
+      type: "select",
+      hasMany: true,
+      admin: {
+        isClearable: true
+      },
+      options: options2.pages.map((slug) => {
+        return { value: slug, label: slug };
+      })
+    },
+    // !!! todo withCheckbox ?
+    {
+      name: "hasCompatibleCollections",
+      type: "checkbox",
+      admin: {
+        disabled: true
+      },
+      hooks: {
+        beforeChange: [
+          (args) => {
+            const { data } = args;
+            if (data.compatibleCollections && data.compatibleCollections.length > 0) {
+              return true;
+            } else {
+              return false;
+            }
+          }
+        ]
+      }
+    }
+  ]
+}), "Template");
+
+// src/core/api/cache.service.ts
+var CACHE_DURATION = 5 * 60 * 1e3;
+var InMemoryCache = class {
+  duration = CACHE_DURATION;
+  cache;
+  constructor(options2 = {}) {
+    this.duration = options2.duration || this.duration;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  has(key) {
+    return this.cache.has(key) && this.cache.get(key).timestamp > (/* @__PURE__ */ new Date()).getTime() - this.duration;
+  }
+  get(key) {
+    return this.cache.get(key).data;
+  }
+  set(key, data) {
+    this.cache.set(key, {
+      timestamp: (/* @__PURE__ */ new Date()).getTime(),
+      data
+    });
+  }
+};
+__name(InMemoryCache, "InMemoryCache");
+function keyWithRequest(key, req) {
+  const segments = req.url.split("?");
+  return segments.length > 1 ? `${key}-${segments[1]}` : key;
+}
+__name(keyWithRequest, "keyWithRequest");
+
+// src/core/api/collection.service.ts
+async function getCollectionItems(req, slug) {
+  const { url, query, params, payload } = req;
+  const { locale, where, sort, depth, draft, page, limit, pagination } = query;
+  const response = await payload.find({
+    collection: slug,
+    draft: draft === "true",
+    locale,
+    where,
+    sort,
+    depth: parseInt(String(depth), 10),
+    limit: 1e4,
+    pagination: false
+  });
+  const items = response.docs ? response.docs : [];
+  return items;
+}
+__name(getCollectionItems, "getCollectionItems");
+var collectionGet = /* @__PURE__ */ __name((slug) => ({
+  path: "/",
+  method: "get",
+  handler: async (req, res, next) => {
+    const { query } = req;
+    const { pagination } = query;
+    if (pagination !== "false") {
+      return next();
+    }
+    try {
+      const items = await getCollectionItems(req, slug);
+      res.status(200).send(items);
+    } catch (error) {
+      console.log("collectionGet.error", error);
+      res.status(500).send(error);
+    }
+  }
+}), "collectionGet");
+
+// src/translations.ts
+var translations = {
+  en: {
+    group: {
+      content: "Content",
+      nav: "Navigation",
+      config: "Configuration",
+      i18n: "I18N",
+      admin: "Admin"
+    },
+    collection: {
+      singular: {
+        category: "Category",
+        color: "Color",
+        country: "Country",
+        label: "Label",
+        language: "Language",
+        market: "Market",
+        media: "Media",
+        page: "Page",
+        province: "Province",
+        region: "Region",
+        template: "Template",
+        users: "User",
+        i18n_continent: "Continent",
+        i18n_country_zone: "Country Zone",
+        i18n_country: "Country",
+        i18n_language: "Language",
+        i18n_municipality: "Municipality",
+        i18n_province: "Province",
+        i18n_region: "Region",
+        i18n_sub_continent: "Subcontinent"
+      },
+      plural: {
+        category: "Categories",
+        color: "Colors",
+        country: "Countries",
+        label: "Labels",
+        language: "Languages",
+        market: "Markets",
+        media: "Medias",
+        page: "Pages",
+        province: "Provinces",
+        region: "Regions",
+        template: "Templates",
+        users: "Users",
+        i18n_continent: "Continents",
+        i18n_country_zone: "Country Zones",
+        i18n_country: "Countries",
+        i18n_language: "Languages",
+        i18n_municipality: "Municipalities",
+        i18n_province: "Provinces",
+        i18n_region: "Regions",
+        i18n_sub_continent: "Subcontinents"
+      }
+    },
+    global: {
+      locale: "Locales"
+    },
+    field: {
+      alpha2Code: "Alpha2 Code",
+      alpha3Code: "Alpha3 Code",
+      abstract: "Abstract",
+      alt: "Alt",
+      appearance: "Appearance",
+      blocks: "Blocks",
+      category: "Category",
+      category_index: "Index of Category",
+      code: "Code",
+      color: "Color",
+      compatibleCollections: "Collections",
+      content: "Content",
+      continent: "Continent",
+      countries: "Countries",
+      country: "Country",
+      countryZone: "Country Zone",
+      date: "Date",
+      description: "Description",
+      englishName: "English Name",
+      hasCompatibleCollections: "Has Compatible Collections",
+      href: "Href",
+      id: "ID",
+      isActive: "Active",
+      isDefault: "Is Default",
+      items: "Items",
+      label: "Label",
+      language: "Language",
+      languages: "Languages",
+      defaultLanguage: "Default Language",
+      link: "Link",
+      markets: "Markets",
+      media: "Media",
+      medias: "Medias",
+      name: "Name",
+      nativeName: "Native Name",
+      newTab: "New Tab",
+      price: "Price",
+      province: "Province",
+      reference: "Reference",
+      region: "Region",
+      slug: "Slug",
+      subContinent: "Subcontinent",
+      template: "Template",
+      title: "Title",
+      type: "Type",
+      url: "Url"
+    },
+    localizedField: {
+      changeLocalization: "Change localization",
+      saveDocument: "Save document to enable localizations",
+      referenceLanguage: "Reference language {{locale}}"
+    },
+    // override existing translation keys
+    general: {
+      // dashboard: 'Dashboard',
+    }
+  },
+  it: {
+    group: {
+      content: "Contenuti",
+      nav: "Navigazione",
+      config: "Configurazione",
+      i18n: "I18N",
+      admin: "Admin"
+    },
+    collection: {
+      singular: {
+        category: "Categoria",
+        color: "Colore",
+        country: "Nazione",
+        label: "Etichetta",
+        language: "Lingua",
+        market: "Mercato",
+        media: "Media",
+        page: "Pagina",
+        province: "Provincia",
+        region: "Regione",
+        template: "Template",
+        users: "Utente",
+        i18n_continent: "Continente",
+        i18n_country_zone: "Area Nazionale",
+        i18n_country: "Nazione",
+        i18n_language: "Lingua",
+        i18n_municipality: "Comune",
+        i18n_province: "Provincia",
+        i18n_region: "Regione",
+        i18n_sub_continent: "Subcontinente"
+      },
+      plural: {
+        category: "Categorie",
+        color: "Colori",
+        country: "Nazioni",
+        label: "Etichette",
+        language: "Lingue",
+        login: "Login",
+        market: "Mercati",
+        media: "Media",
+        page: "Pagine",
+        province: "Province",
+        region: "Regioni",
+        template: "Templates",
+        users: "Utenti",
+        i18n_continent: "Continenti",
+        i18n_country_zone: "Aree Nazionali",
+        i18n_country: "Nazioni",
+        i18n_language: "Lingue",
+        i18n_municipality: "Comuni",
+        i18n_province: "Province",
+        i18n_region: "Regioni",
+        i18n_sub_continent: "Subcontinenti"
+      }
+    },
+    global: {
+      locale: "Localizzazioni"
+    },
+    field: {
+      alpha2Code: "Codice Alpha2",
+      alpha3Code: "Codice Alpha3",
+      abstract: "Abstract",
+      alt: "Testo Alternativo",
+      appearance: "Aspetto",
+      blocks: "Blocchi",
+      category: "Categoria",
+      category_index: "Indice di Categoria",
+      code: "Codice",
+      color: "Colore",
+      compatibleCollections: "Collezioni",
+      content: "Contenuto",
+      continent: "Continente",
+      countries: "Nazioni",
+      country: "Nazione",
+      countryZone: "Area Nazionale",
+      date: "Data",
+      description: "Descrizione",
+      englishName: "Nome Inglese",
+      hasCompatibleCollections: "Ha Collezioni Compatibili",
+      href: "Href",
+      id: "ID",
+      isActive: "Attivo",
+      isDefault: "Valore di Default",
+      items: "Elementi",
+      label: "Etichetta",
+      language: "Lingua",
+      languages: "Lingue",
+      defaultLanguage: "Lingua di Default",
+      link: "Link",
+      markets: "Mercati",
+      media: "Media",
+      medias: "Media",
+      name: "Nome",
+      nativeName: "Nome Nativo",
+      newTab: "Nuovo Tab",
+      price: "Prezzo",
+      province: "Provincia",
+      reference: "Riferimento",
+      region: "Regione",
+      slug: "Slug",
+      subContinent: "Subcontinente",
+      template: "Template",
+      title: "Titolo",
+      type: "Tipo",
+      url: "Url"
+    },
+    localizedField: {
+      changeLocalization: "Modifica localizzazione",
+      saveDocument: "Salva il documento per abilitare le modifiche",
+      referenceLanguage: "Lingua di riferimento {{locale}}"
+    },
+    // override existing translation keys
+    general: {
+      // dashboard: 'Dashboard',
+    }
+  }
+};
+
+// src/options.ts
+var defaultSlug = {
+  category: "category",
+  label: "label",
+  locale: "locale",
+  market: "market",
+  media: "media",
+  page: "page",
+  template: "template",
+  //
+  continent: "i18n_continent",
+  country: "i18n_country",
+  countryZone: "i18n_country_zone",
+  language: "i18n_language",
+  municipality: "i18n_municipality",
+  province: "i18n_province",
+  region: "i18n_region",
+  subContinent: "i18n_sub_continent"
+};
+var defaultGroup = {
+  content: "content",
+  nav: "nav",
+  config: "config",
+  i18n: "i18n",
+  admin: "admin"
+};
+var defaultLocales = ["en", "it"];
+var defaultLocale = "en";
+var options = {
+  collections: [],
+  defaultLocale,
+  group: defaultGroup,
+  locales: defaultLocales,
+  pages: [],
+  slug: defaultSlug,
+  translations
+};
+var internalSlugs = Object.entries(defaultSlug).map((x) => x[1]);
+
+// src/fields/ui-languages/UILanguagesCell.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var UILanguagesCell = /* @__PURE__ */ __name(({ cellData, colIndex, collection, field, rowData }) => {
+  if (!cellData)
+    return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: cellData.toString() });
+}, "UILanguagesCell");
+
+// src/fields/ui-languages/UILanguagesField.tsx
+var import_utilities = require("payload/components/utilities");
+var import_qs2 = __toESM(require("qs"));
+var import_react_router_dom2 = require("react-router-dom");
+
+// src/fields/ui-languages/useSearchParams.tsx
+var import_qs = __toESM(require("qs"));
+var import_react = require("react");
+var import_react_router_dom = require("react-router-dom");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var Context = (0, import_react.createContext)({});
+var useSearchParams = /* @__PURE__ */ __name(() => {
+  const location = (0, import_react_router_dom.useLocation)();
+  const params = import_qs.default.parse(
+    location.search,
+    { ignoreQueryPrefix: true, depth: 10 }
+  );
+  return params;
+}, "useSearchParams");
+
+// src/fields/ui-languages/UILanguagesField.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var baseClass = "ui-languages";
+var UILanguagesField = /* @__PURE__ */ __name((props) => {
+  const searchParams = useSearchParams();
+  const { localization } = (0, import_utilities.useConfig)();
+  const currentLocale = (0, import_utilities.useLocale)();
+  const locales = localization ? localization.locales : [];
+  const otherLocales = locales.filter((x) => x !== currentLocale);
+  const documentInfo = (0, import_utilities.useDocumentInfo)();
+  if (!localization) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: `${baseClass}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: `${baseClass}__head`, children: [
+      documentInfo.id ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: `${baseClass}__badge`, children: documentInfo.id }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: `${baseClass}__badge`, children: "Unsaved document" }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: `${baseClass}__badge uppercase`, children: currentLocale })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: `${baseClass}__locales`, children: otherLocales.map((locale) => {
+      const newParams = {
+        ...searchParams,
+        locale
+      };
+      const search = import_qs2.default.stringify(newParams);
+      return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_router_dom2.Link, { className: "btn", to: { search }, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "btn__label", children: locale }) }, locale);
+    }) })
+  ] });
+}, "UILanguagesField");
+
+// src/fields/ui-languages/index.ts
+var withUILanguages = /* @__PURE__ */ __name((options2 = {}) => {
+  const baseOptions = {
+    name: "uiLanguages",
+    type: "ui",
+    admin: {
+      components: {
+        Field: UILanguagesField,
+        Cell: UILanguagesCell
+      }
+    }
+  };
+  return deepMerge(
+    baseOptions,
+    options2
+  );
+}, "withUILanguages");
+
+// src/fields/localized-field/LocalizedField.tsx
+var import_modal2 = require("@faceless-ui/modal");
+var import_components2 = require("payload/components");
+var import_utilities5 = require("payload/components/utilities");
+var import_react7 = require("react");
+var import_react_i18next5 = require("react-i18next");
+
+// src/fields/localized-field/LocalizedFieldModal.tsx
+var import_modal = require("@faceless-ui/modal");
+var import_components = require("payload/components");
+var import_forms4 = require("payload/components/forms");
+var import_utilities4 = require("payload/components/utilities");
+var import_field_types = __toESM(require("payload/dist/admin/components/forms/field-types"));
+var import_react6 = require("react");
+var import_react_i18next4 = require("react-i18next");
+var import_react_toastify = require("react-toastify");
+
+// src/fields/localized-field/Publish/Publish.tsx
+var import_forms = require("payload/components/forms");
+var import_utilities2 = require("payload/components/utilities");
+var import_Submit = __toESM(require("payload/dist/admin/components/forms/Submit"));
+var import_react2 = require("react");
+var import_react_i18next = require("react-i18next");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var Publish = /* @__PURE__ */ __name(() => {
+  const { unpublishedVersions, publishedDoc } = (0, import_utilities2.useDocumentInfo)();
+  const { submit } = (0, import_forms.useForm)();
+  const modified = (0, import_forms.useFormModified)();
+  const { t } = (0, import_react_i18next.useTranslation)("version");
+  const hasNewerVersions = unpublishedVersions?.totalDocs > 0;
+  const canPublish = modified || hasNewerVersions || !publishedDoc;
+  const publish = (0, import_react2.useCallback)(() => {
+    submit({
+      overrides: {
+        _status: "published"
+      }
+    });
+  }, [submit]);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_Submit.default, { type: "button", disabled: !canPublish, onClick: publish, children: t("publishChanges") });
+}, "Publish");
+
+// src/fields/localized-field/RichTextSerializer.tsx
+var import_escape_html = __toESM(require("escape-html"));
+var import_react3 = require("react");
+var import_slate = require("slate");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var baseClass2 = "wysiwyg";
+var RichTextSerializer = /* @__PURE__ */ __name(({ value }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: baseClass2, children: Serializer(value) });
+}, "RichTextSerializer");
+function Serializer(children) {
+  return children.map((node, i) => {
+    if (import_slate.Text.isText(node)) {
+      let text = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { dangerouslySetInnerHTML: { __html: (0, import_escape_html.default)(node.text) } });
+      if (node.bold) {
+        text = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("strong", { children: text }, i);
+      }
+      if (node.code) {
+        text = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("code", { children: text }, i);
+      }
+      if (node.italic) {
+        text = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("em", { children: text }, i);
+      }
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react3.Fragment, { children: text }, i);
+    }
+    if (!node) {
+      return null;
+    }
+    switch (node.type) {
+      case "h1":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("h1", { children: Serializer(node.children) }, i);
+      case "h6":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("h6", { children: Serializer(node.children) }, i);
+      case "quote":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("blockquote", { children: Serializer(node.children) }, i);
+      case "ul":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("ul", { children: Serializer(node.children) }, i);
+      case "ol":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("ol", { children: Serializer(node.children) }, i);
+      case "li":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("li", { children: Serializer(node.children) }, i);
+      case "link":
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+          "a",
+          {
+            href: (0, import_escape_html.default)(node.url),
+            children: Serializer(node.children)
+          },
+          i
+        );
+      default:
+        return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("p", { children: Serializer(node.children) }, i);
+    }
+  });
+}
+__name(Serializer, "Serializer");
+
+// src/fields/localized-field/Save/Save.tsx
+var import_forms2 = require("payload/components/forms");
+var import_Submit2 = __toESM(require("payload/dist/admin/components/forms/Submit"));
+var import_react4 = require("react");
+var import_react_i18next2 = require("react-i18next");
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var Save = /* @__PURE__ */ __name(() => {
+  const { submit } = (0, import_forms2.useForm)();
+  const modified = (0, import_forms2.useFormModified)();
+  const { t } = (0, import_react_i18next2.useTranslation)("general");
+  const canSave = modified;
+  const publish = (0, import_react4.useCallback)(() => {
+    submit();
+  }, [submit]);
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_Submit2.default, { type: "button", disabled: !canSave, onClick: publish, children: t("save") });
+}, "Save");
+
+// src/fields/localized-field/SaveDraft/SaveDraft.tsx
+var import_forms3 = require("payload/components/forms");
+var import_utilities3 = require("payload/components/utilities");
+var import_Submit3 = __toESM(require("payload/dist/admin/components/forms/Submit"));
+var import_react5 = require("react");
+var import_react_i18next3 = require("react-i18next");
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var baseClass3 = "save-draft";
+var SaveDraft = /* @__PURE__ */ __name(() => {
+  const { serverURL, routes: { api } } = (0, import_utilities3.useConfig)();
+  const { submit } = (0, import_forms3.useForm)();
+  const { collection, global, id } = (0, import_utilities3.useDocumentInfo)();
+  const modified = (0, import_forms3.useFormModified)();
+  const { t } = (0, import_react_i18next3.useTranslation)("version");
+  const locale = (0, import_utilities3.useLocale)();
+  const canSaveDraft = modified;
+  const saveDraft = (0, import_react5.useCallback)(() => {
+    const search = `?locale=${locale}&depth=0&fallback-locale=null&draft=true`;
+    let action;
+    let method = "POST";
+    if (collection) {
+      action = `${serverURL}${api}/${collection.slug}${id ? `/${id}` : ""}${search}`;
+      if (id)
+        method = "PATCH";
+    }
+    if (global) {
+      action = `${serverURL}${api}/globals/${global.slug}${search}`;
+    }
+    submit({
+      action,
+      method,
+      skipValidation: true,
+      overrides: {
+        _status: "draft"
+      }
+    });
+  }, [submit, collection, global, serverURL, api, locale, id]);
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_Submit3.default, { className: baseClass3, type: "button", buttonStyle: "secondary", disabled: !canSaveDraft, onClick: saveDraft, children: t("saveDraft") });
+}, "SaveDraft");
+
+// src/fields/localized-field/LocalizedFieldModal.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var DEBUG = false;
+var baseClass4 = "localized-field";
+var getTranslation = /* @__PURE__ */ __name((label, i18n) => {
+  if (typeof label === "object") {
+    if (label[i18n.language]) {
+      return label[i18n.language];
+    }
+    let fallbacks = [];
+    if (typeof i18n.options.fallbackLng === "string") {
+      fallbacks = [i18n.options.fallbackLng];
+    } else if (Array.isArray(i18n.options.fallbackLng)) {
+      fallbacks = i18n.options.fallbackLng;
+    } else if (typeof i18n.options.fallbackLng === "object") {
+      fallbacks = Object.keys(i18n.options.fallbackLng);
+    } else if (typeof i18n.options.fallbackLng === "function") {
+      console.warn("Use of i18next fallbackLng functions are not supported.");
+    }
+    return label[fallbacks.find((language) => label[language])] ?? label[Object.keys(label)[0]];
+  }
+  return label;
+}, "getTranslation");
+var LocalizedFieldModal = /* @__PURE__ */ __name((schema) => {
+  const { t } = (0, import_react_i18next4.useTranslation)("localizedField");
+  const { path, label } = schema;
+  const { closeAllModals } = (0, import_modal.useModal)();
+  const { i18n } = (0, import_react_i18next4.useTranslation)();
+  const config = (0, import_utilities4.useConfig)();
+  const locales = config.localization ? config.localization.locales : [];
+  const defaultLocale2 = config.localization ? config.localization.defaultLocale : null;
+  const initialLocale = (0, import_utilities4.useLocale)();
+  const documentInfo = (0, import_utilities4.useDocumentInfo)();
+  const { id, collection, global } = documentInfo;
+  const field = (0, import_forms4.useFormFields)(([fields]) => fields[path]);
+  const dispatchField = (0, import_forms4.useFormFields)(([_, dispatch]) => dispatch);
+  const [referenceValue, setReferenceValue] = (0, import_react6.useState)(field.value);
+  const [referenceLocale, setReferenceLocale] = (0, import_react6.useState)(initialLocale);
+  const [currentLocale, setCurrentLocale] = (0, import_react6.useState)(initialLocale);
+  const [initialJson, setInitialJson] = (0, import_react6.useState)(null);
+  const [currentJson, setCurrentJson] = (0, import_react6.useState)({});
+  const [emptyLocales, setEmptyLocales] = (0, import_react6.useState)([]);
+  const [filledInLocales, setFilledInLocales] = (0, import_react6.useState)([]);
+  const FieldComponent = import_field_types.default[schema.type];
+  const saveLocale = /* @__PURE__ */ __name(async (locale, json = currentJson, status = "draft") => {
+    try {
+      const search = `?depth=0&locale=${locale}&fallback-locale=null${status === "draft" ? "&draft=true" : ""}`;
+      let url;
+      if (collection) {
+        url = `${config.serverURL}${config.routes.api}/${collection.slug}/${id}${search}`;
+      }
+      if (global) {
+        url = `${config.serverURL}${config.routes.api}/globals/${global.slug}${search}`;
+      }
+      const httpGetResponse = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (!httpGetResponse.ok) {
+        throw httpGetResponse;
+      }
+      const localizedDocument = await httpGetResponse.json();
+      const payload = setPathPayload(path, localizedDocument, json[locale]);
+      payload._status = status;
+      if (DEBUG) {
+        console.log("LocalizedFieldModal.saveLocale", path, url, payload);
+        return payload;
+      }
+      const httpResponse = await fetch(url, {
+        method: "PATCH",
+        body: JSON.stringify(payload),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (!httpResponse.ok) {
+        throw httpResponse;
+      }
+      const response = await httpResponse.json();
+      return response;
+    } catch (error) {
+      console.log("LocalizedFieldModal.saveLocale.error", error);
+    }
+  }, "saveLocale");
+  const localeDidChange = /* @__PURE__ */ __name((locale, json = currentJson) => {
+    if (json[locale] === initialJson[locale]) {
+      return false;
+    }
+    return true;
+  }, "localeDidChange");
+  (0, import_react6.useEffect)(() => {
+    const getData = /* @__PURE__ */ __name(async () => {
+      try {
+        const search = "?depth=0&locale=*&draft=true";
+        let url;
+        if (collection) {
+          url = `${config.serverURL}${config.routes.api}/${collection.slug}/${id}${search}`;
+        }
+        if (global) {
+          url = `${config.serverURL}${config.routes.api}/globals/${global.slug}${search}`;
+        }
+        const httpResponse = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+        if (!httpResponse.ok) {
+          throw httpResponse;
+        }
+        const document = await httpResponse.json();
+        const json = getPathValue(path, document) || {};
+        json[initialLocale] = field.value;
+        setInitialJson(json);
+        setCurrentJson(json);
+        const emptyLocales2 = locales.filter((locale) => {
+          return json[locale] === void 0;
+        });
+        sortByLocale(emptyLocales2, initialLocale);
+        setEmptyLocales(emptyLocales2);
+        const filledInLocales2 = locales.filter((locale) => {
+          return json[locale] !== void 0;
+        });
+        sortByLocale(filledInLocales2, initialLocale);
+        setFilledInLocales(filledInLocales2);
+        const reference = getReference(json, defaultLocale2, initialLocale, locales);
+        setReferenceValue(reference.value);
+        setReferenceLocale(reference.locale);
+      } catch (error) {
+        console.log("LocalizedFieldModal.error", error);
+      }
+    }, "getData");
+    getData();
+  }, []);
+  const onChangeSelectedLocale = /* @__PURE__ */ __name(async (locale) => {
+    setCurrentLocale(locale);
+  }, "onChangeSelectedLocale");
+  const onAddSelectedLocale = /* @__PURE__ */ __name(async (locale) => {
+    const filledIns = [...filledInLocales];
+    filledIns.push(locale);
+    sortByLocale(filledIns, initialLocale);
+    setFilledInLocales(filledIns);
+    const empties = [...emptyLocales];
+    empties.splice(empties.indexOf(locale), 1);
+    setEmptyLocales(empties);
+    sortByLocale(empties, initialLocale);
+    setCurrentLocale(locale);
+  }, "onAddSelectedLocale");
+  const onSubmit = /* @__PURE__ */ __name(async (fields, data) => {
+    const json = currentJson;
+    if (localeDidChange(initialLocale, json)) {
+      dispatchField({
+        type: "UPDATE",
+        path,
+        value: json[initialLocale]
+      });
+    }
+    try {
+      const promises = locales.filter((x) => localeDidChange(x, json)).map((x) => () => saveLocale(x, json, data._status));
+      const responses = [];
+      for (const promise of promises) {
+        const response = await promise();
+        responses.push(response);
+      }
+      import_react_toastify.toast.success(data._status === "draft" ? "Draft saved successfully." : "Updated successfully.");
+      closeAllModals();
+    } catch (error) {
+      import_react_toastify.toast.error(`There was an error while saving ${collection ? `${collection.slug} ${id}` : global.slug}.`);
+    }
+  }, "onSubmit");
+  const onClose = /* @__PURE__ */ __name(() => {
+    closeAllModals();
+  }, "onClose");
+  const initialFormData = (0, import_react6.useMemo)(() => currentJson, [currentLocale, initialJson]);
+  const fieldOptions = (0, import_react6.useMemo)(() => ({
+    ...schema,
+    validate: (value, args) => {
+      if (args.operation === "update") {
+        setCurrentJson(args.siblingData);
+      }
+      if (typeof schema.validate === "function") {
+        return schema.validate(value, args);
+      }
+      return true;
+    },
+    path: currentLocale,
+    fieldTypes: import_field_types.default
+  }), [currentLocale, initialJson]);
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_components.MinimalTemplate, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("header", { className: `${baseClass4}__header`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("h3", { children: [
+        label && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { children: getTranslation(label, i18n) }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: `${baseClass4}__locale`, children: initialLocale }),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("path", { d: "M7.961 7.5h1.303l2.47 6.5h-1.349l-.538-1.5h-2.438l-.535 1.5h-1.392l2.479-6.5zm1.517 3.965l-.857-2.451-.851 2.451h1.708zm8.092-1.402c.062-.243.1-.426.135-.605l-1.1-.214-.109.5c-.371-.054-.767-.061-1.166-.021.009-.268.025-.531.049-.784h1.229v-1.042h-1.081c.054-.265.099-.424.144-.575l-1.074-.322c-.079.263-.145.521-.211.897h-1.226v1.042h1.092c-.028.337-.046.686-.051 1.038-1.207.443-1.719 1.288-1.719 2.054 0 .904.714 1.7 1.842 1.598 1.401-.128 2.337-1.186 2.885-2.487.567.327.805.876.591 1.385-.197.471-.78.919-1.892.896v1.121c1.234.019 2.448-.45 2.925-1.583.465-1.108-.066-2.318-1.263-2.898zm-1.446.766c-.175.387-.404.771-.697 1.075-.045-.323-.076-.676-.093-1.054.268-.035.537-.041.79-.021zm-1.894.362c.03.473.084.909.158 1.298-.997.183-1.037-.801-.158-1.298zm-2.23-8.191c5.514 0 10 3.592 10 8.007 0 4.917-5.145 7.961-9.91 7.961-1.937 0-3.384-.397-4.394-.644-1 .613-1.594 1.037-4.272 1.82.535-1.373.722-2.748.601-4.265-.837-1-2.025-2.4-2.025-4.872 0-4.415 4.486-8.007 10-8.007zm0-2c-6.338 0-12 4.226-12 10.007 0 2.05.739 4.063 2.047 5.625.055 1.83-1.023 4.456-1.993 6.368 2.602-.47 6.301-1.508 7.978-2.536 1.417.345 2.774.503 4.059.503 7.083 0 11.91-4.837 11.91-9.961-.001-5.811-5.702-10.006-12.001-10.006z" }) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_components.Button, { buttonStyle: "none", onClick: onClose, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_components.X, {}) })
+    ] }),
+    initialJson ? /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("main", { className: `${baseClass4}__main`, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_forms4.Form, { onSubmit, initialData: initialFormData, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: `${baseClass4}__locales`, children: [
+        filledInLocales.map((locale) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_components.Button, { className: locale === currentLocale ? "active filled" : "filled", buttonStyle: "none", onClick: () => onChangeSelectedLocale(locale), children: locale }, locale)),
+        emptyLocales.map((locale) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_components.Button, { className: locale === currentLocale ? "active empty" : "empty", buttonStyle: "none", onClick: () => onAddSelectedLocale(locale), children: locale }, locale))
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(FieldComponent, { ...fieldOptions }, currentLocale),
+      referenceValue && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+        (schema.type === "text" || schema.type === "richText") && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: `${baseClass4}__reference`, children: t("referenceLanguage", { locale: referenceLocale.toUpperCase() }) }),
+        schema.type === "text" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: `${baseClass4}__preview`, children: referenceValue }),
+        schema.type === "richText" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: `${baseClass4}__preview`, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(RichTextSerializer, { value: referenceValue }) })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("div", { className: `${baseClass4}__foot`, children: collection?.versions?.drafts || global?.versions?.drafts ? /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_jsx_runtime8.Fragment, { children: [
+        !(collection?.versions?.drafts && collection.versions.drafts.autosave) && !(global?.versions?.drafts && global.versions.drafts.autosave) && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(SaveDraft, {}),
+        /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Publish, {})
+      ] }) : /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Save, {}) })
+    ] }) }) : null
+  ] });
+}, "LocalizedFieldModal");
+function getReference(json, defaultLocale2, initialLocale, locales) {
+  const reference = { locale: initialLocale, value: json[initialLocale] };
+  if (!json[initialLocale]) {
+    if (json[defaultLocale2]) {
+      reference.locale = defaultLocale2;
+      reference.value = json[defaultLocale2];
+    } else {
+      const fallbackLocale = locales.find((l) => json[l]);
+      if (fallbackLocale) {
+        reference.locale = fallbackLocale;
+        reference.value = json[fallbackLocale];
+      }
+    }
+  }
+  return reference;
+}
+__name(getReference, "getReference");
+function getPathValue(pathOrPaths, object) {
+  const paths = Array.isArray(pathOrPaths) ? pathOrPaths : pathOrPaths.split(".");
+  if (paths.length === 1) {
+    return object[paths[0]];
+  } else {
+    const path = paths.shift();
+    return getPathValue(paths, object[path]);
+  }
+}
+__name(getPathValue, "getPathValue");
+function setPathPayload(pathOrPaths, object, value, payload = {}) {
+  const paths = Array.isArray(pathOrPaths) ? pathOrPaths : pathOrPaths.split(".");
+  if (paths.length === 1) {
+    const leafPath = paths[0];
+    if (Array.isArray(value)) {
+      payload[leafPath] = [...value];
+    } else if (typeof value === "object") {
+      payload[leafPath] = { ...value };
+    } else if (value != null) {
+      payload[leafPath] = value;
+    }
+  } else {
+    const path = paths.shift();
+    const subObject = object[path];
+    let subPayload;
+    if (Array.isArray(subObject)) {
+      subPayload = [...subObject];
+    } else if (typeof subObject === "object") {
+      subPayload = { ...subObject };
+    } else {
+      throw "invalid data";
+    }
+    payload[path] = subPayload;
+    setPathPayload(paths, subObject, value, subPayload);
+  }
+  return payload;
+}
+__name(setPathPayload, "setPathPayload");
+function sortByLocale(locales, locale) {
+  locales.sort((a, b) => {
+    if (a === locale) {
+      return -1;
+    } else if (b === locale) {
+      return 1;
+    } else {
+      return a.localeCompare(b);
+    }
+  });
+}
+__name(sortByLocale, "sortByLocale");
+
+// src/fields/localized-field/LocalizedField.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var baseClass5 = "localized-field";
+var LocalizedField = /* @__PURE__ */ __name((props) => {
+  const { t } = (0, import_react_i18next5.useTranslation)("localizedField");
+  const schema = (0, import_react7.useMemo)(() => {
+    const schema2 = { ...props };
+    schema2.admin = { ...schema2.admin, components: {} };
+    return schema2;
+  }, []);
+  const { path } = schema;
+  const locale = (0, import_utilities5.useLocale)();
+  const documentInfo = (0, import_utilities5.useDocumentInfo)();
+  const { openModal, isModalOpen } = (0, import_modal2.useModal)();
+  const modalKey = `${locale}-localized-field-modal-${path}`;
+  const isModalOpened = isModalOpen(modalKey);
+  const FieldComponent = schema.fieldTypes[schema.type];
+  const fieldKey = `${locale}-localized-field-${path}-${isModalOpened ? "opened" : "closed"}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(FieldComponent, { ...schema }, fieldKey),
+    documentInfo.id ? /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: baseClass5, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_components2.Button, { className: "btn--localize", buttonStyle: "none", onClick: () => openModal(modalKey), children: [
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: `${baseClass5}__locale`, children: locale }),
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("path", { d: "M7.961 7.5h1.303l2.47 6.5h-1.349l-.538-1.5h-2.438l-.535 1.5h-1.392l2.479-6.5zm1.517 3.965l-.857-2.451-.851 2.451h1.708zm8.092-1.402c.062-.243.1-.426.135-.605l-1.1-.214-.109.5c-.371-.054-.767-.061-1.166-.021.009-.268.025-.531.049-.784h1.229v-1.042h-1.081c.054-.265.099-.424.144-.575l-1.074-.322c-.079.263-.145.521-.211.897h-1.226v1.042h1.092c-.028.337-.046.686-.051 1.038-1.207.443-1.719 1.288-1.719 2.054 0 .904.714 1.7 1.842 1.598 1.401-.128 2.337-1.186 2.885-2.487.567.327.805.876.591 1.385-.197.471-.78.919-1.892.896v1.121c1.234.019 2.448-.45 2.925-1.583.465-1.108-.066-2.318-1.263-2.898zm-1.446.766c-.175.387-.404.771-.697 1.075-.045-.323-.076-.676-.093-1.054.268-.035.537-.041.79-.021zm-1.894.362c.03.473.084.909.158 1.298-.997.183-1.037-.801-.158-1.298zm-2.23-8.191c5.514 0 10 3.592 10 8.007 0 4.917-5.145 7.961-9.91 7.961-1.937 0-3.384-.397-4.394-.644-1 .613-1.594 1.037-4.272 1.82.535-1.373.722-2.748.601-4.265-.837-1-2.025-2.4-2.025-4.872 0-4.415 4.486-8.007 10-8.007zm0-2c-6.338 0-12 4.226-12 10.007 0 2.05.739 4.063 2.047 5.625.055 1.83-1.023 4.456-1.993 6.368 2.602-.47 6.301-1.508 7.978-2.536 1.417.345 2.774.503 4.059.503 7.083 0 11.91-4.837 11.91-9.961-.001-5.811-5.702-10.006-12.001-10.006z" }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { children: t("changeLocalization") })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_modal2.Modal, { slug: modalKey, className: `${baseClass5}__modal`, children: isModalOpened && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(LocalizedFieldModal, { ...schema }) })
+    ] }) : /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { className: baseClass5, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_components2.Button, { className: "btn--localize", buttonStyle: "none", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: `${baseClass5}__locale`, children: locale }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("svg", { xmlns: "http://www.w3.org/2000/svg", width: "24", height: "24", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("path", { d: "M7.961 7.5h1.303l2.47 6.5h-1.349l-.538-1.5h-2.438l-.535 1.5h-1.392l2.479-6.5zm1.517 3.965l-.857-2.451-.851 2.451h1.708zm8.092-1.402c.062-.243.1-.426.135-.605l-1.1-.214-.109.5c-.371-.054-.767-.061-1.166-.021.009-.268.025-.531.049-.784h1.229v-1.042h-1.081c.054-.265.099-.424.144-.575l-1.074-.322c-.079.263-.145.521-.211.897h-1.226v1.042h1.092c-.028.337-.046.686-.051 1.038-1.207.443-1.719 1.288-1.719 2.054 0 .904.714 1.7 1.842 1.598 1.401-.128 2.337-1.186 2.885-2.487.567.327.805.876.591 1.385-.197.471-.78.919-1.892.896v1.121c1.234.019 2.448-.45 2.925-1.583.465-1.108-.066-2.318-1.263-2.898zm-1.446.766c-.175.387-.404.771-.697 1.075-.045-.323-.076-.676-.093-1.054.268-.035.537-.041.79-.021zm-1.894.362c.03.473.084.909.158 1.298-.997.183-1.037-.801-.158-1.298zm-2.23-8.191c5.514 0 10 3.592 10 8.007 0 4.917-5.145 7.961-9.91 7.961-1.937 0-3.384-.397-4.394-.644-1 .613-1.594 1.037-4.272 1.82.535-1.373.722-2.748.601-4.265-.837-1-2.025-2.4-2.025-4.872 0-4.415 4.486-8.007 10-8.007zm0-2c-6.338 0-12 4.226-12 10.007 0 2.05.739 4.063 2.047 5.625.055 1.83-1.023 4.456-1.993 6.368 2.602-.47 6.301-1.508 7.978-2.536 1.417.345 2.774.503 4.059.503 7.083 0 11.91-4.837 11.91-9.961-.001-5.811-5.702-10.006-12.001-10.006z" }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { children: t("saveDocument") })
+    ] }) })
+  ] });
+}, "LocalizedField");
+
+// src/fields/localized-field/index.ts
+var localizedField = /* @__PURE__ */ __name((options2) => {
+  const baseOptions = {
+    localized: true,
+    admin: {
+      components: {
+        Field: LocalizedField
+      }
+    }
+  };
+  return deepMerge(
+    baseOptions,
+    options2
+  );
+}, "localizedField");
+var withLocalized = /* @__PURE__ */ __name((config, first = true) => {
+  Object.keys(config).forEach((key) => {
+    if (typeof config[key] === "object") {
+      if (config[key].localized === true) {
+        config[key] = localizedField(config[key]);
+      } else {
+        config[key] = withLocalized(config[key], false);
+      }
+    }
+  });
+  if (first && Array.isArray(config.fields)) {
+    if (!config.fields.find((x) => x.type === "ui" && x.name === "uiLanguages")) {
+      config.fields.unshift(
+        withUILanguages()
+      );
+    }
+  }
+  return config;
+}, "withLocalized");
+
+// src/core/translations/translations.ts
+var missingTranslations = [];
+function getTranslation2(path, defaultText, locale, node, fullPath) {
+  node = node || options.translations[locale];
+  fullPath = fullPath || path;
+  if (path.indexOf(".") !== -1) {
+    const paths = path.split(".");
+    const key = paths.shift();
+    path = paths.join(".");
+    return getTranslation2(path, defaultText, locale, node[key] || {}, fullPath);
+  }
+  if (!node[path] && missingTranslations.indexOf(fullPath) === -1) {
+    missingTranslations.push(fullPath);
+  }
+  return node[path] || defaultText || "";
+}
+__name(getTranslation2, "getTranslation");
+function getTranslations(path, defaultText) {
+  defaultText = defaultText || path;
+  const localizedText = {};
+  options.locales.forEach((locale) => {
+    localizedText[locale] = getTranslation2(path, defaultText, locale);
+  });
+  return localizedText;
+}
+__name(getTranslations, "getTranslations");
+function slugToLabels(slug) {
+  return {
+    singular: getTranslations(`collection.singular.${slug}`, slug),
+    plural: getTranslations(`collection.plural.${slug}`, slug)
+  };
+}
+__name(slugToLabels, "slugToLabels");
+function slugToLabel(slug) {
+  return getTranslations(`global.${slug}`, slug);
+}
+__name(slugToLabel, "slugToLabel");
+function translateTab(tab) {
+  if (tab.label === false) {
+    return tab;
+  }
+  if (typeof tab.label === "object") {
+    return tab;
+  }
+  const label = tab.name || tab.label;
+  if (label) {
+    tab.label = getTranslations(`field.${label}`);
+  }
+  tab.fields = translateFields(tab.fields);
+  return tab;
+}
+__name(translateTab, "translateTab");
+function translateTabs(tabs) {
+  tabs = tabs.map((tab) => translateTab(tab));
+  return tabs;
+}
+__name(translateTabs, "translateTabs");
+function translateBlock(block) {
+  block.labels = slugToLabels(block.slug);
+  block.fields = translateFields(block.fields);
+  return block;
+}
+__name(translateBlock, "translateBlock");
+function translateBlocks(blocks) {
+  blocks = blocks.map((block) => translateBlock(block));
+  return blocks;
+}
+__name(translateBlocks, "translateBlocks");
+function translateField(field) {
+  if (field.type === "ui") {
+    return field;
+  }
+  if (typeof field.label === "object") {
+    return field;
+  }
+  if (field.label === false) {
+    return field;
+  }
+  const label = field["name"] || field.label;
+  if (label) {
+    field.label = getTranslations(`field.${label}`);
+  }
+  switch (field.type) {
+    case "tabs":
+      break;
+    case "group":
+    case "array":
+    case "row":
+      field.fields = translateFields(field.fields);
+      break;
+    case "blocks":
+      field.blocks = translateBlocks(field.blocks);
+      break;
+  }
+  return field;
+}
+__name(translateField, "translateField");
+function translateFields(fields) {
+  fields = fields.map((field) => translateField(field));
+  return fields;
+}
+__name(translateFields, "translateFields");
+function translateCollection(config) {
+  config.labels = slugToLabels(config.slug);
+  config.fields = translateFields(config.fields);
+  if (config.admin && config.admin.group && typeof config.admin.group === "string") {
+    config.admin.group = getTranslations(`group.${config.admin.group}`);
+  }
+  return config;
+}
+__name(translateCollection, "translateCollection");
+function translateGlobal(config) {
+  config.label = slugToLabel(config.slug);
+  config.fields = translateFields(config.fields);
+  if (config.admin && config.admin.group && typeof config.admin.group === "string") {
+    config.admin.group = getTranslations(`group.${config.admin.group}`);
+  }
+  return config;
+}
+__name(translateGlobal, "translateGlobal");
+function logMissingTranslations() {
+  missingTranslations.sort();
+  missingTranslations.forEach((missing) => console.warn(`missing translation ${missing}`));
+}
+__name(logMissingTranslations, "logMissingTranslations");
+
+// src/core/utils/deepMerge.ts
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+__name(isObject, "isObject");
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isObject(source[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: source[key] });
+        } else {
+          output[key] = deepMerge(target[key], source[key]);
+        }
+      } else {
+        Object.assign(output, { [key]: source[key] });
+      }
+    });
+  }
+  return output;
+}
+__name(deepMerge, "deepMerge");
+
+// src/core/utils/formatSlug.ts
+var format = /* @__PURE__ */ __name((val) => val.replace(/ /g, "-").replace(/[^\w-]+/g, "").toLowerCase(), "format");
+var formatSlug = /* @__PURE__ */ __name((fallback) => ({ value, originalDoc, data }) => {
+  if (typeof value === "string") {
+    return format(value);
+  }
+  const fallbackData = data && data[fallback] || originalDoc && originalDoc[fallback];
+  if (fallbackData && typeof fallbackData === "string") {
+    return format(fallbackData);
+  }
+  return value;
+}, "formatSlug");
+
+// src/core/utils/hooks.ts
+function withCollectionHook(config, name, hook) {
+  const hooks = config.hooks || {};
+  const list = hooks[name] || [];
+  list.push(hook);
+  hooks[name] = list;
+  config.hooks = hooks;
+  return config;
+}
+__name(withCollectionHook, "withCollectionHook");
+function withGlobalHook(config, name, hook) {
+  const hooks = config.hooks || {};
+  const list = hooks[name] || [];
+  list.push(hook);
+  hooks[name] = list;
+  config.hooks = hooks;
+  return config;
+}
+__name(withGlobalHook, "withGlobalHook");
+function withFieldHook(field, name, hook) {
+  const hooks = field.hooks || {};
+  const list = hooks[name] || [];
+  list.push(hook);
+  hooks[name] = list;
+  field.hooks = hooks;
+  return field;
+}
+__name(withFieldHook, "withFieldHook");
+
+// src/core/utils/syncPages.ts
+var afterPageChangeHook = /* @__PURE__ */ __name(async ({
+  doc,
+  // full document data
+  req,
+  // full express request
+  previousDoc,
+  // document data before updating the collection
+  operation
+  // name of the operation ie. 'create', 'update'
+}) => {
+  if (operation === "create") {
+    const pages = await req.payload.find({
+      collection: "page",
+      where: { "content.value": { equals: doc.id } }
+    });
+    if (pages.totalDocs == 0) {
+      await req.payload.create({
+        collection: "page",
+        data: {
+          content: {
+            value: doc.id,
+            relationTo: req.collection.config.slug
+          }
+        }
+      });
+    }
+  }
+  return doc;
+}, "afterPageChangeHook");
+var afterPageDeleteHook = /* @__PURE__ */ __name(async ({
+  req,
+  // full express request
+  id,
+  // id of document to delete
+  doc
+  // deleted document
+}) => {
+  const pages = await req.payload.find({
+    collection: "page",
+    where: { "content.value": { equals: id } }
+  });
+  if (pages.totalDocs > 0) {
+    pages.docs.map(async ({ id: pageId }) => {
+      await req.payload.delete({
+        collection: "page",
+        id: pageId
+      });
+    });
+  }
+}, "afterPageDeleteHook");
+
+// src/core/collections/withBlock.ts
+var BlockDefaults = {};
+var withBlock = /* @__PURE__ */ __name((options2) => {
+  const blockConfig = deepMerge({
+    ...BlockDefaults
+  }, options2);
+  delete blockConfig["type"];
+  translateCollection(blockConfig);
+  return withLocalized(blockConfig);
+}, "withBlock");
+
+// src/core/collections/withStaticCollection.ts
+var import_axios = __toESM(require("axios"));
+var staticCollections = [];
+var staticCollectionLoaders = {};
+var ID = 0;
+var CACHE = {};
+async function getCollection(url) {
+  const response = await import_axios.default.get(url, {});
+  const items = response.data.items;
+  return items;
+}
+__name(getCollection, "getCollection");
+function mapItems(items, map) {
+  if (typeof map === "object") {
+    items = items.map((x) => {
+      const item = {};
+      Object.entries(x).forEach(([k, v]) => {
+        item[map[k] || k] = v;
+      });
+      return item;
+    });
+  }
+  return items;
+}
+__name(mapItems, "mapItems");
+function getLoader(config, src, map) {
+  return async () => {
+    const key = typeof src === "string" ? src : `static_${++ID}`;
+    let items = CACHE[key];
+    if (!items) {
+      if (typeof src === "string") {
+        items = await getCollection(src);
+      } else if (typeof src === "function") {
+        if (src instanceof Promise) {
+          items = await src(config);
+        } else {
+          items = src(config);
+        }
+      } else {
+        items = src;
+      }
+      items = mapItems(items, map);
+      CACHE[key] = items;
+    }
+    return items;
+  };
+}
+__name(getLoader, "getLoader");
+function getObjectParam(value) {
+  if (typeof value === "object") {
+    return value;
+  }
+  return void 0;
+}
+__name(getObjectParam, "getObjectParam");
+function getNumericParam(value) {
+  if (typeof value === "string") {
+    return parseInt(value);
+  }
+  return void 0;
+}
+__name(getNumericParam, "getNumericParam");
+function getStringParam(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return void 0;
+}
+__name(getStringParam, "getStringParam");
+function existsClause(value, exists) {
+  if (typeof exists === "boolean") {
+    return value != null === exists;
+  }
+  return true;
+}
+__name(existsClause, "existsClause");
+function equalsClause(value, equals) {
+  if (typeof equals !== "undefined") {
+    return value === equals;
+  }
+  return true;
+}
+__name(equalsClause, "equalsClause");
+function inClause(value, values) {
+  if (Array.isArray(values)) {
+    return values.indexOf(value) !== -1;
+  }
+  return true;
+}
+__name(inClause, "inClause");
+function notInClause(value, values) {
+  if (Array.isArray(values)) {
+    return values.indexOf(value) === -1;
+  }
+  return true;
+}
+__name(notInClause, "notInClause");
+function likeClause(value, query) {
+  if (typeof query === "string") {
+    return String(value).toLowerCase().indexOf(query.toLowerCase()) !== -1;
+  }
+  return true;
+}
+__name(likeClause, "likeClause");
+function whereItem(item, where) {
+  let has = true;
+  if (typeof where === "object") {
+    Object.entries(where).forEach(([k, v]) => {
+      switch (k) {
+        case "and":
+          if (Array.isArray(v)) {
+            has = v.reduce((p, c) => {
+              return p && whereItem(item, c);
+            }, has);
+          }
+          break;
+        case "or":
+          if (Array.isArray(v)) {
+            has = has && v.reduce((p, c) => {
+              return p || whereItem(item, c);
+            }, false);
+          }
+          break;
+        default:
+          if (typeof v === "object") {
+            const value = item[k];
+            has = has && existsClause(value, v.exists);
+            has = has && equalsClause(value, v.equals);
+            has = has && inClause(value, v.in);
+            has = has && notInClause(value, v.not_in);
+            has = has && likeClause(value, v.like);
+          }
+      }
+    });
+  }
+  return has;
+}
+__name(whereItem, "whereItem");
+async function whereCollection(items, where) {
+  if (typeof where === "object") {
+    items = items.filter((item) => whereItem(item, where));
+  }
+  return items;
+}
+__name(whereCollection, "whereCollection");
+async function populateStaticFields(item, fields, locale = "en") {
+  const x = { ...item };
+  for (const field of fields) {
+    if (field.type === "relationship" && typeof field.relationTo === "string") {
+      const { name } = field;
+      const loader = getStaticLoader(field.relationTo);
+      if (typeof loader === "function") {
+        const items = await loader();
+        if (field.hasMany) {
+          const ids = x[name];
+          x[name] = items.filter((x2) => ids.indexOf(x2.id) !== -1);
+        } else {
+          const id = x[name];
+          x[name] = items.find((x2) => x2.id === id) || id;
+        }
+      }
+    }
+  }
+  return x;
+}
+__name(populateStaticFields, "populateStaticFields");
+function localizeItem(item, localizedFields, locale = "en") {
+  let localizedItem = item;
+  if (localizedFields.length) {
+    localizedItem = { ...item };
+    localizedFields.forEach((field) => {
+      localizedItem[field] = item[field][locale];
+    });
+  }
+  return localizedItem;
+}
+__name(localizeItem, "localizeItem");
+async function localizeCollection(items, localizedFields, locale = "en") {
+  if (localizedFields.length) {
+    items = items.map((item) => localizeItem(item, localizedFields, locale));
+  }
+  return items;
+}
+__name(localizeCollection, "localizeCollection");
+async function sortCollection(items, sort) {
+  if (sort) {
+    const keys = sort.split("-");
+    const reverse = keys.length > 1 ? -1 : 1;
+    const key = keys.pop();
+    items = [...items];
+    items.sort((a, b) => {
+      const aValue = String(a[key]);
+      const bValue = String(b[key]);
+      if (aValue.localeCompare(bValue) < 0) {
+        return -1 * reverse;
+      } else if (aValue.localeCompare(bValue) > 0) {
+        return 1 * reverse;
+      }
+      return 0;
+    });
+  }
+  return items;
+}
+__name(sortCollection, "sortCollection");
+async function getPagination(items, page = 1, limit = 10) {
+  const totalDocs = items.length;
+  const totalPages = Math.ceil(items.length / limit);
+  const hasNextPage = page < totalPages;
+  const hasPrevPage = page > 1;
+  const index = page - 1;
+  const from = index * limit;
+  const to = Math.min(page * limit, totalDocs);
+  const docs = items.slice(from, to);
+  const pagination = {
+    totalDocs,
+    totalPages,
+    page,
+    limit,
+    hasNextPage,
+    hasPrevPage,
+    nextPage: hasNextPage ? page + 1 : null,
+    prevPage: hasPrevPage ? page - 1 : null,
+    pagingCounter: from + 1
+  };
+  return {
+    docs,
+    ...pagination
+  };
+}
+__name(getPagination, "getPagination");
+function getStaticLoader(slug) {
+  return staticCollectionLoaders[slug];
+}
+__name(getStaticLoader, "getStaticLoader");
+var StaticCollectionDefault = {
+  admin: {
+    group: options.group.i18n,
+    useAsTitle: "name",
+    defaultColumns: ["name", "id"],
+    listSearchableFields: ["name", "id"]
+  },
+  access: {
+    read: () => true,
+    create: () => false,
+    update: () => false,
+    delete: () => false,
+    admin: () => true,
+    unlock: () => false
+  }
+};
+var withStaticCollection = /* @__PURE__ */ __name(({ src, map, ...config }) => {
+  staticCollections.push(config.slug);
+  const collectionConfig = deepMerge(StaticCollectionDefault, config);
+  const localizedFields = collectionConfig.fields.filter((x) => x["localized"] === true).map((x) => x.name);
+  const loader = getLoader(collectionConfig, src, map);
+  staticCollectionLoaders[collectionConfig.slug] = loader;
+  collectionConfig.endpoints = [
+    {
+      path: "/",
+      method: "get",
+      handler: async (req, res, next) => {
+        try {
+          const collection = await loader();
+          const { url, query, params } = req;
+          const { locale, where, sort, page, limit, depth, draft } = query;
+          let items = await whereCollection(collection, getObjectParam(where));
+          items = await localizeCollection(items, localizedFields, getStringParam(locale));
+          items = await sortCollection(items, getStringParam(sort));
+          const pagination = await getPagination(
+            items,
+            getNumericParam(page),
+            getNumericParam(limit)
+          );
+          res.status(200).send(pagination);
+        } catch (error) {
+          console.log("withStaticCollection.get.error", error);
+          res.status(500).send(error);
+        }
+      }
+    },
+    {
+      path: "/:id/",
+      method: "get",
+      handler: async (req, res, next) => {
+        try {
+          const collection = await loader();
+          const { url, query, params } = req;
+          const { locale } = query;
+          const { id } = params;
+          const depth = getNumericParam(query.depth);
+          let item = collection.find((x) => x.id === id);
+          if (item) {
+            if (depth !== 0 && Array.isArray(collectionConfig.fields)) {
+              item = await populateStaticFields(item, collectionConfig.fields);
+            }
+            item = localizeItem(item, localizedFields, getStringParam(locale));
+            res.status(200).send(item);
+          } else {
+            res.status(404);
+          }
+        } catch (error) {
+          console.log("withStaticCollection.get:id.error", error);
+          res.status(500).send(error);
+        }
+      }
+    }
+  ];
+  collectionConfig.fields.forEach((field) => {
+    const admin = field.admin || {};
+    admin["readOnly"] = true;
+    field.admin = admin;
+  });
+  translateCollection(collectionConfig);
+  return collectionConfig;
+}, "withStaticCollection");
+
+// src/core/collections/withCollection.ts
+var CollectionDefault = {
+  admin: {
+    group: options.group.config,
+    useAsTitle: "id",
+    defaultColumns: ["id", "title"]
+  },
+  access: {
+    read: () => true
+  }
+};
+var withCollection = /* @__PURE__ */ __name((config) => {
+  const collectionConfig = deepMerge(CollectionDefault, config);
+  withCollectionHook(collectionConfig, "afterRead", async ({
+    doc,
+    // full document data
+    req,
+    // full express request
+    query,
+    // JSON formatted query
+    findMany
+    // boolean to denote if this hook is running against finding one, or finding many
+  }) => {
+    if (doc && !findMany) {
+      const { query: query2 } = req;
+      const { locale } = query2;
+      const depth = getNumericParam(query2.depth);
+      if (depth !== 0 && Array.isArray(collectionConfig.fields)) {
+        doc = await populateStaticFields(doc, collectionConfig.fields, locale);
+      }
+    }
+    return doc;
+  });
+  collectionConfig.endpoints = [
+    collectionGet(config.slug)
+  ];
+  translateCollection(collectionConfig);
+  return withLocalized(collectionConfig);
+}, "withCollection");
+
+// src/core/collections/withGlobal.ts
+var GlobalDefault = {
+  admin: {
+    group: options.group.config
+  },
+  access: {
+    read: () => true
+  }
+};
+var withGlobal = /* @__PURE__ */ __name((config) => {
+  const globalConfig = deepMerge(GlobalDefault, config);
+  withGlobalHook(globalConfig, "afterRead", async ({
+    doc,
+    // full document data
+    req,
+    // full express request
+    query,
+    // JSON formatted query
+    findMany
+    // boolean to denote if this hook is running against finding one, or finding many
+  }) => {
+    if (doc && !findMany) {
+      const { query: query2 } = req;
+      const { locale } = query2;
+      const depth = getNumericParam(query2.depth);
+      if (depth !== 0 && Array.isArray(globalConfig.fields)) {
+        doc = await populateStaticFields(doc, globalConfig.fields, locale);
+      }
+    }
+    return doc;
+  });
+  translateGlobal(globalConfig);
+  return withLocalized(globalConfig);
+}, "withGlobal");
+
+// src/core/fields/withRichText.ts
+var import_escape_html2 = __toESM(require("escape-html"));
+var import_slate2 = require("slate");
+var richTextAfterReadHook = /* @__PURE__ */ __name((args) => {
+  const {
+    value,
+    // Typed as `string` as shown above
+    operation,
+    findMany,
+    data,
+    // Typed as a Partial of your ExampleDocumentType
+    siblingData,
+    // Typed as a Partial of SiblingDataType
+    originalDoc,
+    // Typed as ExampleDocumentType
+    req
+  } = args;
+  if (operation === "read" && (findMany || req.query && req.query.richText === "false")) {
+    return richTextSerialize(value);
+  }
+  return value;
+}, "richTextAfterReadHook");
+var RichTextDefaults = {
+  name: "richText",
+  type: "richText",
+  localized: true,
+  hooks: {
+    afterRead: [
+      richTextAfterReadHook
+    ]
+  }
+};
+var withRichText = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(RichTextDefaults, options2);
+  return field;
+}, "withRichText");
+var withRichTextRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...RichTextDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withRichTextRequired");
+function richTextSerialize(children) {
+  if (Array.isArray(children)) {
+    return children.map((node, i) => {
+      if (import_slate2.Text.isText(node)) {
+        let text = node.text;
+        if (node.bold) {
+          text = `<strong>${text}</strong>`;
+        }
+        if (node.code) {
+          text = `<code>${text}</code>`;
+        }
+        if (node.italic) {
+          text = `<em>${text}</em>`;
+        }
+        return `<span>${text}</span>`;
+      }
+      if (!node) {
+        return null;
+      }
+      switch (node.type) {
+        case "h1":
+          return `<h1>${richTextSerialize(node.children)}</h1>`;
+        case "h6":
+          return `<h6 >${richTextSerialize(node.children)}</h6>`;
+        case "quote":
+          return `<blockquote >${richTextSerialize(node.children)}</blockquote>`;
+        case "ul":
+          return `<ul >${richTextSerialize(node.children)}</ul>`;
+        case "ol":
+          return `<ol >${richTextSerialize(node.children)}</ol>`;
+        case "li":
+          return `<li>${richTextSerialize(node.children)}</li>`;
+        case "link":
+          return `<a href="${(0, import_escape_html2.default)(node.url)}">${richTextSerialize(node.children)}</a>`;
+        default:
+          return `<p>${richTextSerialize(node.children)}</p>`;
+      }
+    }).join("\n");
+  }
+  return "";
+}
+__name(richTextSerialize, "richTextSerialize");
+
+// src/core/fields/withAbstract.ts
+var withAbstract = /* @__PURE__ */ __name((options2 = {}) => {
+  return withRichText(deepMerge({
+    name: "abstract"
+  }, options2));
+}, "withAbstract");
+var withAbstractRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  return withRichText(deepMerge({
+    name: "abstract",
+    required: true
+  }, options2));
+}, "withAbstractRequired");
+
+// src/core/fields/withCategory.ts
+var CategoryDefaults = {
+  name: "category",
+  type: "relationship",
+  relationTo: options.slug.category,
+  hasMany: false
+};
+var withCategory = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(CategoryDefaults, options2);
+  return field;
+}, "withCategory");
+var withCategoryRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...CategoryDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withCategoryRequired");
+
+// src/core/fields/withCheckbox.ts
+var CheckboxDefaults = {
+  name: "checkbox",
+  type: "checkbox",
+  defaultValue: false
+};
+var withCheckbox = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(CheckboxDefaults, options2);
+  return field;
+}, "withCheckbox");
+var withCheckboxRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...CheckboxDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withCheckboxRequired");
+
+// src/core/fields/withComponents.ts
+var ComponentsDefaults = {
+  name: "components",
+  type: "blocks",
+  blocks: []
+};
+var withComponents = /* @__PURE__ */ __name((options2) => {
+  const field = deepMerge({
+    ...ComponentsDefaults
+  }, options2);
+  return field;
+}, "withComponents");
+
+// src/core/fields/withDate.ts
+var DateDefaults = {
+  name: "date",
+  type: "date"
+};
+var withDate = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(DateDefaults, options2);
+  return field;
+}, "withDate");
+var withDateRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...DateDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withDateRequired");
+
+// src/core/fields/withDescription.ts
+var withDescription = /* @__PURE__ */ __name((options2 = {}) => {
+  return withRichText(deepMerge({
+    name: "description"
+  }, options2));
+}, "withDescription");
+var withDescriptionRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  return withRichText(deepMerge({
+    name: "description",
+    required: true
+  }, options2));
+}, "withDescriptionRequired");
+
+// src/core/fields/withText.ts
+var TextDefaults = {
+  name: "text",
+  type: "text"
+};
+var withText = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(TextDefaults, options2);
+  return field;
+}, "withText");
+var withTextRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...TextDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withTextRequired");
+
+// src/core/fields/withId.ts
+var withId = /* @__PURE__ */ __name((options2 = {}) => {
+  return withText(deepMerge({
+    name: "id"
+  }, options2));
+}, "withId");
+var withIdRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  return withText(deepMerge({
+    name: "id",
+    required: true
+  }, options2));
+}, "withIdRequired");
+
+// src/core/fields/withIsActive.ts
+var withIsActive = /* @__PURE__ */ __name((options2 = {}) => {
+  return withCheckbox(deepMerge({
+    name: "isActive"
+  }, options2));
+}, "withIsActive");
+var withIsActiveRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  return withCheckbox(deepMerge({
+    name: "isActive",
+    required: true
+  }, options2));
+}, "withIsActiveRequired");
+
+// src/core/fields/withIsDefault.ts
+var withIsDefault = /* @__PURE__ */ __name((options2 = {}) => {
+  return withCheckbox(deepMerge({
+    name: "isDefault"
+  }, options2));
+}, "withIsDefault");
+var withIsDefaultRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  return withCheckbox(deepMerge({
+    name: "isDefault",
+    required: true
+  }, options2));
+}, "withIsDefaultRequired");
+
+// src/core/fields/withLink.ts
+var appearanceOptions = {
+  text: {
+    label: "Text",
+    value: "text"
+  },
+  primaryButton: {
+    label: "Primary Button",
+    value: "primaryButton"
+  },
+  secondaryButton: {
+    label: "Secondary Button",
+    value: "secondaryButton"
+  }
+};
+var withLink = /* @__PURE__ */ __name(({ appearances, disableLabel = false, ...props } = {}) => {
+  const generatedLink = {
+    name: "link",
+    type: "group",
+    fields: [
+      {
+        name: "type",
+        type: "radio",
+        options: [
+          {
+            label: "Internal link",
+            value: "reference"
+          },
+          {
+            label: "Custom URL",
+            value: "custom"
+          }
+        ],
+        defaultValue: "reference",
+        admin: {
+          layout: "horizontal"
+        }
+      }
+    ]
+  };
+  const linkOptions = {
+    type: "row",
+    fields: [
+      {
+        name: "reference",
+        label: "Document to link to",
+        type: "relationship",
+        relationTo: options.pages,
+        required: true,
+        maxDepth: 1,
+        admin: {
+          condition: (_, siblingData) => siblingData?.type === "reference"
+        }
+      },
+      {
+        name: "url",
+        label: "Custom URL",
+        type: "text",
+        required: true,
+        admin: {
+          condition: (_, siblingData) => siblingData?.type === "custom"
+        }
+      }
+    ]
+  };
+  if (!disableLabel) {
+    linkOptions.fields.unshift({
+      name: "label",
+      label: "Label",
+      type: "text",
+      required: true,
+      admin: {
+        width: "50%"
+      }
+    });
+    linkOptions.fields[1].admin.width = "50%";
+    linkOptions.fields[2].admin.width = "50%";
+    generatedLink.fields[0].admin.width = "50%";
+    generatedLink.fields.push(linkOptions);
+  } else {
+    generatedLink.fields.push(linkOptions);
+  }
+  generatedLink.fields.push({
+    name: "newTab",
+    label: "Open In New Tab",
+    type: "checkbox"
+  });
+  if (typeof appearances === "undefined") {
+    generatedLink.fields.unshift({
+      name: "appearance",
+      label: "Appearance",
+      type: "select",
+      defaultValue: "text",
+      options: [
+        appearanceOptions.text,
+        appearanceOptions.primaryButton,
+        appearanceOptions.secondaryButton
+      ]
+    });
+  }
+  if (appearances) {
+    generatedLink.fields.unshift({
+      name: "appearance",
+      label: "Appearance",
+      type: "select",
+      defaultValue: appearances[0],
+      options: appearances.map((appearance) => appearanceOptions[appearance])
+    });
+  }
+  return deepMerge(generatedLink, props);
+}, "withLink");
+
+// src/core/fields/withMarkets.ts
+var MarketDefaults = {
+  name: "markets",
+  type: "relationship",
+  relationTo: options.slug.market,
+  hasMany: true
+};
+var withMarkets = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(MarketDefaults, options2);
+  return field;
+}, "withMarkets");
+var withMarketsRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...MarketDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withMarketsRequired");
+
+// src/core/fields/withMedia.ts
+var MediaDefaults = {
+  name: "media",
+  type: "upload",
+  relationTo: options.slug.media
+  /*
+  admin: {
+    description: 'Maximum upload file size: 2MB. Recommended file size for images is <500KB.',
+  },
+  */
+};
+var withMedia = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(MediaDefaults, options2);
+  return field;
+}, "withMedia");
+var withMediaRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...MediaDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withMediaRequired");
+
+// src/core/fields/withMedias.ts
+var MediasDefaults = {
+  name: "medias",
+  type: "array",
+  fields: [
+    withMediaRequired()
+  ]
+};
+var withMedias = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(MediasDefaults, options2);
+  return field;
+}, "withMedias");
+var withMediasRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...MediasDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withMediasRequired");
+
+// src/core/fields/withName.ts
+var withName = /* @__PURE__ */ __name((options2 = {}) => {
+  return withText(deepMerge({
+    name: "name",
+    localized: true
+  }, options2));
+}, "withName");
+var withNameRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  return withText(deepMerge({
+    name: "name",
+    localized: true,
+    required: true
+  }, options2));
+}, "withNameRequired");
+
+// src/core/fields/withRelated.ts
+var RelatedDefaults = {
+  name: "related",
+  type: "blocks",
+  blocks: [],
+  maxRows: 1
+};
+var withRelated = /* @__PURE__ */ __name((options2) => {
+  const field = deepMerge({
+    ...RelatedDefaults
+  }, options2);
+  return field;
+}, "withRelated");
+
+// src/core/fields/withSelect.ts
+var SelectDefaults = {
+  name: "select",
+  type: "select",
+  hasMany: false,
+  admin: {
+    isClearable: true
+  },
+  options: []
+};
+var withSelect = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(SelectDefaults, options2);
+  return field;
+}, "withSelect");
+var withSelectRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...SelectDefaults,
+    required: true
+  }, options2);
+  return field;
+}, "withSelectRequired");
+
+// src/core/fields/withSlug.ts
+var withSlug = /* @__PURE__ */ __name(({ fieldToUse, ...options2 } = { fieldToUse: "title" }) => {
+  return withText(deepMerge({
+    name: "slug",
+    localized: true,
+    hooks: {
+      beforeValidate: [formatSlug(fieldToUse)]
+    }
+  }, options2));
+}, "withSlug");
+var withSlugRequired = /* @__PURE__ */ __name(({ fieldToUse, ...options2 } = { fieldToUse: "title" }) => {
+  return withText(deepMerge({
+    name: "slug",
+    localized: true,
+    required: true,
+    hooks: {
+      beforeValidate: [formatSlug(fieldToUse)]
+    }
+  }, options2));
+}, "withSlugRequired");
+
+// src/core/fields/withTemplate.ts
+var TemplateDefaults = {
+  name: "template",
+  type: "relationship",
+  relationTo: options.slug.template,
+  hasMany: false
+};
+var filterOptionsBySlug = /* @__PURE__ */ __name((slug) => () => {
+  return {
+    or: [
+      {
+        hasCompatibleCollections: { equals: false }
+      },
+      {
+        and: [
+          {
+            hasCompatibleCollections: { equals: true }
+          },
+          {
+            compatibleCollections: { contains: slug }
+          }
+        ]
+      }
+    ]
+  };
+}, "filterOptionsBySlug");
+var withTemplate = /* @__PURE__ */ __name(({ slugToUse, ...options2 }) => {
+  const field = deepMerge(TemplateDefaults, options2);
+  field.filterOptions = filterOptionsBySlug(slugToUse);
+  return field;
+}, "withTemplate");
+var withTemplateRequired = /* @__PURE__ */ __name(({ slugToUse, ...options2 }) => {
+  const field = deepMerge({
+    ...TemplateDefaults,
+    required: true
+  }, options2);
+  field.filterOptions = filterOptionsBySlug(slugToUse);
+  return field;
+}, "withTemplateRequired");
+
+// src/core/fields/withTitle.ts
+var withTitle = /* @__PURE__ */ __name((options2 = {}) => {
+  return withText(deepMerge({
+    name: "title",
+    localized: true
+  }, options2));
+}, "withTitle");
+var withTitleRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  return withText(deepMerge({
+    name: "title",
+    localized: true,
+    required: true
+  }, options2));
+}, "withTitleRequired");
+
+// src/core/collections/withPage.ts
+var PageDefault = {
+  admin: {
+    group: options.group.content,
+    useAsTitle: "title",
+    defaultColumns: ["title", "slug", "template", "createdAt", "_status"]
+  },
+  access: {
+    read: () => true
+  },
+  versions: {
+    drafts: true
+  },
+  hooks: {
+    // beforeValidate: [beforeValidateHook],
+    afterChange: [afterPageChangeHook],
+    afterDelete: [afterPageDeleteHook]
+  }
+};
+var withPage = /* @__PURE__ */ __name((config) => {
+  const defaultConfig = { ...PageDefault };
+  defaultConfig.admin.preview = (doc, { locale }) => {
+    const previewUrl = process.env.PREVIEW_URL || "https://localhost:3000/";
+    return `${previewUrl}preview?collection=${config.slug}&id=${doc.id}&slug=${doc.slug}&locale=${locale}&status=${doc._status}`;
+  };
+  const pageConfig = deepMerge(PageDefault, config);
+  pageConfig.fields = [
+    withTitleRequired(),
+    withSlug({
+      fieldToUse: "title",
+      admin: {
+        position: "sidebar"
+      }
+    }),
+    withCategoryRequired({
+      admin: {
+        position: "sidebar"
+      }
+    }),
+    withIsDefaultRequired({
+      admin: {
+        position: "sidebar"
+      }
+    }),
+    withMarkets({
+      admin: {
+        position: "sidebar"
+      }
+    }),
+    withTemplate({
+      slugToUse: config.slug,
+      admin: {
+        position: "sidebar"
+      }
+    }),
+    ...config.fields
+  ];
+  pageConfig.endpoints = [
+    collectionGet(pageConfig.slug)
+  ];
+  translateCollection(pageConfig);
+  const localizedConfig = withLocalized(pageConfig);
+  return localizedConfig;
+}, "withPage");
+
+// src/core/api/store.service.ts
+var import_qs3 = __toESM(require("qs"));
+
+// src/core/api/route.service.ts
+var CACHE_ = new InMemoryCache();
+async function getRoutes(req) {
+  const key = "route";
+  if (CACHE_.has(key)) {
+    return CACHE_.get(key);
+  }
+  const routes = [];
+  let locales = await fetchGlobalItems(req, options.slug.locale, { depth: 0 });
+  locales = locales.filter((x) => x.isActive);
+  const languages = locales.map((x) => x.id);
+  let markets = await fetchCollectionItems(req, options.slug.market, { depth: 0 });
+  markets = markets.filter((x) => x.isActive).map((x) => ({
+    id: x.id,
+    languages: x.languages && x.languages.length ? x.languages : languages
+  }));
+  const categories = await fetchCollectionItems(req, options.slug.category, { depth: 1 });
+  const keys = options.pages;
+  for (const key2 of keys) {
+    const items = await fetchCollectionItems(req, key2, { depth: 0 });
+    for (const item of items) {
+      const segments = getRouteSegments(key2, item, categories);
+      const availableMarkets = item.markets ? markets.filter((x) => item.markets.indexOf(x.id) !== -1) : markets;
+      availableMarkets.forEach((m) => {
+        m.languages.forEach((l) => {
+          const href = segments.reduce((p, c, i) => {
+            let slug = c.slug;
+            if (isLocalizedString(slug)) {
+              slug = localizedToString(slug, l);
+            }
+            slug = `${p}/${slug}`;
+            return slug === "/" ? "" : slug;
+          }, "");
+          let prefix = "";
+          if (languages.length > 1 || markets.length > 1) {
+            prefix = `/${l}`;
+          }
+          if (markets.length > 1) {
+            prefix = `${prefix}-${m.id}`;
+          }
+          const route = {
+            id: `${prefix}${href}`,
+            market: m.id,
+            locale: l,
+            category: item.category,
+            page: item.id,
+            schema: key2,
+            template: item.template
+          };
+          routes.push(route);
+        });
+      });
+      if (key2 === "homepage") {
+        const defaultLanguage = locales.find((x) => x.isDefault);
+        const defaultMarket = markets.find((x) => x.isDefault) || markets[0];
+        const defaultMarketLanguage = defaultMarket && defaultMarket.defaultLanguage ? defaultMarket.defaultLanguage : defaultLanguage.id;
+        const route = {
+          id: "/",
+          market: defaultMarket.id,
+          locale: defaultMarketLanguage,
+          category: item.category,
+          page: item.id,
+          schema: key2,
+          template: item.template
+        };
+        routes.push(route);
+      }
+    }
+  }
+  CACHE_.set(key, routes);
+  return routes;
+}
+__name(getRoutes, "getRoutes");
+async function getRoute(req, id) {
+  const routes = await getRoutes(req);
+  const route = routes.find((x) => x.id === id);
+  return route || null;
+}
+__name(getRoute, "getRoute");
+function isLocalizedString(value) {
+  let isLocalizedString2 = false;
+  if (value) {
+    if (!Array.isArray(value) && typeof value === "object") {
+      const matchKeys = Object.keys(value).reduce((p, c) => p && /^(\w{2})(-\w{2})?$/.test(c), true);
+      const matchValues = Object.values(value).reduce((p, c) => p && typeof c === "string", true);
+      isLocalizedString2 = Boolean(matchKeys && matchValues);
+    }
+  }
+  return isLocalizedString2;
+}
+__name(isLocalizedString, "isLocalizedString");
+function localizedToString(json, locale = "en", defaultLocale2 = "en") {
+  const localizedString = json[locale] || json[defaultLocale2] || Object.values(json)[0];
+  return localizedString;
+}
+__name(localizedToString, "localizedToString");
+function getRouteSegments(schema, item, categories) {
+  const segments = [];
+  let parentId = item.category || null;
+  while (parentId != null) {
+    const parentCategory = categories.find((c) => c.id === parentId);
+    if (parentCategory) {
+      if (parentCategory.slug) {
+        const segment = { ...parentCategory };
+        segments.unshift(segment);
+      }
+      parentId = parentCategory.category ? parentCategory.category.id : null;
+    } else {
+      parentId = null;
+    }
+  }
+  if (item.isDefault !== true) {
+    segments.push({
+      id: item.id,
+      title: item.title,
+      slug: item.slug,
+      schema,
+      page: item.id,
+      media: null
+      // item.media,
+    });
+  }
+  return segments;
+}
+__name(getRouteSegments, "getRouteSegments");
+var routeGet = {
+  path: "/route",
+  method: "get",
+  handler: async (req, res, next) => {
+    const routes = await getRoutes(req);
+    if (typeof req.query.where === "object") {
+      const items = await whereCollection(routes, req.query.where);
+      if (items.length) {
+        res.status(200).send(items);
+      } else {
+        res.status(404);
+      }
+    } else {
+      res.status(200).send(routes);
+    }
+  }
+};
+
+// src/core/api/store.service.ts
+var CACHE_2 = new InMemoryCache();
+async function getStore(req) {
+  const key = keyWithRequest("store", req);
+  if (CACHE_2.has(key)) {
+    return CACHE_2.get(key);
+  }
+  const store = {};
+  for (const slug of options.collections) {
+    const collection = await fetchCollection(req, slug);
+    store[slug] = collection.docs;
+  }
+  const locale = await fetchGlobal(req, "locale");
+  store.locale = locale.items;
+  const routes = await getRoutes(req);
+  store.route = routes;
+  CACHE_2.set(key, store);
+  return store;
+}
+__name(getStore, "getStore");
+function getApiUrl(req) {
+  const { payload } = req;
+  const { config } = payload;
+  const url = `${config.serverURL}${config.routes.api}/`;
+  return url;
+}
+__name(getApiUrl, "getApiUrl");
+function getSearchUrl(req, overrideQuery) {
+  const { query } = req;
+  const params = Object.assign({
+    locale: "*",
+    depth: 1,
+    limit: 1e4
+  }, overrideQuery || query);
+  const search = import_qs3.default.stringify(params);
+  const url = search ? `?${search}` : "";
+  return url;
+}
+__name(getSearchUrl, "getSearchUrl");
+async function fetchEndpoint(req, endpoint, query) {
+  try {
+    const apiUrl = getApiUrl(req);
+    const searchUrl = getSearchUrl(req, query);
+    const url = `${apiUrl}${endpoint}${searchUrl}`;
+    const httpGetResponse = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!httpGetResponse.ok) {
+      throw httpGetResponse;
+    }
+    const json = await httpGetResponse.json();
+    return json;
+  } catch (error) {
+    console.log("StoreService.fetchEndpoint.error", error);
+    throw error;
+  }
+}
+__name(fetchEndpoint, "fetchEndpoint");
+async function fetchCollection(req, slug, query) {
+  return await fetchEndpoint(req, slug, query);
+}
+__name(fetchCollection, "fetchCollection");
+async function fetchGlobal(req, slug, query) {
+  return await fetchEndpoint(req, `globals/${slug}`, query);
+}
+__name(fetchGlobal, "fetchGlobal");
+async function fetchCollectionItems(req, slug, query) {
+  const collection = await fetchCollection(req, slug, query);
+  if (collection) {
+    return collection.docs;
+  }
+  return [];
+}
+__name(fetchCollectionItems, "fetchCollectionItems");
+async function fetchGlobalItems(req, slug, query) {
+  const collection = await fetchGlobal(req, slug, query);
+  if (collection) {
+    return collection.items;
+  }
+  return [];
+}
+__name(fetchGlobalItems, "fetchGlobalItems");
+var storeGet = {
+  path: "/store",
+  method: "get",
+  handler: async (req, res, next) => {
+    const store = await getStore(req);
+    res.status(200).send(store);
+  }
+};
+
+// src/core/api/locale.service.ts
+async function getLocale(req) {
+  let locales = await fetchGlobalItems(req, options.slug.locale, { depth: 0 });
+  locales = locales.filter((x) => x.isActive);
+  return locales;
+}
+__name(getLocale, "getLocale");
+var localeGet = {
+  path: "/locale",
+  method: "get",
+  handler: async (req, res, next) => {
+    const loader = getStaticLoader(options.slug.language);
+    const languages = await loader();
+    let items = await getLocale(req);
+    if (typeof req.query.where === "object") {
+      items = await whereCollection(items, req.query.where);
+    }
+    items = items.map((item) => {
+      const language = languages.find((x) => x.id === item.id);
+      item.title = language ? language.name : null;
+      return item;
+    });
+    items = await localizeCollection(items, ["title"], getStringParam(req.query.locale));
+    if (items.length) {
+      res.status(200).send(items);
+    } else {
+      res.status(404);
+    }
+  }
+};
+
+// src/globals/Locale.ts
+var Locale = /* @__PURE__ */ __name((options2) => ({
+  type: "withGlobal",
+  slug: options2.slug.locale,
+  admin: {
+    group: options2.group.admin
+  },
+  access: {
+    read: () => true
+  },
+  hooks: {
+    afterRead: [async ({
+      doc,
+      // full document data
+      req,
+      // full express request
+      findMany
+      // boolean to denote if this hook is running against finding one, or finding many (useful in versions)
+    }) => {
+      doc = doc || {};
+      const newDoc = doc.items ? doc : {
+        items: [],
+        globalType: "locale"
+      };
+      newDoc.items = options2.locales.map((locale) => {
+        const defaultItem = {
+          id: locale,
+          isActive: false,
+          isDefault: false
+        };
+        const item = Object.assign(defaultItem, newDoc.items.find((x) => x.id === locale) || {});
+        item.isDefault = locale === options2.defaultLocale;
+        return item;
+      });
+      return newDoc;
+    }]
+  },
+  fields: [
+    {
+      name: "items",
+      type: "array",
+      minRows: options2.locales.length,
+      maxRows: options2.locales.length,
+      required: true,
+      admin: {
+        components: {
+          RowLabel: ({ data, path, index }) => {
+            return data?.id || options2.locales[index - 1];
+          }
+        }
+      },
+      fields: [
+        {
+          name: "id",
+          type: "relationship",
+          relationTo: options2.slug.language,
+          required: true,
+          admin: {
+            readOnly: true
+          }
+        },
+        { type: "withIsActive", required: true },
+        {
+          type: "withIsDefault",
+          required: true,
+          admin: {
+            readOnly: true
+          }
+        }
+      ]
+    }
+  ]
+}), "Locale");
+
+// src/fields/color-picker/ColorCell.tsx
+var import_jsx_runtime10 = require("react/jsx-runtime");
+var ColorCell = /* @__PURE__ */ __name((props) => {
+  const { cellData } = props;
+  if (!cellData)
+    return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+    "div",
+    {
+      className: "chip",
+      style: { backgroundColor: cellData }
+    }
+  );
+}, "ColorCell");
+
+// src/fields/color-picker/ColorField.tsx
+var import_react8 = require("react");
+var import_forms5 = require("payload/components/forms");
+var import_preferences = require("payload/components/preferences");
+var import_components3 = require("payload/components");
+var import_forms6 = require("payload/components/forms");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var defaultColors = [
+  "#333333",
+  "#9A9A9A",
+  "#F3F3F3",
+  "#FF6F76",
+  "#FDFFA4",
+  "#B2FFD6",
+  "#F3DDF3"
+];
+var baseClass6 = "custom-color-picker";
+var preferenceKey = "color-picker-colors";
+var ColorField = /* @__PURE__ */ __name((props) => {
+  const { path, label, required } = props;
+  const { value = "", setValue } = (0, import_forms5.useFieldType)({ path, validate: validateHexColor });
+  const { getPreference, setPreference } = (0, import_preferences.usePreferences)();
+  const [colorOptions, setColorOptions] = (0, import_react8.useState)(defaultColors);
+  const [isAdding, setIsAdding] = (0, import_react8.useState)(false);
+  const [colorToAdd, setColorToAdd] = (0, import_react8.useState)("");
+  (0, import_react8.useEffect)(() => {
+    const mergeColorsFromPreferences = /* @__PURE__ */ __name(async () => {
+      const colorPreferences = await getPreference(preferenceKey);
+      if (colorPreferences) {
+        setColorOptions(colorPreferences);
+      }
+    }, "mergeColorsFromPreferences");
+    mergeColorsFromPreferences();
+  }, [getPreference, setColorOptions]);
+  const handleAddColor = (0, import_react8.useCallback)(() => {
+    setIsAdding(false);
+    setValue(colorToAdd);
+    if (colorOptions.indexOf(colorToAdd) > -1) {
+      return;
+    }
+    const newOptions = colorOptions;
+    newOptions.unshift(colorToAdd);
+    setColorOptions(newOptions);
+    setPreference(preferenceKey, newOptions);
+  }, [colorOptions, setPreference, colorToAdd, setIsAdding, setValue]);
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { className: baseClass6, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_forms6.Label, { htmlFor: path, label, required }),
+    isAdding && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("input", { className: `${baseClass6}__input`, type: "text", placeholder: "#000000", value: colorToAdd, onChange: (e) => setColorToAdd(e.target.value) }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        import_components3.Button,
+        {
+          className: `${baseClass6}__btn`,
+          buttonStyle: "primary",
+          iconPosition: "left",
+          iconStyle: "with-border",
+          size: "small",
+          disabled: validateHexColor(colorToAdd) !== true,
+          onClick: handleAddColor,
+          children: "Add"
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        import_components3.Button,
+        {
+          className: `${baseClass6}__btn`,
+          buttonStyle: "secondary",
+          iconPosition: "left",
+          iconStyle: "with-border",
+          size: "small",
+          onClick: () => setIsAdding(false),
+          children: "Cancel"
+        }
+      )
+    ] }),
+    !isAdding && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_react8.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("ul", { className: `${baseClass6}__colors`, children: colorOptions.map((color, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("li", { children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        "button",
+        {
+          type: "button",
+          className: `chip ${color === value ? "chip--selected" : ""} chip--clickable`,
+          style: { backgroundColor: color },
+          "aria-label": color,
+          onClick: () => setValue(color)
+        },
+        color
+      ) }, i)) }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+        import_components3.Button,
+        {
+          className: "add-color",
+          icon: "plus",
+          buttonStyle: "icon-label",
+          iconPosition: "left",
+          iconStyle: "with-border",
+          onClick: () => {
+            setIsAdding(true);
+            setValue("");
+          }
+        }
+      )
+    ] })
+  ] });
+}, "ColorField");
+
+// src/fields/color-picker/index.ts
+var validateHexColor = /* @__PURE__ */ __name((value = "") => {
+  return value.match(/^#(?:[0-9a-fA-F]{3}){1,2}$/) !== null || "Please give a valid hex color";
+}, "validateHexColor");
+var ColorConfig = {
+  type: "text",
+  name: "color",
+  validate: validateHexColor,
+  admin: {
+    components: {
+      Field: ColorField,
+      Cell: ColorCell
+    }
+  }
+};
+var withColor = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge(ColorConfig, options2);
+  return field;
+}, "withColor");
+var withColorRequired = /* @__PURE__ */ __name((options2 = {}) => {
+  const field = deepMerge({
+    ...ColorConfig,
+    required: true
+  }, options2);
+  return field;
+}, "withColorRequired");
+
+// src/fields/debug-field/DebugField.tsx
+var import_utilities6 = require("payload/components/utilities");
+var import_react9 = require("react");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var baseClass7 = "custom-text";
+var DebugField = /* @__PURE__ */ __name((props) => {
+  const { path, type, fieldTypes: fieldTypes2 } = props;
+  const schema = (0, import_react9.useMemo)(() => ({ ...props, admin: { ...props.admin, components: null } }), [path]);
+  const locale = (0, import_utilities6.useLocale)();
+  const FieldComponent = fieldTypes2[type];
+  const fieldKey = `${locale}-custom-text-${path}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: `${baseClass7}`, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(FieldComponent, { ...schema }, fieldKey) });
+}, "DebugField");
+
+// src/fields/debug-field/index.ts
+var debugField = /* @__PURE__ */ __name((options2 = {}) => {
+  const baseOptions = {
+    name: "text",
+    type: "text",
+    admin: {
+      components: {
+        Field: DebugField
+      }
+    }
+  };
+  return deepMerge(
+    baseOptions,
+    options2
+  );
+}, "debugField");
+
+// src/fields/ui-static/UIStaticCell.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var UIStaticCell = /* @__PURE__ */ __name(({ cellData, colIndex, collection, field, rowData }) => {
+  if (!cellData)
+    return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { children: cellData.toString() });
+}, "UIStaticCell");
+
+// src/fields/ui-static/UIStaticField.tsx
+var import_forms7 = require("payload/components/forms");
+var import_utilities7 = require("payload/components/utilities");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var UIStaticField = /* @__PURE__ */ __name((props) => {
+  const { path, label, required } = props;
+  const config = (0, import_utilities7.useConfig)();
+  const locales = config.localization ? config.localization.locales : [];
+  const defaultLocale2 = config.localization ? config.localization.defaultLocale : null;
+  const locale = (0, import_utilities7.useLocale)();
+  const documentInfo = (0, import_utilities7.useDocumentInfo)();
+  const { value, setValue } = (0, import_forms7.useField)({ path });
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_jsx_runtime14.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)("div", { className: "field-type text localized-text", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_forms7.Label, { htmlFor: path, label, required }),
+    /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("input", { type: "text", id: path, name: typeof label === "string" ? label : void 0, value, readOnly: true })
+  ] }) });
+}, "UIStaticField");
+
+// src/fields/ui-static/index.ts
+var withUIStatic = /* @__PURE__ */ __name((options2 = {}) => {
+  const baseOptions = {
+    name: "uiStatic",
+    type: "ui",
+    admin: {
+      components: {
+        Field: UIStaticField,
+        Cell: UIStaticCell
+      }
+    }
+  };
+  return deepMerge(
+    baseOptions,
+    options2
+  );
+}, "withUIStatic");
+
+// src/mapper.ts
+function toCollection(collection) {
+  const type = collection.type;
+  const fields = collection.fields.map((x) => toField(x));
+  delete collection.type;
+  delete collection.fields;
+  const item = {
+    ...collection,
+    fields
+  };
+  switch (type) {
+    case "withPage":
+      return withPage(item);
+    case "withCollection":
+      return withCollection(item);
+    case "withStatic":
+      return withStaticCollection(item);
+    default:
+      return item;
+  }
+}
+__name(toCollection, "toCollection");
+function toGlobal(collection) {
+  const type = collection.type;
+  const fields = collection.fields.map((x) => toField(x));
+  delete collection.type;
+  delete collection.fields;
+  const item = {
+    ...collection,
+    fields
+  };
+  switch (type) {
+    case "withGlobal":
+      return withGlobal(item);
+    default:
+      return item;
+  }
+}
+__name(toGlobal, "toGlobal");
+function toField(item) {
+  if (item["fields"]) {
+    item["fields"] = item["fields"].map((x) => toField(x));
+  }
+  if (item["blocks"]) {
+    item["blocks"] = item["blocks"].map((x) => toBlock(x));
+  }
+  if (item["tabs"]) {
+    item["tabs"] = item["tabs"].map((x) => toTab(x));
+  }
+  switch (item.type) {
+    case "withAbstract":
+      delete item.type;
+      return withAbstract(item);
+    case "withCategory":
+      delete item.type;
+      return withCategory(item);
+    case "withCheckbox":
+      delete item.type;
+      return withCheckbox(item);
+    case "withColor":
+      delete item.type;
+      return withColor(item);
+    case "withComponents":
+      delete item.type;
+      return withComponents(item);
+    case "withDate":
+      delete item.type;
+      return withDate(item);
+    case "withDescription":
+      delete item.type;
+      return withDescription(item);
+    case "withId":
+      delete item.type;
+      return withId(item);
+    case "withIsActive":
+      delete item.type;
+      return withIsActive(item);
+    case "withIsDefault":
+      delete item.type;
+      return withIsDefault(item);
+    case "withLink":
+      delete item.type;
+      return withLink(item);
+    case "withMarkets":
+      delete item.type;
+      return withMarkets(item);
+    case "withMedia":
+      delete item.type;
+      return withMedia(item);
+    case "withMedias":
+      delete item.type;
+      return withMedias(item);
+    case "withName":
+      delete item.type;
+      return withName(item);
+    case "withRelated":
+      delete item.type;
+      return withRelated(item);
+    case "withRichText":
+      delete item.type;
+      return withRichText(item);
+    case "withSelect":
+      delete item.type;
+      return withSelect(item);
+    case "withSlug":
+      delete item.type;
+      return withSlug(item);
+    case "withTemplate":
+      delete item.type;
+      return withTemplate(item);
+    case "withText":
+      delete item.type;
+      return withText(item);
+    case "withTitle":
+      delete item.type;
+      return withTitle(item);
+    case "array":
+      const array = item;
+      array.fields = array.fields.map((x) => toField(x));
+      return array;
+    case "blocks":
+      const blocks = item;
+      blocks.blocks = blocks.blocks.map((x) => toBlock(x));
+      return blocks;
+    case "collapsible":
+      const collapsible = item;
+      collapsible.fields = collapsible.fields.map((x) => toField(x));
+      return collapsible;
+    case "group":
+      const group = item;
+      group.fields = group.fields.map((x) => toField(x));
+      return group;
+    case "row":
+      const row = item;
+      row.fields = row.fields.map((x) => toField(x));
+      return row;
+    case "tabs":
+      const tabs = item;
+      tabs.tabs = tabs.tabs.map((x) => toTab(x));
+      return tabs;
+    default:
+      return item;
+  }
+}
+__name(toField, "toField");
+function toBlock(item) {
+  item.fields = item.fields.map((x) => toField(x));
+  return withBlock(item);
+}
+__name(toBlock, "toBlock");
+function toTab(item) {
+  item.fields = item.fields.map((x) => toField(x));
+  return item;
+}
+__name(toTab, "toTab");
+
+// src/bowl.ts
+var bowl = /* @__PURE__ */ __name((sourceOptions = {}) => (sourceConfig) => {
+  const bowlCollections = [
+    // Content
+    Media,
+    // Navigation
+    Category,
+    Page,
+    // Configuration
+    Label,
+    Market,
+    Template,
+    // I18N
+    Language,
+    Continent,
+    SubContinent,
+    Country,
+    CountryZone,
+    Region,
+    Province,
+    Municipality
+    // Admin
+  ];
+  const bowlGlobals = [
+    // Admin
+    Locale
+  ];
+  const sourceCollections = sourceConfig.collections || [];
+  const sourceGlobals = sourceConfig.globals || [];
+  const pages = [
+    ...sourceCollections.filter((x) => x.type === "withPage").map((x) => x.slug),
+    ...sourceGlobals.filter((x) => x.type === "withPage").map((x) => x.slug)
+  ];
+  options.pages = pages;
+  if (sourceOptions.group) {
+    options.group = Object.assign(options.group, sourceOptions.group);
+  }
+  if (sourceOptions.slug) {
+    options.slug = Object.assign(options.slug, sourceOptions.slug);
+  }
+  if (sourceConfig.localization && sourceConfig.localization.locales) {
+    options.locales = sourceConfig.localization.locales;
+  }
+  if (sourceConfig.localization && sourceConfig.localization.defaultLocale) {
+    options.defaultLocale = sourceConfig.localization.defaultLocale;
+  }
+  if (sourceConfig.i18n && sourceConfig.i18n.resources) {
+    options.translations = deepMerge(options.translations, sourceConfig.i18n.resources);
+  }
+  const filteredCollections = sourceCollections.filter((x) => !internalSlugs.includes(x.slug));
+  const filteredGlobals = sourceGlobals.filter((x) => !internalSlugs.includes(x.slug));
+  const unmappedCollections = [
+    ...filteredCollections,
+    ...bowlCollections.map((x) => x(options))
+  ];
+  const unmappedGlobals = [
+    ...filteredGlobals,
+    ...bowlGlobals.map((x) => x(options))
+  ];
+  const collections = unmappedCollections.map((x) => toCollection(x));
+  const globals = unmappedGlobals.map((x) => toGlobal(x));
+  options.collections = collections.map((x) => x.slug);
+  const sourceEndpoints = sourceConfig.endpoints || [];
+  const targetConfig = {
+    ...sourceConfig,
+    collections,
+    globals,
+    endpoints: [
+      storeGet,
+      routeGet,
+      localeGet,
+      ...sourceEndpoints
+    ]
+  };
+  logMissingTranslations();
+  return targetConfig;
+}, "bowl");
+
+// src/index.ts
+var src_default = bowl;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BlockDefaults,
+  CategoryDefaults,
+  CheckboxDefaults,
+  CollectionDefault,
+  ColorCell,
+  ColorConfig,
+  ColorField,
+  ComponentsDefaults,
+  DateDefaults,
+  DebugField,
+  GlobalDefault,
+  InMemoryCache,
+  LocalizedField,
+  MarketDefaults,
+  MediaDefaults,
+  MediasDefaults,
+  PageDefault,
+  RelatedDefaults,
+  RichTextDefaults,
+  SelectDefaults,
+  StaticCollectionDefault,
+  TemplateDefaults,
+  TextDefaults,
+  UILanguagesCell,
+  UILanguagesField,
+  UIStaticCell,
+  UIStaticField,
+  afterPageChangeHook,
+  afterPageDeleteHook,
+  appearanceOptions,
+  bowl,
+  collectionGet,
+  debugField,
+  deepMerge,
+  defaultGroup,
+  defaultLocale,
+  defaultLocales,
+  defaultSlug,
+  fetchCollection,
+  fetchCollectionItems,
+  fetchEndpoint,
+  fetchGlobal,
+  fetchGlobalItems,
+  formatSlug,
+  getApiUrl,
+  getLocale,
+  getNumericParam,
+  getObjectParam,
+  getRoute,
+  getRoutes,
+  getSearchUrl,
+  getStaticLoader,
+  getStore,
+  getStringParam,
+  getTranslation,
+  getTranslations,
+  internalSlugs,
+  isObject,
+  keyWithRequest,
+  localeGet,
+  localizeCollection,
+  localizedField,
+  logMissingTranslations,
+  options,
+  populateStaticFields,
+  richTextAfterReadHook,
+  richTextSerialize,
+  routeGet,
+  slugToLabel,
+  slugToLabels,
+  storeGet,
+  toBlock,
+  toCollection,
+  toField,
+  toGlobal,
+  toTab,
+  translateBlock,
+  translateBlocks,
+  translateCollection,
+  translateField,
+  translateFields,
+  translateGlobal,
+  translateTab,
+  translateTabs,
+  validateHexColor,
+  whereCollection,
+  withAbstract,
+  withAbstractRequired,
+  withBlock,
+  withCategory,
+  withCategoryRequired,
+  withCheckbox,
+  withCheckboxRequired,
+  withCollection,
+  withCollectionHook,
+  withColor,
+  withColorRequired,
+  withComponents,
+  withDate,
+  withDateRequired,
+  withDescription,
+  withDescriptionRequired,
+  withFieldHook,
+  withGlobal,
+  withGlobalHook,
+  withId,
+  withIdRequired,
+  withIsActive,
+  withIsActiveRequired,
+  withIsDefault,
+  withIsDefaultRequired,
+  withLink,
+  withLocalized,
+  withMarkets,
+  withMarketsRequired,
+  withMedia,
+  withMediaRequired,
+  withMedias,
+  withMediasRequired,
+  withName,
+  withNameRequired,
+  withPage,
+  withRelated,
+  withRichText,
+  withRichTextRequired,
+  withSelect,
+  withSelectRequired,
+  withSlug,
+  withSlugRequired,
+  withStaticCollection,
+  withTemplate,
+  withTemplateRequired,
+  withText,
+  withTextRequired,
+  withTitle,
+  withTitleRequired,
+  withUILanguages,
+  withUIStatic
+});