gray-matter-es 0.1.3 → 0.2.0

package/README.md

@@ -8,6 +8,7 @@ ESM-only [gray-matter](https://github.com/jonschlinkert/gray-matter) implementat
 ## Features
 
 - 🚀 ESM-only, no CommonJS
+- 🌲 Tree-shakable (named exports)
 - 🌐 Browser-compatible (no Node.js dependencies)
 - 📦 Zero runtime dependencies (YAML parser bundled from [@std/yaml](https://jsr.io/@std/yaml))
 - 🔷 Full TypeScript support with strict types
@@ -24,12 +25,10 @@ pnpm add gray-matter-es
 ## Usage
 
 ```typescript
-import matter from "gray-matter-es";
-// or
-import { matter } from "gray-matter-es";
+import * as matter from "gray-matter-es";
 
 // Parse front matter
-const file = matter("---\ntitle: Hello\n---\nThis is content");
+const file = matter.matter("---\ntitle: Hello\n---\nThis is content");
 console.log(file.data); // { title: 'Hello' }
 console.log(file.content); // 'This is content'
 
@@ -47,6 +46,12 @@ matter.test("---\ntitle: Hello\n---"); // true
 matter.language("---json\n{}\n---"); // { raw: 'json', name: 'json' }
 ```
 
+You can also import individual functions for tree-shaking:
+
+```typescript
+import { matter, stringify, test, language, clearCache, cache } from "gray-matter-es";
+```
+
 ### Custom Delimiters
 
 ```typescript
@@ -94,18 +99,26 @@ Parse front matter from a string or Uint8Array.
 - `isEmpty` - True if front matter block was empty
 - `stringify(data?, options?)` - Stringify the file back
 
-### `matter.stringify(file, data?, options?)`
+### `stringify(file, data?, options?)`
 
 Stringify data to front matter and append content.
 
-### `matter.test(str, options?)`
+### `test(str, options?)`
 
 Test if a string has front matter.
 
-### `matter.language(str, options?)`
+### `language(str, options?)`
 
 Detect the language specified after the opening delimiter.
 
+### `clearCache()`
+
+Clear the internal cache.
+
+### `cache`
+
+The internal cache (read-only access).
+
 ### Options
 
 - `language` - Language to use for parsing (default: `'yaml'`)
@@ -131,9 +144,25 @@ Detect the language specified after the opening delimiter.
 
 ```diff
 - const matter = require('gray-matter');
-+ import matter from 'gray-matter-es';
-+ // or
-+ import { matter } from 'gray-matter-es';
++ import * as matter from 'gray-matter-es';
+```
+
+### API Changes
+
+The main function is now `matter.matter()` instead of `matter()`:
+
+```diff
+- const result = matter(str);
++ const result = matter.matter(str);
+```
+
+Other methods remain the same:
+
+```typescript
+matter.stringify(file, data);
+matter.test(str);
+matter.language(str);
+matter.clearCache();
 ```
 
 ### Removed Features
@@ -187,7 +216,36 @@ If you're using CommonJS, you'll need to either:
 2. Use dynamic import:
 
 ```javascript
-const matter = await import("gray-matter-es").then((m) => m.default);
+const { matter } = await import("gray-matter-es");
+```
+
+## Development
+
+### Prerequisites
+
+This project uses [Nix](https://nixos.org/) for development environment management. Make sure you have Nix installed with flakes enabled.
+
+### Setup
+
+```bash
+# Enter the development shell
+nix develop
+```
+
+### Commands
+
+```bash
+# Run tests
+pnpm run test
+
+# Type check with tsgo
+pnpm run typecheck
+
+# Build
+pnpm run build
+
+# Lint
+pnpm run lint
 ```
 
 ## License

package/dist/index.d.mts

@@ -63,20 +63,6 @@ type GrayMatterInput = string | Uint8Array | {
   content: string;
   data?: Record<string, unknown>;
 };
-/**
-* The matter function interface with static methods
-*/
-interface MatterFunction {
-  (input: GrayMatterInput, options?: GrayMatterOptions): GrayMatterFile;
-  stringify: (file: GrayMatterFile | string, data?: Record<string, unknown>, options?: GrayMatterOptions) => string;
-  test: (str: string, options?: GrayMatterOptions) => boolean;
-  language: (str: string, options?: GrayMatterOptions) => {
-    raw: string;
-    name: string;
-  };
-  clearCache: () => void;
-  cache: Map<string, GrayMatterFile>;
-}
 //#endregion
 //#region src/engines.d.ts
 /**
@@ -86,8 +72,42 @@ type BuiltinLanguage = "yaml" | "json";
 //#endregion
 //#region src/index.d.ts
 /**
-* The matter function with all static methods
+* Cache for parsed results
+*/
+declare const cache: Map<string, GrayMatterFile>;
+/**
+* Takes a string or object with `content` property, extracts
+* and parses front-matter from the string, then returns an object
+* with `data`, `content` and other useful properties.
+*
+* @example
+* ```ts
+* import { matter } from 'gray-matter-es';
+* console.log(matter('---\ntitle: Home\n---\nOther stuff'));
+* //=> { data: { title: 'Home'}, content: 'Other stuff' }
+* ```
+*/
+declare function matter(input: GrayMatterInput, options?: GrayMatterOptions): GrayMatterFile;
+/**
+* Clear the cache
+*/
+declare function clearCache(): void;
+/**
+* Detect the language to use, if one is defined after the
+* first front-matter delimiter.
+*/
+declare function language(str: string, options?: GrayMatterOptions): {
+  raw: string;
+  name: string;
+};
+/**
+* Returns true if the given string has front matter.
+*/
+declare function test(str: string, options?: GrayMatterOptions): boolean;
+/**
+* Stringify an object to YAML or the specified language, and
+* append it to the given string.
 */
-declare const matter: MatterFunction;
+declare function stringify(file: GrayMatterFile | string, data?: Record<string, unknown>, options?: GrayMatterOptions): string;
 //#endregion
-export { type BuiltinLanguage, type Engine, type GrayMatterFile, type GrayMatterInput, type GrayMatterOptions, type MatterFunction, type ResolvedOptions, matter as default, matter };
+export { type BuiltinLanguage, type Engine, type GrayMatterFile, type GrayMatterInput, type GrayMatterOptions, type ResolvedOptions, cache, clearCache, language, matter, stringify, test };

package/dist/index.mjs

@@ -2103,7 +2103,7 @@ var DumperState = class {
 * @param data The data to serialize.
 * @param options The options for serialization.
 * @returns A YAML string.
-*/ function stringify$1(data, options = {}) {
+*/ function stringify$2(data, options = {}) {
 	return new DumperState({
 		...options,
 		schema: SCHEMA_MAP.get(options.schema)
@@ -2136,7 +2136,7 @@ const yaml = {
 		return toRecord(parse$1(str$1));
 	},
 	stringify: (data) => {
-		return stringify$1(data);
+		return stringify$2(data);
 	}
 };
 /**
@@ -2158,11 +2158,11 @@ const json = {
 /**
 * Get engine by language name
 */
-function getEngine(language) {
-	switch (language) {
+function getEngine(language$1) {
+	switch (language$1) {
 		case "yaml": return yaml;
 		case "json": return json;
-		default: throw new Error(`Unknown language: ${language}`);
+		default: throw new Error(`Unknown language: ${language$1}`);
 	}
 }
 
@@ -2192,8 +2192,8 @@ function excerpt(file, options) {
 /**
 * Parse front matter string using the specified language engine
 */
-function parse(language, str$1) {
-	return getEngine(language).parse(str$1);
+function parse(language$1, str$1) {
+	return getEngine(language$1).parse(str$1);
 }
 
 //#endregion
@@ -2213,7 +2213,7 @@ function newline(str$1) {
 /**
 * Stringify file object to string with front matter
 */
-function stringify(file, data, options) {
+function stringify$1(file, data, options) {
 	if (data == null && options == null) if (isGrayMatterFile(file)) {
 		data = file.data;
 		options = {};
@@ -2264,19 +2264,19 @@ function toFile(input) {
 	const normalized = normalizeInput(input);
 	const data = isObject$1(normalized.data) ? normalized.data : {};
 	const content = toString(normalized.content ?? "");
-	const language = normalized.language ?? "";
+	const language$1 = normalized.language ?? "";
 	const matter$1 = normalized.matter ?? "";
 	return {
 		data,
 		content,
 		excerpt: "",
 		orig: toUint8Array(normalized.content ?? ""),
-		language,
+		language: language$1,
 		matter: matter$1,
 		isEmpty: false,
 		stringify(newData, options) {
 			if (options?.language) this.language = options.language;
-			return stringify(this, newData, options);
+			return stringify$1(this, newData, options);
 		}
 	};
 }
@@ -2294,12 +2294,12 @@ const cache = /* @__PURE__ */ new Map();
 *
 * @example
 * ```ts
-* import matter from 'gray-matter-es';
+* import { matter } from 'gray-matter-es';
 * console.log(matter('---\ntitle: Home\n---\nOther stuff'));
 * //=> { data: { title: 'Home'}, content: 'Other stuff' }
 * ```
 */
-function matterImpl(input, options) {
+function matter(input, options) {
 	if (input === "") return {
 		...toFile(input),
 		isEmpty: true
@@ -2317,6 +2317,12 @@ function matterImpl(input, options) {
 	return parseMatter(file, options);
 }
 /**
+* Clear the cache
+*/
+function clearCache() {
+	cache.clear();
+}
+/**
 * Parse front matter from file
 */
 function parseMatter(file, options) {
@@ -2333,7 +2339,7 @@ function parseMatter(file, options) {
 	if (str$1.at(openLen) === open.at(-1)) return file;
 	str$1 = str$1.slice(openLen);
 	const len = str$1.length;
-	const lang = matterLanguage(str$1, opts);
+	const lang = language(str$1, opts);
 	if (lang.name) {
 		file.language = lang.name;
 		str$1 = str$1.slice(lang.raw.length);
@@ -2359,38 +2365,29 @@ function parseMatter(file, options) {
 * Detect the language to use, if one is defined after the
 * first front-matter delimiter.
 */
-function matterLanguage(str$1, options) {
+function language(str$1, options) {
 	const opts = defaults(options);
 	const open = opts.delimiters[0];
-	if (matterTest(str$1, opts)) str$1 = str$1.slice(open.length);
-	const language = str$1.slice(0, str$1.search(/\r?\n/));
+	if (test(str$1, opts)) str$1 = str$1.slice(open.length);
+	const lang = str$1.slice(0, str$1.search(/\r?\n/));
 	return {
-		raw: language,
-		name: language ? language.trim() : ""
+		raw: lang,
+		name: lang ? lang.trim() : ""
 	};
 }
 /**
 * Returns true if the given string has front matter.
 */
-function matterTest(str$1, options) {
+function test(str$1, options) {
 	return str$1.startsWith(defaults(options).delimiters[0]);
 }
 /**
-* The matter function with all static methods
+* Stringify an object to YAML or the specified language, and
+* append it to the given string.
 */
-const matter = Object.assign(matterImpl, {
-	stringify: (file, data, options) => {
-		if (typeof file === "string") file = matterImpl(file, options);
-		return stringify(file, data, options);
-	},
-	test: matterTest,
-	language: matterLanguage,
-	clearCache: () => {
-		cache.clear();
-	},
-	cache
-});
-var src_default = matter;
+function stringify(file, data, options) {
+	return stringify$1(typeof file === "string" ? matter(file, options) : file, data, options);
+}
 
 //#endregion
-export { src_default as default, matter };
+export { cache, clearCache, language, matter, stringify, test };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gray-matter-es",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "ES-only gray-matter",
   "keywords": [
     "esm",

package/src/index.ts

@@ -2,21 +2,15 @@ import { defaults } from "./defaults.ts";
 import { toBuiltinLanguage } from "./engines.ts";
 import { excerpt } from "./excerpt.ts";
 import { parse } from "./parse.ts";
-import { stringify } from "./stringify.ts";
+import { stringify as stringifyImpl } from "./stringify.ts";
 import { toFile } from "./to-file.ts";
-import type {
-  GrayMatterFile,
-  GrayMatterInput,
-  GrayMatterOptions,
-  MatterFunction,
-} from "./types.ts";
+import type { GrayMatterFile, GrayMatterInput, GrayMatterOptions } from "./types.ts";
 
 export type {
   Engine,
   GrayMatterFile,
   GrayMatterInput,
   GrayMatterOptions,
-  MatterFunction,
   ResolvedOptions,
 } from "./types.ts";
 
@@ -25,7 +19,7 @@ export type { BuiltinLanguage } from "./engines.ts";
 /**
  * Cache for parsed results
  */
-const cache = new Map<string, GrayMatterFile>();
+const cache: Map<string, GrayMatterFile> = new Map<string, GrayMatterFile>();
 
 /**
  * Takes a string or object with `content` property, extracts
@@ -34,12 +28,12 @@ const cache = new Map<string, GrayMatterFile>();
  *
  * @example
  * ```ts
- * import matter from 'gray-matter-es';
+ * import { matter } from 'gray-matter-es';
  * console.log(matter('---\ntitle: Home\n---\nOther stuff'));
  * //=> { data: { title: 'Home'}, content: 'Other stuff' }
  * ```
  */
-function matterImpl(input: GrayMatterInput, options?: GrayMatterOptions): GrayMatterFile {
+function matter(input: GrayMatterInput, options?: GrayMatterOptions): GrayMatterFile {
   if (input === "") {
     return { ...toFile(input), isEmpty: true };
   }
@@ -61,6 +55,13 @@ function matterImpl(input: GrayMatterInput, options?: GrayMatterOptions): GrayMa
   return parseMatter(file, options);
 }
 
+/**
+ * Clear the cache
+ */
+function clearCache(): void {
+  cache.clear();
+}
+
 /**
  * Parse front matter from file
  */
@@ -93,7 +94,7 @@ function parseMatter(file: GrayMatterFile, options?: GrayMatterOptions): GrayMat
   const len = str.length;
 
   // use the language defined after first delimiter, if it exists
-  const lang = matterLanguage(str, opts);
+  const lang = language(str, opts);
   if (lang.name) {
     file.language = lang.name;
     str = str.slice(lang.raw.length);
@@ -139,78 +140,49 @@ function parseMatter(file: GrayMatterFile, options?: GrayMatterOptions): GrayMat
  * Detect the language to use, if one is defined after the
  * first front-matter delimiter.
  */
-function matterLanguage(str: string, options?: GrayMatterOptions): { raw: string; name: string } {
+function language(str: string, options?: GrayMatterOptions): { raw: string; name: string } {
   const opts = defaults(options);
   const open = opts.delimiters[0];
 
-  if (matterTest(str, opts)) {
+  if (test(str, opts)) {
     str = str.slice(open.length);
   }
 
-  const language = str.slice(0, str.search(/\r?\n/));
+  const lang = str.slice(0, str.search(/\r?\n/));
   return {
-    raw: language,
-    name: language ? language.trim() : "",
+    raw: lang,
+    name: lang ? lang.trim() : "",
   };
 }
 
 /**
  * Returns true if the given string has front matter.
  */
-function matterTest(str: string, options?: GrayMatterOptions): boolean {
+function test(str: string, options?: GrayMatterOptions): boolean {
   return str.startsWith(defaults(options).delimiters[0]);
 }
 
 /**
- * The matter function with all static methods
+ * Stringify an object to YAML or the specified language, and
+ * append it to the given string.
  */
-const matter: MatterFunction = Object.assign(matterImpl, {
-  /**
-   * Stringify an object to YAML or the specified language, and
-   * append it to the given string.
-   */
-  stringify: (
-    file: GrayMatterFile | string,
-    data?: Record<string, unknown>,
-    options?: GrayMatterOptions,
-  ): string => {
-    if (typeof file === "string") file = matterImpl(file, options);
-    return stringify(file, data, options);
-  },
-
-  /**
-   * Returns true if the given string has front matter.
-   */
-  test: matterTest,
-
-  /**
-   * Detect the language to use, if one is defined after the
-   * first front-matter delimiter.
-   */
-  language: matterLanguage,
-
-  /**
-   * Clear the cache
-   */
-  clearCache: (): void => {
-    cache.clear();
-  },
-
-  /**
-   * Expose cache (read-only access)
-   */
-  cache,
-});
-
-export { matter };
-export default matter;
+function stringify(
+  file: GrayMatterFile | string,
+  data?: Record<string, unknown>,
+  options?: GrayMatterOptions,
+): string {
+  const resolvedFile = typeof file === "string" ? matter(file, options) : file;
+  return stringifyImpl(resolvedFile, data, options);
+}
+
+export { matter, stringify, test, language, clearCache, cache };
 
 if (import.meta.vitest) {
-  const { fc, test } = await import("@fast-check/vitest");
+  const { fc, test: fcTest } = await import("@fast-check/vitest");
 
   describe("matter", () => {
     beforeEach(() => {
-      matter.clearCache();
+      clearCache();
     });
 
     it("should extract YAML front matter", () => {
@@ -286,9 +258,9 @@ if (import.meta.vitest) {
     });
   });
 
-  describe("matter.stringify", () => {
+  describe("stringify", () => {
     it("should stringify data to YAML front matter", () => {
-      const result = matter.stringify("content", { title: "Hello" });
+      const result = stringify("content", { title: "Hello" });
       expect(result).toContain("---");
       expect(result).toContain("title: Hello");
       expect(result).toContain("content");
@@ -296,36 +268,36 @@ if (import.meta.vitest) {
 
     it("should stringify file object", () => {
       const file = matter("---\ntitle: Test\n---\ncontent");
-      const result = matter.stringify(file, { title: "Updated" });
+      const result = stringify(file, { title: "Updated" });
       expect(result).toContain("title: Updated");
     });
   });
 
-  describe("matter.test", () => {
+  describe("test", () => {
     it("should return true for string with front matter", () => {
-      expect(matter.test("---\nabc: xyz\n---")).toBe(true);
+      expect(test("---\nabc: xyz\n---")).toBe(true);
     });
 
     it("should return false for string without front matter", () => {
-      expect(matter.test("foo bar")).toBe(false);
+      expect(test("foo bar")).toBe(false);
     });
   });
 
-  describe("matter.language", () => {
+  describe("language", () => {
     it("should detect language after delimiter", () => {
-      const result = matter.language("---json\n{}\n---");
+      const result = language("---json\n{}\n---");
       expect(result.name).toBe("json");
     });
 
     it("should return empty for no language", () => {
-      const result = matter.language("---\nabc: xyz\n---");
+      const result = language("---\nabc: xyz\n---");
       expect(result.name).toBe("");
     });
   });
 
   describe("property-based tests", () => {
     beforeEach(() => {
-      matter.clearCache();
+      clearCache();
     });
 
     /** Arbitrary for YAML-safe keys */
@@ -343,12 +315,12 @@ if (import.meta.vitest) {
     /** Arbitrary for simple YAML-compatible objects */
     const yamlSafeObject = fc.dictionary(yamlKey, yamlSafeValue, { minKeys: 1, maxKeys: 5 });
 
-    test.prop([fc.string({ minLength: 1, maxLength: 100 })])(
+    fcTest.prop([fc.string({ minLength: 1, maxLength: 100 })])(
       "Uint8Array and string input should produce equivalent results",
       (content) => {
-        matter.clearCache();
+        clearCache();
         const fromString = matter(content);
-        matter.clearCache();
+        clearCache();
         const fromUint8Array = matter(new TextEncoder().encode(content));
 
         expect(fromString.content).toBe(fromUint8Array.content);
@@ -357,7 +329,7 @@ if (import.meta.vitest) {
       },
     );
 
-    test.prop([yamlSafeObject, fc.string({ minLength: 0, maxLength: 50 })])(
+    fcTest.prop([yamlSafeObject, fc.string({ minLength: 0, maxLength: 50 })])(
       "parse then stringify should preserve data",
       (data, content) => {
         const frontMatter = Object.entries(data)
@@ -365,21 +337,21 @@ if (import.meta.vitest) {
           .join("\n");
         const input = `---\n${frontMatter}\n---\n${content}`;
 
-        matter.clearCache();
+        clearCache();
         const parsed = matter(input);
-        const stringified = matter.stringify(parsed);
-        matter.clearCache();
+        const stringified = stringify(parsed);
+        clearCache();
         const reparsed = matter(stringified);
 
         expect(reparsed.data).toEqual(parsed.data);
       },
     );
 
-    test.prop([fc.string({ minLength: 0, maxLength: 100 })])(
+    fcTest.prop([fc.string({ minLength: 0, maxLength: 100 })])(
       "content without front matter should be preserved",
       (content) => {
         const safeContent = content.replace(/^---/gm, "___");
-        matter.clearCache();
+        clearCache();
         const result = matter(safeContent);
 
         expect(result.content).toBe(safeContent);
@@ -387,26 +359,26 @@ if (import.meta.vitest) {
       },
     );
 
-    test.prop([
+    fcTest.prop([
       yamlSafeObject,
       fc.string({ minLength: 0, maxLength: 50 }),
       fc.string({ minLength: 1, maxLength: 50 }),
-    ])("matter.test should correctly detect front matter", (data, content, noFrontMatter) => {
+    ])("test should correctly detect front matter", (data, content, noFrontMatter) => {
       const frontMatter = Object.entries(data)
         .map(([k, v]) => `${k}: ${typeof v === "string" ? JSON.stringify(v) : v}`)
         .join("\n");
       const withFrontMatter = `---\n${frontMatter}\n---\n${content}`;
       const withoutFrontMatter = noFrontMatter.replace(/^---/gm, "___");
 
-      expect(matter.test(withFrontMatter)).toBe(true);
-      expect(matter.test(withoutFrontMatter)).toBe(withoutFrontMatter.startsWith("---"));
+      expect(test(withFrontMatter)).toBe(true);
+      expect(test(withoutFrontMatter)).toBe(withoutFrontMatter.startsWith("---"));
     });
 
-    test.prop([fc.constantFrom("yaml", "json"), yamlSafeObject, fc.string({ maxLength: 30 })])(
+    fcTest.prop([fc.constantFrom("yaml", "json"), yamlSafeObject, fc.string({ maxLength: 30 })])(
       "should handle different languages",
-      (language, data, content) => {
+      (lang, data, content) => {
         let frontMatterContent: string;
-        if (language === "json") {
+        if (lang === "json") {
           frontMatterContent = JSON.stringify(data);
         } else {
           frontMatterContent = Object.entries(data)
@@ -414,20 +386,20 @@ if (import.meta.vitest) {
             .join("\n");
         }
 
-        const input = `---${language}\n${frontMatterContent}\n---\n${content}`;
-        matter.clearCache();
+        const input = `---${lang}\n${frontMatterContent}\n---\n${content}`;
+        clearCache();
         const result = matter(input);
 
-        expect(result.language).toBe(language);
+        expect(result.language).toBe(lang);
         expect(result.data).toEqual(data);
       },
     );
 
-    test.prop([fc.constantFrom("---", "~~~", "***", "+++")])(
+    fcTest.prop([fc.constantFrom("---", "~~~", "***", "+++")])(
       "should handle custom delimiters",
       (delimiter) => {
         const input = `${delimiter}\ntitle: Test\n${delimiter}\ncontent`;
-        matter.clearCache();
+        clearCache();
         const result = matter(input, { delimiters: delimiter });
 
         expect(result.data).toEqual({ title: "Test" });
@@ -435,7 +407,7 @@ if (import.meta.vitest) {
       },
     );
 
-    test.prop([
+    fcTest.prop([
       fc.string({ minLength: 1, maxLength: 20 }),
       fc.string({ minLength: 1, maxLength: 20 }),
     ])("should extract excerpt with custom separator", (excerptText, contentText) => {
@@ -444,22 +416,22 @@ if (import.meta.vitest) {
       const safeContent = contentText.replace(separator, "");
       const input = `---\ntitle: Test\n---\n${safeExcerpt}\n${separator}\n${safeContent}`;
 
-      matter.clearCache();
+      clearCache();
       const result = matter(input, { excerpt: true, excerpt_separator: separator });
 
       expect(result.excerpt).toBe(`${safeExcerpt}\n`);
     });
 
-    test.prop([fc.string({ minLength: 0, maxLength: 50 })])(
+    fcTest.prop([fc.string({ minLength: 0, maxLength: 50 })])(
       "should handle CRLF and LF consistently",
       (content) => {
         const yamlData = "title: Test";
         const inputLF = `---\n${yamlData}\n---\n${content}`;
         const inputCRLF = `---\r\n${yamlData}\r\n---\r\n${content}`;
 
-        matter.clearCache();
+        clearCache();
         const resultLF = matter(inputLF);
-        matter.clearCache();
+        clearCache();
         const resultCRLF = matter(inputCRLF);
 
         expect(resultLF.data).toEqual(resultCRLF.data);

package/src/types.ts

@@ -66,19 +66,3 @@ export type GrayMatterInput =
   | string
   | Uint8Array
   | { content: string; data?: Record<string, unknown> };
-
-/**
- * The matter function interface with static methods
- */
-export interface MatterFunction {
-  (input: GrayMatterInput, options?: GrayMatterOptions): GrayMatterFile;
-  stringify: (
-    file: GrayMatterFile | string,
-    data?: Record<string, unknown>,
-    options?: GrayMatterOptions,
-  ) => string;
-  test: (str: string, options?: GrayMatterOptions) => boolean;
-  language: (str: string, options?: GrayMatterOptions) => { raw: string; name: string };
-  clearCache: () => void;
-  cache: Map<string, GrayMatterFile>;
-}