@ztl-uwu/nuxt-content 2.13.5

package/dist/runtime/components/Prose/ProsePre.vue.d.ts

@@ -0,0 +1,146 @@
+declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
+declare var __VLS_6: {};
+type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+    default?: (props: typeof __VLS_6) => any;
+}>;
+declare const __VLS_self: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+    class: {
+        type: StringConstructor;
+        default: null;
+    };
+    style: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: null;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+    class: {
+        type: StringConstructor;
+        default: null;
+    };
+    style: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    meta: string;
+    style: string | Record<string, any>;
+    class: string;
+    code: string;
+    language: string;
+    filename: string;
+    highlights: number[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+    class: {
+        type: StringConstructor;
+        default: null;
+    };
+    style: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: null;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    code: {
+        type: StringConstructor;
+        default: string;
+    };
+    language: {
+        type: StringConstructor;
+        default: null;
+    };
+    filename: {
+        type: StringConstructor;
+        default: null;
+    };
+    highlights: {
+        type: () => number[];
+        default: () => never[];
+    };
+    meta: {
+        type: StringConstructor;
+        default: null;
+    };
+    class: {
+        type: StringConstructor;
+        default: null;
+    };
+    style: {
+        type: (ObjectConstructor | StringConstructor)[];
+        default: null;
+    };
+}>> & Readonly<{}>, {
+    meta: string;
+    style: string | Record<string, any>;
+    class: string;
+    code: string;
+    language: string;
+    filename: string;
+    highlights: number[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/composables/client-db.d.ts

@@ -0,0 +1,14 @@
+import { type Storage, type StorageValue } from 'unstorage';
+import type { NavItem, ContentQueryBuilderParams } from '@nuxt/content';
+export declare const contentStorage: Storage<StorageValue>;
+export declare function createDB(storage: Storage): {
+    storage: Storage<StorageValue>;
+    fetch: (query: NavItem<unknown>) => Promise<NavItem<unknown>>;
+    query: (initialParams?: ContentQueryBuilderParams) => ContentQueryBuilder<T>;
+};
+export declare function useContentDatabase(): Promise<{
+    storage: Storage<StorageValue>;
+    fetch: (query: NavItem<unknown>) => Promise<NavItem<unknown>>;
+    query: (initialParams?: ContentQueryBuilderParams) => ContentQueryBuilder<T>;
+}>;
+export declare function generateNavigation(query?: ContentQueryBuilderParams): Promise<Array<NavItem>>;

package/dist/runtime/composables/client-db.js

@@ -0,0 +1,105 @@
+import memoryDriver from "unstorage/drivers/memory";
+import { createStorage, prefixStorage } from "unstorage";
+import { withBase } from "ufo";
+import { createQuery } from "../query/query.js";
+import { createNav } from "../server/navigation.js";
+import { createPipelineFetcher } from "../query/match/pipeline.js";
+import { useContentPreview } from "./preview.js";
+import { useRuntimeConfig, useNuxtApp } from "#imports";
+const withContentBase = (url) => withBase(url, useRuntimeConfig().public.content.api.baseURL);
+export const contentStorage = prefixStorage(createStorage({ driver: memoryDriver() }), "@content");
+export function createDB(storage) {
+  async function getItems() {
+    const keys = new Set(await storage.getKeys("cache:"));
+    const previewToken = useContentPreview().getPreviewToken();
+    if (previewToken) {
+      const previewMeta = await storage.getItem(`${previewToken}$`).then((data) => data || {});
+      if (Array.isArray(previewMeta.ignoreSources)) {
+        const sources = previewMeta.ignoreSources.map((s) => `cache:${s.trim()}:`);
+        for (const key of keys) {
+          if (sources.some((s) => key.startsWith(s))) {
+            keys.delete(key);
+          }
+        }
+      }
+      const previewKeys = await storage.getKeys(`${previewToken}:`);
+      const previewContents = await Promise.all(previewKeys.map((key) => storage.getItem(key)));
+      for (const pItem of previewContents) {
+        keys.delete(`cache:${pItem._id}`);
+        if (!pItem.__deleted) {
+          keys.add(`${previewToken}:${pItem._id}`);
+        }
+      }
+    }
+    const items = await Promise.all(Array.from(keys).map((key) => storage.getItem(key)));
+    return items;
+  }
+  return {
+    storage,
+    fetch: createPipelineFetcher(getItems),
+    query: (initialParams) => createQuery(
+      createPipelineFetcher(getItems),
+      { initialParams, legacy: false }
+    )
+  };
+}
+let contentDatabase = null;
+let contentDatabaseInitPromise = null;
+export async function useContentDatabase() {
+  if (contentDatabaseInitPromise) {
+    await contentDatabaseInitPromise;
+  } else if (!contentDatabase) {
+    contentDatabaseInitPromise = initContentDatabase();
+    contentDatabase = await contentDatabaseInitPromise;
+  }
+  return contentDatabase;
+}
+async function initContentDatabase() {
+  const nuxtApp = useNuxtApp();
+  const { content } = useRuntimeConfig().public;
+  const _contentDatabase = createDB(contentStorage);
+  const integrity = await _contentDatabase.storage.getItem("integrity");
+  if (content.integrity !== +(integrity || 0)) {
+    const { contents, navigation } = await $fetch(withContentBase(content.integrity ? `cache.${content.integrity}.json` : "cache.json"));
+    await Promise.all(
+      contents.map((content2) => _contentDatabase.storage.setItem(`cache:${content2._id}`, content2))
+    );
+    await _contentDatabase.storage.setItem("navigation", navigation);
+    await _contentDatabase.storage.setItem("integrity", content.integrity);
+  }
+  await nuxtApp.callHook("content:storage", _contentDatabase.storage);
+  return _contentDatabase;
+}
+export async function generateNavigation(query) {
+  const db = await useContentDatabase();
+  if (!useContentPreview().getPreviewToken() && Object.keys(query || {}).length === 0) {
+    return db.storage.getItem("navigation");
+  }
+  const contents = await db.query(query).where({
+    /**
+     * Partial contents are not included in the navigation
+     * A partial content is a content that has `_` prefix in its path
+     */
+    _partial: false,
+    /**
+    * Exclude any pages which have opted out of navigation via frontmatter.
+    */
+    navigation: {
+      $ne: false
+    }
+  }).find();
+  const dirConfigs = await db.query().where({ _path: /\/_dir$/i, _partial: true }).find();
+  const configs = dirConfigs.result.reduce((configs2, conf) => {
+    if (conf.title?.toLowerCase() === "dir") {
+      conf.title = void 0;
+    }
+    const key = conf._path.split("/").slice(0, -1).join("/") || "/";
+    configs2[key] = {
+      ...conf,
+      // Extract meta from body. (non MD files)
+      ...conf.body
+    };
+    return configs2;
+  }, {});
+  return createNav(contents?.result || contents, configs);
+}

package/dist/runtime/composables/content.d.ts

@@ -0,0 +1,19 @@
+import type { ParsedContent } from '@nuxt/content';
+export declare const useContentState: <G extends object = Record<string, unknown>>() => {
+    pages: import("vue").Ref<Record<string, ParsedContent>, Record<string, ParsedContent>>;
+    surrounds: import("vue").Ref<Record<string, [Omit<ParsedContent, "body"> | null, Omit<ParsedContent, "body"> | null]>, Record<string, [Omit<ParsedContent, "body"> | null, Omit<ParsedContent, "body"> | null]>>;
+    navigation: import("vue").Ref<NavItem[], NavItem[]>;
+    globals: import("vue").Ref<Record<string, G>, Record<string, G>>;
+};
+export declare const useContent: <T extends ParsedContent, G extends object = Record<string, unknown>>() => {
+    globals: import("vue").Ref<Record<string, G>, Record<string, G>>;
+    navigation: import("vue").Ref<NavItem[], NavItem[]>;
+    surround: import("vue").ComputedRef<[Omit<ParsedContent, "body"> | null, Omit<ParsedContent, "body"> | null] | undefined>;
+    page: import("vue").ComputedRef<T>;
+    excerpt: import("vue").ComputedRef<any>;
+    toc: import("vue").ComputedRef<any>;
+    type: import("vue").ComputedRef<any>;
+    layout: import("vue").ComputedRef<any>;
+    next: import("vue").ComputedRef<Omit<ParsedContent, "body"> | null | undefined>;
+    prev: import("vue").ComputedRef<Omit<ParsedContent, "body"> | null | undefined>;
+};

package/dist/runtime/composables/content.js

@@ -0,0 +1,41 @@
+import { withoutTrailingSlash } from "ufo";
+import { computed, shallowReactive, shallowRef, useState, useRoute } from "#imports";
+export const useContentState = () => {
+  const pages = useState("dd-pages", () => shallowRef(shallowReactive({})));
+  const surrounds = useState("dd-surrounds", () => shallowRef(shallowReactive({})));
+  const navigation = useState("dd-navigation");
+  const globals = useState("dd-globals", () => shallowRef(shallowReactive({})));
+  return {
+    pages,
+    surrounds,
+    navigation,
+    globals
+  };
+};
+export const useContent = () => {
+  const { navigation, pages, surrounds, globals } = useContentState();
+  const _path = computed(() => withoutTrailingSlash(useRoute().path));
+  const page = computed(() => pages.value[_path.value]);
+  const surround = computed(() => surrounds.value[_path.value]);
+  const toc = computed(() => page?.value?.body?.toc);
+  const type = computed(() => page.value?._type);
+  const excerpt = computed(() => page.value?.excerpt);
+  const layout = computed(() => page.value?.layout);
+  const next = computed(() => surround.value?.[1]);
+  const prev = computed(() => surround.value?.[0]);
+  return {
+    // Refs
+    globals,
+    navigation,
+    surround,
+    page,
+    // From page
+    excerpt,
+    toc,
+    type,
+    layout,
+    // From surround
+    next,
+    prev
+  };
+};

package/dist/runtime/composables/head.d.ts

@@ -0,0 +1,4 @@
+import type { RouteLocationNormalized, RouteLocationNormalizedLoaded } from 'vue-router';
+import type { Ref } from 'vue';
+import type { ParsedContent } from '@nuxt/content';
+export declare const useContentHead: (_content: ParsedContent | Ref<ParsedContent>, to?: RouteLocationNormalized | RouteLocationNormalizedLoaded) => void;

package/dist/runtime/composables/head.js

@@ -0,0 +1,94 @@
+import { hasProtocol, joinURL, withTrailingSlash, withoutTrailingSlash } from "ufo";
+import { useRoute, nextTick, useHead, unref, watch, useRuntimeConfig } from "#imports";
+export const useContentHead = (_content, to = useRoute()) => {
+  const content = unref(_content);
+  const config = useRuntimeConfig();
+  const refreshHead = (data = content) => {
+    if (!to.path || !data) {
+      return;
+    }
+    const head = Object.assign({}, data?.head || {});
+    head.meta = [...head.meta || []];
+    head.link = [...head.link || []];
+    const title = head.title || data?.title;
+    if (title) {
+      head.title = title;
+      if (import.meta.server && !head.meta.some((m) => m.property === "og:title")) {
+        head.meta.push({
+          property: "og:title",
+          content: title
+        });
+      }
+    }
+    const host = config.public.content.host;
+    if (import.meta.server && host) {
+      const _url = joinURL(host ?? "/", config.app.baseURL, to.fullPath);
+      const url = config.public.content.trailingSlash ? withTrailingSlash(_url) : withoutTrailingSlash(_url);
+      if (!head.meta.some((m) => m.property === "og:url")) {
+        head.meta.push({
+          property: "og:url",
+          content: url
+        });
+      }
+      if (!head.link.some((m) => m.rel === "canonical")) {
+        head.link.push({
+          rel: "canonical",
+          href: url
+        });
+      }
+    }
+    const description = head?.description || data?.description;
+    if (description && head.meta.filter((m) => m.name === "description").length === 0) {
+      head.meta.push({
+        name: "description",
+        content: description
+      });
+    }
+    if (import.meta.server && description && !head.meta.some((m) => m.property === "og:description")) {
+      head.meta.push({
+        property: "og:description",
+        content: description
+      });
+    }
+    const image = head?.image || data?.image;
+    if (import.meta.server && image && head.meta.filter((m) => m.property === "og:image").length === 0) {
+      if (typeof image === "string") {
+        head.meta.push({
+          property: "og:image",
+          content: host && !hasProtocol(image) ? new URL(joinURL(config.app.baseURL, image), host).href : image
+        });
+      }
+      if (typeof image === "object") {
+        const imageKeys = [
+          "src",
+          "secure_url",
+          "type",
+          "width",
+          "height",
+          "alt"
+        ];
+        for (const key of imageKeys) {
+          if (key === "src" && image.src) {
+            const isAbsoluteURL = hasProtocol(image.src);
+            const imageURL = isAbsoluteURL ? image.src : joinURL(config.app.baseURL, image.src ?? "/");
+            head.meta.push({
+              property: "og:image",
+              content: host && !isAbsoluteURL ? new URL(imageURL, host).href : imageURL
+            });
+          } else if (image[key]) {
+            head.meta.push({
+              property: `og:image:${key}`,
+              content: image[key]
+            });
+          }
+        }
+      }
+    }
+    if (import.meta.client) {
+      nextTick(() => useHead(head));
+    } else {
+      useHead(head);
+    }
+  };
+  watch(() => unref(_content), refreshHead, { immediate: true });
+};

package/dist/runtime/composables/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { NavItem } from '@nuxt/content';
+export declare const useContentHelpers: () => {
+    navBottomLink: (link: NavItem) => string | undefined;
+    navDirFromPath: (path: string, tree: NavItem[]) => NavItem[] | undefined;
+    navPageFromPath: (path: string, tree: NavItem[]) => NavItem | undefined;
+    navKeyFromPath: (path: string, key: string, tree: NavItem[]) => any;
+};

package/dist/runtime/composables/helpers.js

@@ -0,0 +1,66 @@
+const navBottomLink = (link) => {
+  if (!link.children) {
+    return link._path;
+  }
+  for (const child of link?.children || []) {
+    const result = navBottomLink(child);
+    if (result) {
+      return result;
+    }
+  }
+};
+const navDirFromPath = (path, tree) => {
+  for (const file of tree) {
+    if (file._path === path && !file._id) {
+      return file.children;
+    }
+    if (file.children) {
+      const result = navDirFromPath(path, file.children);
+      if (result) {
+        return result;
+      }
+    }
+  }
+};
+const navPageFromPath = (path, tree) => {
+  for (const file of tree) {
+    if (file._path === path) {
+      return file;
+    }
+    if (file.children) {
+      const result = navPageFromPath(path, file.children);
+      if (result) {
+        return result;
+      }
+    }
+  }
+};
+const navKeyFromPath = (path, key, tree) => {
+  let value;
+  const goDeep = (path2, tree2) => {
+    for (const file of tree2) {
+      if (path2 !== "/" && file._path === "/") {
+        continue;
+      }
+      if (path2?.startsWith(file._path) && file[key]) {
+        value = file[key];
+      }
+      if (file._path === path2) {
+        return;
+      }
+      if (file.children) {
+        goDeep(path2, file.children);
+      }
+    }
+  };
+  goDeep(path, tree);
+  return value;
+};
+export const useContentHelpers = () => {
+  return {
+    navBottomLink,
+    navDirFromPath,
+    navPageFromPath,
+    navKeyFromPath
+  };
+};

package/dist/runtime/composables/navigation.d.ts

@@ -0,0 +1,2 @@
+import type { NavItem, QueryBuilder, QueryBuilderParams, ContentQueryBuilder } from '@nuxt/content';
+export declare const fetchContentNavigation: (queryBuilder?: QueryBuilder | QueryBuilderParams | ContentQueryBuilder) => Promise<Array<NavItem>>;

package/dist/runtime/composables/navigation.js

@@ -0,0 +1,34 @@
+import { hash } from "ohash";
+import { encodeQueryParams } from "../utils/query.js";
+import { jsonStringify } from "../utils/json.js";
+import { addPrerenderPath, shouldUseClientDB, withContentBase } from "./utils.js";
+import { queryContent } from "./query.js";
+import { useContentPreview } from "./preview.js";
+import { useRuntimeConfig } from "#imports";
+export const fetchContentNavigation = async (queryBuilder) => {
+  const { content } = useRuntimeConfig().public;
+  if (typeof queryBuilder?.params !== "function") {
+    queryBuilder = queryContent(queryBuilder);
+  }
+  const params = queryBuilder.params();
+  const apiPath = content.experimental.stripQueryParameters ? withContentBase(`/navigation/${import.meta.dev ? "_" : `${hash(params)}.${content.integrity}`}/${encodeQueryParams(params)}.json`) : withContentBase(import.meta.dev ? `/navigation/${hash(params)}` : `/navigation/${hash(params)}.${content.integrity}.json`);
+  if (!import.meta.dev && import.meta.server) {
+    addPrerenderPath(apiPath);
+  }
+  if (shouldUseClientDB()) {
+    const generateNavigation = await import("./client-db.js").then((m) => m.generateNavigation);
+    return generateNavigation(params);
+  }
+  const data = await $fetch(apiPath, {
+    method: "GET",
+    responseType: "json",
+    params: content.experimental.stripQueryParameters ? void 0 : {
+      _params: jsonStringify(params),
+      previewToken: useContentPreview().getPreviewToken()
+    }
+  });
+  if (typeof data === "string" && data.startsWith("<!DOCTYPE html>")) {
+    throw new Error("Not found");
+  }
+  return data;
+};

package/dist/runtime/composables/preview.d.ts

@@ -0,0 +1,5 @@
+export declare const useContentPreview: () => {
+    isEnabled: () => boolean;
+    getPreviewToken: () => string | undefined;
+    setPreviewToken: (token: string | undefined) => void;
+};

package/dist/runtime/composables/preview.js

@@ -0,0 +1,41 @@
+import { useCookie, useRoute } from "#imports";
+let showWarning = true;
+export const useContentPreview = () => {
+  const getPreviewToken = () => {
+    return useCookie("previewToken").value || import.meta.client && sessionStorage.getItem("previewToken") || void 0;
+  };
+  const setPreviewToken = (token) => {
+    useCookie("previewToken").value = token;
+    useRoute().query.preview = token || "";
+    if (import.meta.client) {
+      if (token) {
+        sessionStorage.setItem("previewToken", token);
+      } else {
+        sessionStorage.removeItem("previewToken");
+      }
+      window.location.reload();
+    }
+  };
+  const isEnabled = () => {
+    const query = useRoute().query;
+    if (Object.prototype.hasOwnProperty.call(query, "preview") && !query.preview) {
+      return false;
+    }
+    if (query.preview || useCookie("previewToken").value) {
+      if (import.meta.dev && showWarning) {
+        console.warn("[content] Client DB enabled since a preview token is set (either in query or cookie).");
+        showWarning = false;
+      }
+      return true;
+    }
+    if (import.meta.client && sessionStorage.getItem("previewToken")) {
+      return true;
+    }
+    return false;
+  };
+  return {
+    isEnabled,
+    getPreviewToken,
+    setPreviewToken
+  };
+};

package/dist/runtime/composables/query.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedContent, ContentQueryBuilder, ContentQueryBuilderParams } from '@nuxt/content';
+/**
+ * Query fetcher
+ */
+export declare const createQueryFetch: <T = ParsedContent>() => (query: ContentQueryBuilder<T>) => Promise<any>;
+/**
+ * Query contents from path
+ */
+export declare function queryContent<T = ParsedContent>(query?: ContentQueryBuilderParams): ContentQueryBuilder<T>;
+export declare function queryContent<T = ParsedContent>(query: string, ...pathParts: string[]): ContentQueryBuilder<T>;

package/dist/runtime/composables/query.js

@@ -0,0 +1,64 @@
+import { joinURL, withLeadingSlash, withoutTrailingSlash } from "ufo";
+import { hash } from "ohash";
+import { createQuery } from "../query/query.js";
+import { encodeQueryParams } from "../utils/query.js";
+import { jsonStringify } from "../utils/json.js";
+import { addPrerenderPath, shouldUseClientDB, withContentBase } from "./utils.js";
+import { useContentPreview } from "./preview.js";
+import { useRuntimeConfig } from "#imports";
+export const createQueryFetch = () => async (query) => {
+  const { content } = useRuntimeConfig().public;
+  const params = query.params();
+  const apiPath = content.experimental.stripQueryParameters ? withContentBase(`/query/${import.meta.dev ? "_" : `${hash(params)}.${content.integrity}`}/${encodeQueryParams(params)}.json`) : withContentBase(import.meta.dev ? "/query" : `/query/${hash(params)}.${content.integrity}.json`);
+  if (!import.meta.dev && import.meta.server) {
+    addPrerenderPath(apiPath);
+  }
+  if (shouldUseClientDB()) {
+    const db = await import("./client-db.js").then((m) => m.useContentDatabase());
+    return db.fetch(query);
+  }
+  const _query = content.experimental.stripQueryParameters ? void 0 : `_params=${encodeURIComponent(jsonStringify(params))}&previewToken=${useContentPreview().getPreviewToken()}`;
+  const data = await $fetch(apiPath + "?" + _query, { method: "GET", responseType: "json" });
+  if (typeof data === "string" && data.startsWith("<!DOCTYPE html>")) {
+    throw new Error("Not found");
+  }
+  return data;
+};
+export function queryContent(query, ...pathParts) {
+  const { content } = useRuntimeConfig().public;
+  const queryBuilder = content.experimental.advanceQuery ? createQuery(createQueryFetch(), { initialParams: typeof query !== "string" ? query : {}, legacy: false }) : createQuery(createQueryFetch(), { initialParams: typeof query !== "string" ? query : {}, legacy: true });
+  let path;
+  if (typeof query === "string") {
+    path = withLeadingSlash(joinURL(query, ...pathParts));
+  }
+  const originalParamsFn = queryBuilder.params;
+  queryBuilder.params = () => {
+    const params = originalParamsFn();
+    if (path) {
+      params.where = params.where || [];
+      if (params.first && (params.where || []).length === 0) {
+        params.where.push({ _path: withoutTrailingSlash(path) });
+      } else {
+        params.where.push({ _path: new RegExp(`^${path.replace(/[-[\]{}()*+.,^$\s/]/g, "\\$&")}`) });
+      }
+    }
+    if (!params.sort?.length) {
+      params.sort = [{ _stem: 1, $numeric: true }];
+    }
+    if (!import.meta.dev) {
+      params.where = params.where || [];
+      if (!params.where.find((item) => typeof item._draft !== "undefined")) {
+        params.where.push({ _draft: { $ne: true } });
+      }
+    }
+    if (content.locales.length) {
+      const queryLocale = params.where?.find((w) => w._locale)?._locale;
+      if (!queryLocale) {
+        params.where = params.where || [];
+        params.where.push({ _locale: content.defaultLocale });
+      }
+    }
+    return params;
+  };
+  return queryBuilder;
+}