@vezham/docs-core 1.0.1

package/dist/remark-admonition-BwTcmI_S.d.ts

@@ -0,0 +1,20 @@
+import { Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-admonition.d.ts
+interface RemarkAdmonitionOptions {
+  tag?: string;
+  /**
+   * Map type to another type
+   */
+  typeMap?: Record<string, string>;
+}
+/**
+ * Remark Plugin to support Admonition syntax
+ *
+ * Useful when Migrating from Docusaurus
+ *
+ * @deprecated Use `remarkDirectiveAdmonition` with `remark-directive` configured instead.
+ */
+declare function remarkAdmonition(options?: RemarkAdmonitionOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkAdmonition as n, RemarkAdmonitionOptions as t };

package/dist/remark-code-tab-DE_4bdnu.d.ts

@@ -0,0 +1,34 @@
+import { Processor, Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-code-tab.d.ts
+type TabType = 'CodeBlockTabs' | 'Tabs';
+interface RemarkCodeTabOptions {
+  Tabs?: TabType;
+  /**
+   * Parse MDX in tab values
+   *
+   * @defaultValue false
+   */
+  parseMdx?: boolean;
+}
+declare module 'mdast' {
+  interface CodeData {
+    /**
+     * [Fumadocs: remark-code-tab] the associated tab value
+     */
+    tab?: string;
+    /**
+     * [Fumadocs: remark-code-tab] the associated tab group ID
+     */
+    tabGroup?: string;
+  }
+  interface Data {
+    /**
+     * [Fumadocs: remark-code-tab] internal
+     */
+    _code_tab_visited?: true;
+  }
+}
+declare function remarkCodeTab(this: Processor, options?: RemarkCodeTabOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkCodeTab as n, RemarkCodeTabOptions as t };

package/dist/remark-directive-admonition-BLiJ5l43.d.ts

@@ -0,0 +1,27 @@
+import { Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-directive-admonition.d.ts
+interface RemarkDirectiveAdmonitionOptions {
+  /**
+   * the tag names of Callout component.
+   */
+  tags?: {
+    CalloutContainer?: string;
+    CalloutTitle?: string;
+    CalloutDescription?: string;
+  };
+  /**
+   * All supported admonition types and their linked Callout type.
+   *
+   * When specified, all defaults will be cleared.
+   */
+  types?: Record<string, string>;
+}
+/**
+ * Remark Plugin to support Admonition syntax in Docusaurus, useful for migrating from Docusaurus.
+ *
+ * Requires [`remark-directive`](https://github.com/remarkjs/remark-directive) to be configured.
+ */
+declare function remarkDirectiveAdmonition({ tags: { CalloutContainer, CalloutTitle, CalloutDescription }, types }?: RemarkDirectiveAdmonitionOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkDirectiveAdmonition as n, RemarkDirectiveAdmonitionOptions as t };

package/dist/remark-feedback-block-BxtINXN-.d.ts

@@ -0,0 +1,45 @@
+import { Transformer } from "unified";
+import { Root, RootContent } from "mdast";
+//#region src/mdx-plugins/remark-feedback-block.d.ts
+interface RemarkFeedbackBlockOptions {
+  /**
+   * generate block ID, default to using MD5.
+   */
+  generateHash?: (ctx: {
+    body: string;
+  }) => string;
+  /**
+   * @defaultValue FeedbackBlock
+   */
+  tagName?: string;
+  /**
+   * determine how the node should be resolved into a feedback block.
+   *
+   * default: skip MDX elements, convert paragraph, list item, and image nodes.
+   *
+   * @returns
+   * - `true`: convert the node into a feedback block.
+   * - `false`: skip the current node and look into its children.
+   * - `skip`: skip the current node and its children.
+   */
+  resolve?: (node: RootContent) => boolean | 'skip';
+  /**
+   * generate & include the block body to `<FeedbackBlock body="..." />` as string
+   *
+   * @defaultValue true
+   */
+  generateBody?: boolean;
+}
+interface FeedbackBlockProps {
+  id: string;
+  /** the text body of block, only exists when `generateBody` is enabled. */
+  body?: string;
+}
+/**
+ * Generate MDX `<FeedbackBlock />` elements with an unique `id` for every block-like element.
+ *
+ * Note: the uniqueness is only guaranteed per MDX file/page.
+ */
+declare function remarkFeedbackBlock({ generateHash, tagName, resolve, generateBody }?: RemarkFeedbackBlockOptions): Transformer<Root, Root>;
+//#endregion
+export { RemarkFeedbackBlockOptions as n, remarkFeedbackBlock as r, FeedbackBlockProps as t };

package/dist/remark-gfm-DpVfAX1x.d.ts

@@ -0,0 +1,2 @@
+import remarkGfm$1, { Options as RemarkGfmOptions } from "remark-gfm";
+export { remarkGfm$1 as n, RemarkGfmOptions as t };

package/dist/remark-heading-DEIzTkU5.d.ts

@@ -0,0 +1,33 @@
+import { c as TOCItemType } from "./toc-CtW5lwA1.js";
+import { Transformer } from "unified";
+import { Heading, Root } from "mdast";
+//#region src/mdx-plugins/remark-heading.d.ts
+interface RemarkHeadingOptions {
+  slug?: (root: Root, heading: Heading, text: string) => string;
+  /**
+   * Allow custom headings ids
+   *
+   * @defaultValue true
+   */
+  customId?: boolean;
+  /**
+   * Attach an array of `TOCItemType` to `file.data.toc`
+   *
+   * @defaultValue true
+   */
+  generateToc?: boolean;
+}
+declare module 'vfile' {
+  interface DataMap {
+    /**
+     * [Fumadocs: remark-heading] output data.
+     */
+    toc?: TOCItemType[];
+  }
+}
+/**
+ * Add heading ids and extract TOC
+ */
+declare function remarkHeading({ slug, customId, generateToc }?: RemarkHeadingOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkHeading as n, RemarkHeadingOptions as t };

package/dist/remark-image-BI2S9LOb.d.ts

@@ -0,0 +1,57 @@
+import { Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-image.d.ts
+type ExternalImageOptions = {
+  /**
+   * timeout for fetching remote images (in milliseconds)
+   */
+  timeout?: number;
+} | boolean;
+interface RemarkImageOptions {
+  /**
+   * Directory or base URL to resolve absolute image paths
+   */
+  publicDir?: string;
+  /**
+   * Preferred placeholder type, only available with `useImport` + local images.
+   *
+   * @defaultValue 'none'
+   */
+  placeholder?: 'blur' | 'none';
+  /**
+   * Define how to handle errors when fetching image size.
+   *
+   * - `error` (default): throw an error.
+   * - `ignore`: do absolutely nothing (Next.js Image component may complain).
+   * - `hide`: remove that image element.
+   *
+   * @defaultValue 'error'
+   */
+  onError?: 'error' | 'hide' | 'ignore' | ((error: Error) => void);
+  /**
+   * Import images in the file, and let bundlers handle it.
+   *
+   * ```tsx
+   * import MyImage from "./public/img.png";
+   *
+   * <img src={MyImage} />
+   * ```
+   *
+   * When disabled, `placeholder` will be ignored.
+   *
+   * @defaultValue true
+   */
+  useImport?: boolean;
+  /**
+   * Fetch image size of external URLs
+   *
+   * @defaultValue true
+   */
+  external?: ExternalImageOptions;
+}
+/**
+ * Turn images into Next.js Image compatible usage.
+ */
+declare function remarkImage({ placeholder, external, useImport, onError, publicDir }?: RemarkImageOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkImage as n, RemarkImageOptions as t };

package/dist/remark-llms-bD3WvU2V.d.ts

@@ -0,0 +1,73 @@
+import { n as StringifyOptions } from "./stringifier-B_QUcUyo.js";
+import { MdxJsxFlowElement, MdxJsxTextElement } from "mdast-util-mdx";
+import { Info, State } from "mdast-util-to-markdown";
+import { Processor, Transformer } from "unified";
+import { Parents, Root } from "mdast";
+//#region src/mdx-plugins/remark-llms.d.ts
+interface LLMsOptions extends StringifyOptions {
+  /**
+   * export name for output Markdown.
+   *
+   * @default _markdown
+   */
+  as?: string;
+  /**
+   * Explicit heading IDs in output.
+   *
+   * @default true
+   */
+  headingIds?: boolean;
+  /**
+   * Filter the elements to be included in the output:
+   *
+   * - `true`: include element & its children.
+   * - `children-only`: exclude element but keep its children.
+   * - `false`: exclude element & its children.
+   *
+   * Default:
+   *
+   * ```ts
+   * filterElement = (node) => {
+   *   switch (node.type) {
+   *     case 'mdxjsEsm':
+   *       return false;
+   *     default:
+   *       return true;
+   *   }
+   * },
+   * ```
+   */
+  filterElement?: StringifyOptions['filterElement'];
+  /**
+   * Tag names of MDX components to be stringified as `placeholder()`, you can also use `placeholder()` directly in `stringify` callback.
+   *
+   * Ignored with `output: 'function'`.
+   */
+  mdxAsPlaceholder?: string[];
+  /**
+   * Form of the export:
+   *
+   * - `string`: the output Markdown.
+   * - `function`: a component: Markdown content is still stringified at compile time, while JSX
+   *   elements are kept as JSX, receiving their original props and resolving from `props.components`.
+   *   Render it with `renderToMarkdown` from `@vezham/docs-core/server`, where a component
+   *   can call `asMarkdown()` to define its own Markdown form.
+   *
+   * @default string
+   */
+  output?: 'function' | 'string';
+  /**
+   * @private output in file data, unavailable with `output: 'function'`
+   */
+  _data?: boolean;
+}
+/**
+ * generate `llms.txt` for markdown.
+ */
+declare function remarkLLMs(this: Processor, { as, headingIds, _data, mdxAsPlaceholder, output, ...rest }?: LLMsOptions): Transformer<Root, Root>;
+/**
+ * Preserve AST data to render the MDX component at runtime, use `renderPlaceholder()` to render the placeholders.
+ */
+declare function placeholder(node: MdxJsxTextElement | MdxJsxFlowElement, _parent: Parents | undefined, state: State, info: Info): string;
+//#endregion
+export { placeholder as n, remarkLLMs as r, LLMsOptions as t };

package/dist/remark-mdx-files-Buvxc-sa.d.ts

@@ -0,0 +1,54 @@
+import { MdxJsxFlowElement } from "mdast-util-mdx";
+import { Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-mdx-files.d.ts
+interface FileNode {
+  depth: number;
+  type: 'file';
+  name: string;
+}
+interface FolderNode {
+  depth: number;
+  type: 'folder';
+  name: string;
+  children: Node[];
+}
+interface ToMdxOptions {
+  defaultOpenAll: boolean;
+}
+type Node = FileNode | FolderNode;
+interface RemarkMdxFilesOptions {
+  /**
+   * @defaultValue files
+   */
+  lang?: string;
+  toMdx?: (node: Node, options: ToMdxOptions) => MdxJsxFlowElement;
+}
+/**
+ *
+ * **Files CodeBlock:**
+ *
+ * Convert codeblocks with `files` as lang, like:
+ *
+ * ```files
+ * project
+ * ├── src
+ * │   ├── index.js
+ * │   └── utils
+ * │       └── helper.js
+ * ├── package.json
+ * ```
+ *
+ * into MDX `<Files />` component.
+ *
+ * **Auto Files:**
+ *
+ * Generates MDX `<Files />` component from file system.
+ *
+ * ```mdx
+ * <auto-files dir="scripts" pattern="my-dir/*" defaultOpenAll />
+ * ```
+ */
+declare function remarkMdxFiles(options?: RemarkMdxFilesOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkMdxFiles as a, ToMdxOptions as i, FolderNode as n, RemarkMdxFilesOptions as r, FileNode as t };

package/dist/remark-mdx-mermaid-C1bCHHc6.d.ts

@@ -0,0 +1,15 @@
+import { Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-mdx-mermaid.d.ts
+interface RemarkMdxMermaidOptions {
+  /**
+   * @defaultValue mermaid
+   */
+  lang?: string;
+}
+/**
+ * Convert `mermaid` codeblocks into `<Mermaid />` MDX component
+ */
+declare function remarkMdxMermaid(options?: RemarkMdxMermaidOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkMdxMermaid as n, RemarkMdxMermaidOptions as t };

package/dist/remark-npm-BbpvkJaT.d.ts

@@ -0,0 +1,31 @@
+import { Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-npm.d.ts
+interface PackageManager {
+  name: string;
+  /**
+   * Default to `name`
+   */
+  value?: string;
+  /**
+   * Convert from npm to another package manager
+   */
+  command: (command: string) => string | undefined;
+}
+interface RemarkNpmOptions {
+  /**
+   * Persist Tab value (Fumadocs UI only)
+   *
+   * @defaultValue false
+   */
+  persist?: {
+    id: string;
+  } | false;
+  packageManagers?: PackageManager[];
+}
+/**
+ * It generates multiple tabs of codeblocks for different package managers from a npm command codeblock.
+ */
+declare function remarkNpm({ persist, packageManagers }?: RemarkNpmOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkNpm as n, RemarkNpmOptions as t };

package/dist/remark-steps-DqVEo0iq.d.ts

@@ -0,0 +1,23 @@
+import { Transformer } from "unified";
+import { Root } from "mdast";
+//#region src/mdx-plugins/remark-steps.d.ts
+interface RemarkStepsOptions {
+  /**
+   * Class name for steps container
+   *
+   * @defaultValue fd-steps
+   */
+  steps?: string;
+  /**
+   * Class name for step container
+   *
+   * @defaultValue fd-step
+   */
+  step?: string;
+}
+/**
+ * Convert headings in the format of `1. Hello World` into steps.
+ */
+declare function remarkSteps({ steps, step }?: RemarkStepsOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkSteps as n, RemarkStepsOptions as t };

package/dist/remark-structure-CnHwvNZr.d.ts

@@ -0,0 +1,87 @@
+import { n as StringifyOptions$1, t as Stringifier$1 } from "./stringifier-B_QUcUyo.js";
+import { MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement } from "mdast-util-mdx";
+import { PluggableList, Processor, Transformer } from "unified";
+import { Nodes, Root } from "mdast";
+//#region src/mdx-plugins/remark-structure.d.ts
+interface StructuredDataHeading {
+  id: string;
+  content: string;
+}
+interface StructuredDataContent {
+  heading: string | undefined;
+  content: string;
+}
+interface StructuredData {
+  headings: StructuredDataHeading[];
+  /**
+   * Refer to paragraphs, a heading may contain multiple contents as well
+   */
+  contents: StructuredDataContent[];
+}
+interface StructureOptions {
+  /**
+   * MDAST node types to be scanned as a content block.
+   *
+   * If a node's type is listed in this array, it will be converted into a single content block.
+   *
+   * @defaultValue ['heading', 'paragraph', 'blockquote', 'tableCell', 'mdxJsxFlowElement']
+   */
+  types?: string[] | ((node: Nodes) => boolean);
+  /**
+   * stringify text content from a MDAST node.
+   */
+  stringify?: Stringifier | StringifyOptions;
+  /**
+   * Whether the MDX element should be treated as a single content block, only effective if `types` has `mdxJsxFlowElement`.
+   *
+   * Default: return `true` if the element is a leaf node, otherwise `false`.
+   */
+  mdxTypes?: (node: MdxJsxFlowElement | MdxJsxTextElement) => boolean;
+  /** @deprecated use `stringify.filterMdxAttributes` instead */
+  allowedMdxAttributes?: string[] | ((node: MdxJsxFlowElement | MdxJsxTextElement, attribute: MdxJsxAttribute | MdxJsxExpressionAttribute) => boolean);
+  /**
+   * export as `structuredData` (if true) or specified variable name.
+   */
+  exportAs?: string | boolean;
+}
+declare module 'mdast' {
+  interface Data {
+    /**
+     * [Fumadocs: remark-structure] Items to add to the structured data.
+     */
+    structuredData?: {
+      contents: StructuredDataContent[];
+    };
+  }
+}
+declare module 'vfile' {
+  interface DataMap {
+    /**
+     * [Fumadocs: remark-structure] output data.
+     */
+    structuredData: StructuredData;
+  }
+}
+declare const remarkStructureDefaultOptions: {
+  types: string[];
+  mdxTypes(node: MdxJsxFlowElement | MdxJsxTextElement): boolean;
+  exportAs: false;
+};
+/**
+ * Extract content into structured data.
+ *
+ * By default, the output is stored into VFile (`vfile.data.structuredData`), you can specify `exportAs` to export it.
+ */
+declare function remarkStructure(this: Processor, { types, mdxTypes, stringify: stringifyOptions, allowedMdxAttributes, exportAs }?: StructureOptions): Transformer<Root, Root>;
+/**
+ * Extract data from markdown/mdx content
+ */
+declare function structure(content: string, remarkPlugins?: PluggableList, options?: StructureOptions): StructuredData;
+interface StringifierContext {
+  addContent: (...content: StructuredDataContent[]) => void;
+}
+type Stringifier = Stringifier$1<StringifierContext>;
+type StringifyOptions = StringifyOptions$1<StringifierContext>;
+declare function defaultStringifier(config: StringifyOptions): Stringifier;
+//#endregion
+export { defaultStringifier as a, structure as c, StructuredData as i, StringifyOptions as n, remarkStructure as o, StructureOptions as r, remarkStructureDefaultOptions as s, Stringifier as t };

package/dist/remove-markdown-DfKNMl9w.js

@@ -0,0 +1,40 @@
+import { t as __commonJSMin } from "./rolldown-runtime-DC62tzP2.js";
+//#region ../../node_modules/.pnpm/remove-markdown@0.6.4/node_modules/remove-markdown/index.js
+var require_remove_markdown = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function(md, options) {
+		options = options || {};
+		options.listUnicodeChar = options.hasOwnProperty("listUnicodeChar") ? options.listUnicodeChar : false;
+		options.stripListLeaders = options.hasOwnProperty("stripListLeaders") ? options.stripListLeaders : true;
+		options.gfm = options.hasOwnProperty("gfm") ? options.gfm : true;
+		options.useImgAltText = options.hasOwnProperty("useImgAltText") ? options.useImgAltText : true;
+		options.abbr = options.hasOwnProperty("abbr") ? options.abbr : false;
+		options.replaceLinksWithURL = options.hasOwnProperty("replaceLinksWithURL") ? options.replaceLinksWithURL : false;
+		options.separateLinksAndTexts = options.hasOwnProperty("separateLinksAndTexts") ? options.separateLinksAndTexts : null;
+		options.htmlTagsToSkip = options.hasOwnProperty("htmlTagsToSkip") ? options.htmlTagsToSkip : [];
+		options.throwError = options.hasOwnProperty("throwError") ? options.throwError : false;
+		var output = md || "";
+		output = output.replace(/^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/gm, "");
+		try {
+			if (options.stripListLeaders) {
+				if (options.listUnicodeChar) output = output.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, options.listUnicodeChar + " $1");
+				else output = output.replace(/^([\s\t]*)([\*\-\+]|\d+\.)\s+/gm, "$1");
+			}
+			if (options.gfm) output = output.replace(/\n={2,}/g, "\n").replace(/~{3}.*\n/g, "").replace(/~~/g, "").replace(/```(?:.*)\n([\s\S]*?)```/g, (_, code) => code.trim());
+			if (options.abbr) output = output.replace(/\*\[.*\]:.*\n/, "");
+			let htmlReplaceRegex = /<[^>]*>/g;
+			if (options.htmlTagsToSkip && options.htmlTagsToSkip.length > 0) {
+				const joinedHtmlTagsToSkip = options.htmlTagsToSkip.join("|");
+				htmlReplaceRegex = new RegExp(`<(?!\/?(${joinedHtmlTagsToSkip})(?=>|\s[^>]*>))[^>]*>`, "g");
+			}
+			if (options.separateLinksAndTexts) output = output.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1" + options.separateLinksAndTexts + "$2");
+			output = output.replace(htmlReplaceRegex, "").replace(/^[=\-]{2,}\s*$/g, "").replace(/\[\^.+?\](\: .*?$)?/g, "").replace(/\s{0,2}\[.*?\]: .*?$/g, "").replace(/\!\[(.*?)\][\[\(].*?[\]\)]/g, options.useImgAltText ? "$1" : "").replace(/\[([\s\S]*?)\]\s*[\(\[](.*?)[\)\]]/g, options.replaceLinksWithURL ? "$2" : "$1").replace(/^(\n)?\s{0,3}>\s?/gm, "$1").replace(/^\s{1,2}\[(.*?)\]: (\S+)( ".*?")?\s*$/g, "").replace(/^(\n)?\s{0,}#{1,6}\s*( (.+))? +#+$|^(\n)?\s{0,}#{1,6}\s*( (.+))?$/gm, "$1$3$4$6").replace(/([\*]+)(\S)(.*?\S)??\1/g, "$2$3").replace(/(^|\W)([_]+)(\S)(.*?\S)??\2($|\W)/g, "$1$3$4$5").replace(/(`{3,})(.*?)\1/gm, "$2").replace(/`(.+?)`/g, "$1").replace(/~(.*?)~/g, "$1");
+		} catch (e) {
+			if (options.throwError) throw e;
+			console.error("remove-markdown encountered error: %s", e);
+			return md;
+		}
+		return output;
+	};
+}));
+//#endregion
+export { require_remove_markdown as t };

package/dist/remove-undefined-CzMSKybq.js

@@ -0,0 +1,24 @@
+//#region src/utils/remove-undefined.ts
+function removeUndefined(value, deep = false) {
+	const obj = value;
+	for (const key in obj) {
+		if (obj[key] === void 0) delete obj[key];
+		if (!deep) continue;
+		const entry = obj[key];
+		if (isPlainObject(entry)) {
+			removeUndefined(entry, deep);
+			continue;
+		}
+		if (Array.isArray(entry)) {
+			for (const item of entry) if (isPlainObject(item)) removeUndefined(item, deep);
+		}
+	}
+	return value;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+export { removeUndefined as t };

package/dist/rolldown-runtime-DC62tzP2.js

@@ -0,0 +1,33 @@
+//#region \0rolldown/runtime.js
+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 __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+export { __exportAll as n, __toESM as r, __commonJSMin as t };

package/dist/search/algolia.d.ts

@@ -0,0 +1,2 @@
+import { a as sync, i as setIndexSettings, n as DocumentRecord, o as updateDocuments, r as SyncOptions, t as BaseIndex } from "../algolia-C0E5qQhM.js";
+export { BaseIndex, DocumentRecord, SyncOptions, setIndexSettings, sync, updateDocuments };