@ztl-uwu/nuxt-content 2.13.5

package/dist/runtime/query/match/pipeline.js

@@ -0,0 +1,104 @@
+import { joinURL } from "ufo";
+import { apply, ensureArray, sortList, withoutKeys, withKeys, omit } from "./utils.js";
+import { createMatch } from "./index.js";
+export function createPipelineFetcher(getContentsList) {
+  const match = createMatch();
+  const surround = (data, { query, before, after }) => {
+    const matchQuery = typeof query === "string" ? { _path: query } : query;
+    const index = data.findIndex((item) => match(item, matchQuery));
+    before = before ?? 1;
+    after = after ?? 1;
+    const slice = new Array(before + after).fill(null, 0);
+    return index === -1 ? slice : slice.map((_, i) => data[index - before + i + Number(i >= before)] || null);
+  };
+  const matchingPipelines = [
+    // Conditions
+    (state, params) => {
+      const filtered = state.result.filter((item) => ensureArray(params.where).every((matchQuery) => match(item, matchQuery)));
+      return {
+        ...state,
+        result: filtered,
+        total: filtered.length
+      };
+    },
+    // Sort data
+    (state, params) => ensureArray(params.sort).forEach((options) => sortList(state.result, options)),
+    function fetchSurround(state, params, db) {
+      if (params.surround) {
+        let _surround = surround(state.result?.length === 1 ? db : state.result, params.surround);
+        _surround = apply(withoutKeys(params.without))(_surround);
+        _surround = apply(withKeys(params.only))(_surround);
+        state.surround = _surround;
+      }
+      return state;
+    }
+  ];
+  const transformingPiples = [
+    // Skip first items
+    (state, params) => {
+      if (params.skip) {
+        return {
+          ...state,
+          result: state.result.slice(params.skip),
+          skip: params.skip
+        };
+      }
+    },
+    // Pick first items
+    (state, params) => {
+      if (params.limit) {
+        return {
+          ...state,
+          result: state.result.slice(0, params.limit),
+          limit: params.limit
+        };
+      }
+    },
+    function fetchDirConfig(state, params, db) {
+      if (params.dirConfig) {
+        const path = state.result[0]?._path || params.where?.find((w) => w._path)?._path;
+        if (typeof path === "string") {
+          const dirConfig = db.find((item) => item._path === joinURL(path, "_dir"));
+          if (dirConfig) {
+            state.dirConfig = { _path: dirConfig._path, ...withoutKeys(["_"])(dirConfig) };
+          }
+        }
+      }
+      return state;
+    },
+    // Remove unwanted fields
+    (state, params) => ({
+      ...state,
+      result: apply(withoutKeys(params.without))(state.result)
+    }),
+    // Select only wanted fields
+    (state, params) => ({
+      ...state,
+      result: apply(withKeys(params.only))(state.result)
+    })
+  ];
+  return async (query) => {
+    const db = await getContentsList();
+    const params = query.params();
+    const result1 = {
+      result: db,
+      limit: 0,
+      skip: 0,
+      total: db.length
+    };
+    const matchedData = matchingPipelines.reduce(($data, pipe) => pipe($data, params, db) || $data, result1);
+    if (params.count) {
+      return {
+        result: matchedData.result.length
+      };
+    }
+    const result = transformingPiples.reduce(($data, pipe) => pipe($data, params, db) || $data, matchedData);
+    if (params.first) {
+      return {
+        ...omit(["skip", "limit", "total"])(result),
+        result: result.result[0]
+      };
+    }
+    return result;
+  };
+}

package/dist/runtime/query/match/utils.d.ts

@@ -0,0 +1,35 @@
+import type { SortOptions } from '@nuxt/content';
+/**
+ * Retrive nested value from object by path
+ */
+export declare const get: (obj: any, path: string) => any;
+/**
+ * Returns a new object with the specified keys
+ **/
+export declare const pick: (keys?: string[]) => (obj: any) => any;
+/**
+ * Returns a new object with all the keys of the original object execept the ones specified.
+ **/
+export declare const omit: (keys?: string[]) => (obj: any) => any;
+/**
+ * Apply a function to each element of an array
+ */
+export declare const apply: (fn: (d: any) => any) => (data: any) => any;
+export declare const detectProperties: (keys: string[]) => {
+    prefixes: string[];
+    properties: string[];
+};
+export declare const withoutKeys: (keys?: string[]) => (obj: any) => any;
+export declare const withKeys: (keys?: string[]) => (obj: any) => any;
+/**
+ * Sort list of items by givin options
+ */
+export declare const sortList: (data: any[], params: SortOptions) => any[];
+/**
+ * Raise TypeError if value is not an array
+ */
+export declare const assertArray: (value: any, message?: string) => void;
+/**
+ * Ensure result is an array
+ */
+export declare const ensureArray: <T>(value: T) => T extends Array<any> ? T : T[];

package/dist/runtime/query/match/utils.js

@@ -0,0 +1,65 @@
+export const get = (obj, path) => path.split(".").reduce((acc, part) => acc && acc[part], obj);
+const _pick = (obj, condition) => Object.keys(obj).filter(condition).reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {});
+export const pick = (keys) => (obj) => keys && keys.length ? _pick(obj, (key) => keys.includes(key)) : obj;
+export const omit = (keys) => (obj) => keys && keys.length ? _pick(obj, (key) => !keys.includes(key)) : obj;
+export const apply = (fn) => (data) => Array.isArray(data) ? data.map((item) => fn(item)) : fn(data);
+export const detectProperties = (keys) => {
+  const prefixes = [];
+  const properties = [];
+  for (const key of keys) {
+    if (["$", "_"].includes(key)) {
+      prefixes.push(key);
+    } else {
+      properties.push(key);
+    }
+  }
+  return { prefixes, properties };
+};
+export const withoutKeys = (keys = []) => (obj) => {
+  if (keys.length === 0 || !obj) {
+    return obj;
+  }
+  const { prefixes, properties } = detectProperties(keys);
+  return _pick(obj, (key) => !properties.includes(key) && !prefixes.includes(key[0]));
+};
+export const withKeys = (keys = []) => (obj) => {
+  if (keys.length === 0 || !obj) {
+    return obj;
+  }
+  const { prefixes, properties } = detectProperties(keys);
+  return _pick(obj, (key) => properties.includes(key) || prefixes.includes(key[0]));
+};
+export const sortList = (data, params) => {
+  const comperable = new Intl.Collator(params.$locale, {
+    numeric: params.$numeric,
+    caseFirst: params.$caseFirst,
+    sensitivity: params.$sensitivity
+  });
+  const keys = Object.keys(params).filter((key) => !key.startsWith("$"));
+  for (const key of keys) {
+    data = data.sort((a, b) => {
+      const values = [get(a, key), get(b, key)].map((value) => {
+        if (value === null) {
+          return void 0;
+        }
+        if (value instanceof Date) {
+          return value.toISOString();
+        }
+        return value;
+      });
+      if (params[key] === -1) {
+        values.reverse();
+      }
+      return comperable.compare(values[0], values[1]);
+    });
+  }
+  return data;
+};
+export const assertArray = (value, message = "Expected an array") => {
+  if (!Array.isArray(value)) {
+    throw new TypeError(message);
+  }
+};
+export const ensureArray = (value) => {
+  return Array.isArray(value) ? value : [void 0, null].includes(value) ? [] : [value];
+};

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

@@ -0,0 +1,12 @@
+import type { QueryBuilder, ParsedContent, ContentQueryBuilder, ContentQueryBuilderParams, ContentQueryFetcher } from '@nuxt/content';
+interface QueryOptions {
+    initialParams?: ContentQueryBuilderParams;
+    legacy?: boolean;
+}
+export declare function createQuery<T = ParsedContent>(fetcher: ContentQueryFetcher<T>, opts: QueryOptions & {
+    legacy: true;
+}): QueryBuilder<T>;
+export declare function createQuery<T = ParsedContent>(fetcher: ContentQueryFetcher<T>, opts: QueryOptions & {
+    legacy: false;
+}): ContentQueryBuilder<T>;
+export {};

package/dist/runtime/query/query.js

@@ -0,0 +1,61 @@
+import { ensureArray } from "./match/utils.js";
+const arrayParams = ["sort", "where", "only", "without"];
+export function createQuery(fetcher, opts = {}) {
+  const queryParams = {};
+  for (const key of Object.keys(opts.initialParams || {})) {
+    queryParams[key] = arrayParams.includes(key) ? ensureArray(opts.initialParams[key]) : opts.initialParams[key];
+  }
+  const $set = (key, fn = (v) => v) => {
+    return (...values) => {
+      queryParams[key] = fn(...values);
+      return query;
+    };
+  };
+  const resolveResult = (result) => {
+    if (opts.legacy) {
+      if (result?.surround) {
+        return result.surround;
+      }
+      if (!result) {
+        return result;
+      }
+      if (result?.dirConfig) {
+        result.result = {
+          _path: result.dirConfig?._path,
+          ...result.result,
+          _dir: result.dirConfig
+        };
+      }
+      return result?._path || Array.isArray(result) || !Object.prototype.hasOwnProperty.call(result, "result") ? result : result?.result;
+    }
+    return result;
+  };
+  const query = {
+    params: () => ({
+      ...queryParams,
+      ...queryParams.where ? { where: [...ensureArray(queryParams.where)] } : {},
+      ...queryParams.sort ? { sort: [...ensureArray(queryParams.sort)] } : {}
+    }),
+    only: $set("only", ensureArray),
+    without: $set("without", ensureArray),
+    where: $set("where", (q) => [...ensureArray(queryParams.where), ...ensureArray(q)]),
+    sort: $set("sort", (sort) => [...ensureArray(queryParams.sort), ...ensureArray(sort)]),
+    limit: $set("limit", (v) => parseInt(String(v), 10)),
+    skip: $set("skip", (v) => parseInt(String(v), 10)),
+    // find
+    find: () => fetcher(query).then(resolveResult),
+    findOne: () => fetcher($set("first")(true)).then(resolveResult),
+    count: () => fetcher($set("count")(true)).then(resolveResult),
+    // locale
+    locale: (_locale) => query.where({ _locale }),
+    withSurround: $set("surround", (surroundQuery, options) => ({ query: surroundQuery, ...options })),
+    withDirConfig: () => $set("dirConfig")(true)
+  };
+  if (opts.legacy) {
+    query.findSurround = (surroundQuery, options) => {
+      return query.withSurround(surroundQuery, options).find().then(resolveResult);
+    };
+    return query;
+  }
+  return query;
+}

package/dist/runtime/server/api/cache.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    generatedAt: number;
+    generateTime: number;
+    contents: any;
+    navigation: NavItem[];
+}>>;
+export default _default;

package/dist/runtime/server/api/cache.js

@@ -0,0 +1,18 @@
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const { getContentIndex } = await import("../content-index.js");
+  const { cacheStorage, serverQueryContent } = await import("../storage.js");
+  const { content } = useRuntimeConfig();
+  const now = Date.now();
+  const contents = await serverQueryContent(event).find();
+  await getContentIndex(event);
+  const navigation = await $fetch(`${content.api.baseURL}/navigation`);
+  await cacheStorage().setItem("content-navigation.json", navigation);
+  return {
+    generatedAt: now,
+    generateTime: Date.now() - now,
+    contents: content.experimental.cacheContents ? contents : [],
+    navigation
+  };
+});

package/dist/runtime/server/api/navigation-qid-params.d.ts

@@ -0,0 +1 @@
+export { default as default } from './navigation';

package/dist/runtime/server/api/navigation-qid-params.js

@@ -0,0 +1 @@
+export { default } from "./navigation.js";

package/dist/runtime/server/api/navigation-qid.d.ts

@@ -0,0 +1 @@
+export { default as default } from './navigation';

package/dist/runtime/server/api/navigation-qid.js

@@ -0,0 +1 @@
+export { default } from "./navigation.js";

package/dist/runtime/server/api/navigation.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | number | true | object>>;
+export default _default;

package/dist/runtime/server/api/navigation.js

@@ -0,0 +1,42 @@
+import { defineEventHandler } from "h3";
+import { isPreview } from "../preview.js";
+export default defineEventHandler(async (event) => {
+  const { getContentQuery } = await import("../../utils/query.js");
+  const { cacheStorage, serverQueryContent } = await import("../storage.js");
+  const { createNav } = await import("../navigation.js");
+  const query = getContentQuery(event);
+  if (!isPreview(event) && Object.keys(query).length === 0) {
+    const cache = await cacheStorage().getItem("content-navigation.json");
+    if (cache) {
+      return cache;
+    }
+  }
+  const contents = await serverQueryContent(event, 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 _locale = (query?.where || []).find((w) => w._locale)?._locale;
+  const dirConfigs = await serverQueryContent(event, _locale ? { where: [{ _locale }] } : void 0).where({ _path: /\/_dir$/i, _partial: true }).find();
+  const configs = (dirConfigs?.result || dirConfigs).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/server/api/query-qid-params.d.ts

@@ -0,0 +1 @@
+export { default as default } from './query';

package/dist/runtime/server/api/query-qid-params.js

@@ -0,0 +1 @@
+export { default } from "./query.js";

package/dist/runtime/server/api/query-qid.d.ts

@@ -0,0 +1 @@
+export { default as default } from './query';

package/dist/runtime/server/api/query-qid.js

@@ -0,0 +1 @@
+export { default } from "./query.js";

package/dist/runtime/server/api/query.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/query.js

@@ -0,0 +1,32 @@
+import { createError, defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const { getContentQuery } = await import("../../utils/query.js");
+  const { serverQueryContent } = await import("../storage.js");
+  const query = getContentQuery(event);
+  const { advanceQuery } = useRuntimeConfig().public.content.experimental;
+  if (query.first) {
+    let contentQuery = serverQueryContent(event, query);
+    if (!advanceQuery) {
+      contentQuery = contentQuery.withDirConfig();
+    }
+    const content = await contentQuery.findOne();
+    const _result = advanceQuery ? content?.result : content;
+    const missing = !_result && !content?.dirConfig?.navigation?.redirect && !content?._dir?.navigation?.redirect;
+    if (missing) {
+      throw createError({
+        statusMessage: "Document not found!",
+        statusCode: 404,
+        data: {
+          description: "Could not find document for the given query.",
+          query
+        }
+      });
+    }
+    return content;
+  }
+  if (query.count) {
+    return serverQueryContent(event, query).count();
+  }
+  return serverQueryContent(event, query).find();
+});

package/dist/runtime/server/api/search.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | {
+    id: string;
+    title: string;
+    titles: string[];
+    level: number;
+    content: string;
+}[]>>;
+export default _default;

package/dist/runtime/server/api/search.js

@@ -0,0 +1,16 @@
+import { defineEventHandler } from "h3";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const { serverSearchContent, splitPageIntoSections } = await import("../search.js");
+  const MiniSearch = await import("minisearch").then((m) => m.default);
+  const runtimeConfig = useRuntimeConfig();
+  const { ignoredTags = [], filterQuery, indexed, options } = runtimeConfig.public.content.search;
+  const files = await serverSearchContent(event, filterQuery);
+  const sections = files.map((page) => splitPageIntoSections(page, { ignoredTags })).flat();
+  if (indexed) {
+    const miniSearch = new MiniSearch(options);
+    miniSearch.addAll(sections);
+    return JSON.stringify(miniSearch);
+  }
+  return sections;
+});

package/dist/runtime/server/content-index.d.ts

@@ -0,0 +1,4 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent, ContentQueryBuilder } from '@nuxt/content';
+export declare function getContentIndex(event: H3Event): Promise<Record<string, string[]>>;
+export declare function getIndexedContentsList<T = ParsedContent>(event: H3Event, query: ContentQueryBuilder<T>): Promise<T[]>;

package/dist/runtime/server/content-index.js

@@ -0,0 +1,37 @@
+import { isPreview } from "./preview.js";
+import { cacheStorage, chunksFromArray, getContent, getContentsList } from "./storage.js";
+import { useRuntimeConfig } from "#imports";
+export async function getContentIndex(event) {
+  const defaultLocale = useRuntimeConfig().content.defaultLocale;
+  let contentIndex = await cacheStorage().getItem("content-index.json");
+  if (!contentIndex) {
+    const data = await getContentsList(event);
+    contentIndex = data.reduce((acc, item) => {
+      acc[item._path] = acc[item._path] || [];
+      if (item._locale === defaultLocale) {
+        acc[item._path].unshift(item._id);
+      } else {
+        acc[item._path].push(item._id);
+      }
+      return acc;
+    }, {});
+    await cacheStorage().setItem("content-index.json", contentIndex);
+  }
+  return contentIndex;
+}
+export async function getIndexedContentsList(event, query) {
+  const params = query.params();
+  const path = params?.where?.find((wh) => wh._path)?._path;
+  if (!isPreview(event) && !params.surround && !params.dirConfig && (typeof path === "string" || path instanceof RegExp)) {
+    const index = await getContentIndex(event);
+    const keys = Object.keys(index).filter((key) => path.test ? path.test(key) : key === String(path)).flatMap((key) => index[key]);
+    const keyChunks = [...chunksFromArray(keys, 10)];
+    const contents = [];
+    for await (const chunk of keyChunks) {
+      const result = await Promise.all(chunk.map((key) => getContent(event, key)));
+      contents.push(...result);
+    }
+    return contents;
+  }
+  return getContentsList(event);
+}

package/dist/runtime/server/index.d.ts

@@ -0,0 +1 @@
+export { serverQueryContent, parseContent } from './storage';

package/dist/runtime/server/index.js

@@ -0,0 +1 @@
+export { serverQueryContent, parseContent } from "./storage.js";

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

@@ -0,0 +1,5 @@
+import type { ParsedContentMeta } from '@nuxt/content';
+/**
+ * Create NavItem array to be consumed from runtime plugin.
+ */
+export declare function createNav(contents: ParsedContentMeta[], configs: Record<string, ParsedContentMeta>): any[];

package/dist/runtime/server/navigation.js

@@ -0,0 +1,96 @@
+import { generateTitle } from "../transformers/path-meta.js";
+import { useRuntimeConfig } from "#imports";
+export function createNav(contents, configs) {
+  const { navigation } = useRuntimeConfig().public.content;
+  if (navigation === false) {
+    return [];
+  }
+  const pickNavigationFields = (content) => ({
+    ...pick(["title", ...navigation.fields])(content),
+    ...isObject(content?.navigation) ? content.navigation : {}
+  });
+  const nav = contents.sort((a, b) => a._path.localeCompare(b._path)).reduce((nav2, content) => {
+    const parts = content._path.substring(1).split("/");
+    const idParts = content._id.split(":").slice(1);
+    const isIndex = !!idParts[idParts.length - 1]?.match(/([1-9][0-9]*\.)?index.md/g);
+    const getNavItem = (content2) => ({
+      title: content2.title,
+      _path: content2._path,
+      _file: content2._file,
+      children: [],
+      ...pickNavigationFields(content2),
+      ...content2._draft ? { _draft: true } : {}
+    });
+    const navItem = getNavItem(content);
+    if (isIndex) {
+      const dirConfig = configs[navItem._path];
+      if (typeof dirConfig?.navigation !== "undefined" && !dirConfig?.navigation) {
+        return nav2;
+      }
+      if (content._path !== "/") {
+        const indexItem = getNavItem(content);
+        navItem.children.push(indexItem);
+      }
+      if (dirConfig) {
+        Object.assign(
+          navItem,
+          pickNavigationFields(dirConfig)
+        );
+      }
+    }
+    if (parts.length === 1) {
+      nav2.push(navItem);
+      return nav2;
+    }
+    const siblings = parts.slice(0, -1).reduce((nodes, part, i) => {
+      const currentPathPart = "/" + parts.slice(0, i + 1).join("/");
+      const conf = configs[currentPathPart];
+      if (typeof conf?.navigation !== "undefined" && !conf.navigation) {
+        return [];
+      }
+      let parent = nodes.find((n) => n._path === currentPathPart);
+      if (!parent) {
+        parent = {
+          title: generateTitle(part),
+          _path: currentPathPart,
+          _file: content._file,
+          children: [],
+          ...conf && pickNavigationFields(conf)
+        };
+        nodes.push(parent);
+      }
+      return parent.children;
+    }, nav2);
+    siblings.push(navItem);
+    return nav2;
+  }, []);
+  return sortAndClear(nav);
+}
+const collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+function sortAndClear(nav) {
+  nav.forEach((item) => {
+    item._file = item._file.split(".").slice(0, -1).join(".");
+  });
+  const sorted = nav.sort((a, b) => collator.compare(a._file, b._file));
+  for (const item of sorted) {
+    if (item.children?.length) {
+      sortAndClear(item.children);
+    } else {
+      delete item.children;
+    }
+    delete item._file;
+  }
+  return nav;
+}
+function pick(keys) {
+  return (obj) => {
+    obj = obj || {};
+    if (keys && keys.length) {
+      return keys.filter((key) => typeof obj[key] !== "undefined").reduce((newObj, key) => Object.assign(newObj, { [key]: obj[key] }), {});
+    }
+    return obj;
+  };
+}
+function isObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}

package/dist/runtime/server/plugins/refresh-cache.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/refresh-cache.js

@@ -0,0 +1,15 @@
+import { useStorage, defineNitroPlugin } from "#imports";
+export default defineNitroPlugin(async (nitro) => {
+  const { cleanCachedContents } = await import("../storage.js");
+  const storage = useStorage();
+  const unwatch = await storage.watch(async (event, key) => {
+    if (key.startsWith("content:source")) {
+      cleanCachedContents();
+    }
+  });
+  nitro.hooks.hook("close", async () => {
+    if (typeof unwatch === "function") {
+      await unwatch();
+    }
+  });
+});

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

@@ -0,0 +1,5 @@
+import type { H3Event } from 'h3';
+export declare const isPreview: (event: H3Event) => boolean;
+export declare const getPreview: (event: H3Event) => {
+    key: string | undefined;
+};

package/dist/runtime/server/preview.js

@@ -0,0 +1,9 @@
+import { getQuery, getCookie } from "h3";
+export const isPreview = (event) => {
+  const previewToken = getQuery(event).previewToken || getCookie(event, "previewToken");
+  return !!previewToken;
+};
+export const getPreview = (event) => {
+  const key = getQuery(event).previewToken || getCookie(event, "previewToken");
+  return { key };
+};

package/dist/runtime/server/search.d.ts

@@ -0,0 +1,14 @@
+import type { H3Event } from 'h3';
+import type { ParsedContent, QueryBuilderWhere } from '@nuxt/content';
+export declare function serverSearchContent(event: H3Event, filterQuery?: QueryBuilderWhere): Promise<ParsedContent[]>;
+type Section = {
+    id: string;
+    title: string;
+    titles: string[];
+    level: number;
+    content: string;
+};
+export declare function splitPageIntoSections(page: ParsedContent, { ignoredTags }: {
+    ignoredTags: string[];
+}): Section[];
+export {};