gray-matter-es 0.1.2 → 0.2.0

package/README.md

@@ -8,6 +8,8 @@ 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
 - ✅ API compatible with gray-matter
@@ -23,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'
 
@@ -39,9 +39,6 @@ const str = matter.stringify("content", { title: "Hello" });
 // ---
 // content
 
-// Read from file (Node.js)
-const fileFromDisk = matter.read("./post.md");
-
 // Test if string has front matter
 matter.test("---\ntitle: Hello\n---"); // true
 
@@ -49,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
@@ -78,11 +81,11 @@ console.log(file.excerpt); // 'excerpt\n'
 
 ### `matter(input, options?)`
 
-Parse front matter from a string or buffer.
+Parse front matter from a string or Uint8Array.
 
 **Parameters:**
 
-- `input` - String, Buffer, or object with `content` property
+- `input` - String, Uint8Array, or object with `content` property
 - `options` - Optional configuration
 
 **Returns:** `GrayMatterFile` object with:
@@ -90,28 +93,32 @@ Parse front matter from a string or buffer.
 - `data` - Parsed front matter data
 - `content` - Content after front matter
 - `excerpt` - Extracted excerpt (if enabled)
-- `orig` - Original input as Buffer
+- `orig` - Original input as Uint8Array
 - `language` - Detected/specified language
 - `matter` - Raw front matter string
 - `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.read(filepath, options?)`
-
-Synchronously read and parse a file.
-
-### `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'`)
@@ -123,7 +130,9 @@ Detect the language specified after the opening delimiter.
 ## Differences from gray-matter
 
 - ESM-only (no CommonJS support)
+- Browser-compatible (no Node.js dependencies)
 - Uses [`@std/yaml`](https://jsr.io/@std/yaml) instead of `js-yaml`
+- Removed `matter.read()` (use your own file reading)
 - Removed JavaScript front matter engine (security: avoids `eval`)
 - Removed deprecated options (`lang`, `delims`, `parsers`)
 - Removed `section-matter` support
@@ -135,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
@@ -191,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

@@ -43,8 +43,8 @@ interface GrayMatterFile {
   content: string;
   /** The extracted excerpt (if enabled) */
   excerpt: string;
-  /** The original input as a Buffer */
-  orig: Buffer;
+  /** The original input as a Uint8Array */
+  orig: Uint8Array;
   /** The detected/specified language */
   language: string;
   /** The raw front matter string (without delimiters) */
@@ -53,33 +53,16 @@ interface GrayMatterFile {
   isEmpty: boolean;
   /** The original content if isEmpty is true */
   empty?: string;
-  /** File path (set by matter.read) */
-  path?: string;
   /** Stringify the file back to a string */
   stringify: (data?: Record<string, unknown>, options?: GrayMatterOptions) => string;
 }
 /**
 * Input that can be passed to gray-matter
 */
-type GrayMatterInput = string | Buffer | {
+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;
-  read: (filepath: string, options?: GrayMatterOptions) => GrayMatterFile;
-  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
 /**
@@ -89,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

@@ -1,7 +1,6 @@
-import { readFileSync } from "node:fs";
-import { Buffer } from "node:buffer";
-
 //#region src/utils.ts
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
 /**
 * Strip BOM (Byte Order Mark) from a string
 */
@@ -9,29 +8,29 @@ function stripBom(str$1) {
 	return str$1.charCodeAt(0) === 65279 ? str$1.slice(1) : str$1;
 }
 /**
-* Returns true if `val` is a Buffer
+* Returns true if `val` is a Uint8Array
 */
-function isBuffer(val) {
-	return Buffer.isBuffer(val);
+function isUint8Array(val) {
+	return val instanceof Uint8Array;
 }
 /**
-* Returns true if `val` is a plain object (not a Buffer or other special object)
+* Returns true if `val` is a plain object (not a Uint8Array or other special object)
 */
 function isObject$1(val) {
-	return typeof val === "object" && val !== null && !Array.isArray(val) && !Buffer.isBuffer(val);
+	return typeof val === "object" && val !== null && !Array.isArray(val) && !(val instanceof Uint8Array);
 }
 /**
-* Cast `input` to a Buffer
+* Cast `input` to a Uint8Array
 */
-function toBuffer(input) {
-	return typeof input === "string" ? Buffer.from(input) : input;
+function toUint8Array(input) {
+	return typeof input === "string" ? textEncoder.encode(input) : input;
 }
 /**
 * Cast `input` to a string, stripping BOM
 */
 function toString(input) {
-	if (isBuffer(input)) return stripBom(String(input));
-	if (typeof input !== "string") throw new TypeError("expected input to be a string or buffer");
+	if (isUint8Array(input)) return stripBom(textDecoder.decode(input));
+	if (typeof input !== "string") throw new TypeError("expected input to be a string or Uint8Array");
 	return stripBom(input);
 }
 /**
@@ -2104,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)
@@ -2137,7 +2136,7 @@ const yaml = {
 		return toRecord(parse$1(str$1));
 	},
 	stringify: (data) => {
-		return stringify$1(data);
+		return stringify$2(data);
 	}
 };
 /**
@@ -2159,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}`);
 	}
 }
 
@@ -2193,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
@@ -2214,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 = {};
@@ -2265,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: toBuffer(normalized.content ?? ""),
-		language,
+		orig: toUint8Array(normalized.content ?? ""),
+		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);
 		}
 	};
 }
@@ -2295,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
@@ -2318,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) {
@@ -2334,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);
@@ -2360,43 +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);
-	},
-	read: (filepath, options) => {
-		const file = matterImpl(readFileSync(filepath, "utf8"), options);
-		file.path = filepath;
-		return file;
-	},
-	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.2",
+  "version": "0.2.0",
   "description": "ES-only gray-matter",
   "keywords": [
     "esm",

package/src/excerpt.ts

@@ -36,13 +36,12 @@ export function excerpt(file: GrayMatterFile, options?: GrayMatterOptions): Gray
 
 if (import.meta.vitest) {
   const { fc, test } = await import("@fast-check/vitest");
-  const { Buffer } = await import("node:buffer");
 
   const makeFile = (content: string, data: Record<string, unknown> = {}): GrayMatterFile => ({
     content,
     data,
     excerpt: "",
-    orig: Buffer.from(content),
+    orig: new TextEncoder().encode(content),
     language: "yaml",
     matter: "",
     isEmpty: false,

package/src/index.ts

@@ -1,23 +1,16 @@
-import { readFileSync } from "node:fs";
 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";
 
@@ -26,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
@@ -35,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 };
   }
@@ -62,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
  */
@@ -94,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);
@@ -140,89 +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);
-  },
-
-  /**
-   * Synchronously read a file from the file system and parse front matter.
-   */
-  read: (filepath: string, options?: GrayMatterOptions): GrayMatterFile => {
-    const str = readFileSync(filepath, "utf8");
-    const file = matterImpl(str, options);
-    file.path = filepath;
-    return file;
-  },
-
-  /**
-   * 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 { Buffer } = await import("node:buffer");
+  const { fc, test: fcTest } = await import("@fast-check/vitest");
 
   describe("matter", () => {
     beforeEach(() => {
-      matter.clearCache();
+      clearCache();
     });
 
     it("should extract YAML front matter", () => {
@@ -298,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");
@@ -308,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 */
@@ -355,21 +315,21 @@ 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 })])(
-      "Buffer and string input should produce equivalent results",
+    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();
-        const fromBuffer = matter(Buffer.from(content));
+        clearCache();
+        const fromUint8Array = matter(new TextEncoder().encode(content));
 
-        expect(fromString.content).toBe(fromBuffer.content);
-        expect(fromString.data).toEqual(fromBuffer.data);
-        expect(fromString.excerpt).toBe(fromBuffer.excerpt);
+        expect(fromString.content).toBe(fromUint8Array.content);
+        expect(fromString.data).toEqual(fromUint8Array.data);
+        expect(fromString.excerpt).toBe(fromUint8Array.excerpt);
       },
     );
 
-    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)
@@ -377,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);
@@ -399,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)
@@ -426,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" });
@@ -447,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) => {
@@ -456,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/stringify.ts

@@ -79,7 +79,7 @@ if (import.meta.vitest) {
         content: "hello world",
         data: { title: "Test" },
         excerpt: "",
-        orig: Buffer.from(""),
+        orig: new Uint8Array(),
         language: "yaml",
         matter: "",
         isEmpty: false,
@@ -104,7 +104,7 @@ if (import.meta.vitest) {
         content: "no newline",
         data: { key: "value" },
         excerpt: "",
-        orig: Buffer.from(""),
+        orig: new Uint8Array(),
         language: "yaml",
         matter: "",
         isEmpty: false,
@@ -119,7 +119,7 @@ if (import.meta.vitest) {
         content: "content only",
         data: {},
         excerpt: "",
-        orig: Buffer.from(""),
+        orig: new Uint8Array(),
         language: "yaml",
         matter: "",
         isEmpty: false,
@@ -134,7 +134,7 @@ if (import.meta.vitest) {
         content: "main content",
         data: { title: "Test" },
         excerpt: "This is excerpt",
-        orig: Buffer.from(""),
+        orig: new Uint8Array(),
         language: "yaml",
         matter: "",
         isEmpty: false,
@@ -155,7 +155,7 @@ if (import.meta.vitest) {
         content: "test content",
         data,
         excerpt: "",
-        orig: Buffer.from(""),
+        orig: new Uint8Array(),
         language: "yaml",
         matter: "",
         isEmpty: false,
@@ -172,14 +172,14 @@ if (import.meta.vitest) {
           content,
           data: { key: "value" },
           excerpt: "",
-          orig: Buffer.from(""),
+          orig: new Uint8Array(),
           language: "yaml",
           matter: "",
           isEmpty: false,
           stringify: () => "",
         };
         const result = stringify(file);
-        expect(typeof result).toBe("string");
+        expect(result).toBeTypeOf("string");
         expect(result.endsWith("\n")).toBe(true);
       },
     );

package/src/to-file.ts

@@ -1,12 +1,12 @@
 import type { GrayMatterFile, GrayMatterInput, GrayMatterOptions } from "./types.ts";
-import { getStringProp, isObject, toBuffer, toString } from "./utils.ts";
+import { getStringProp, isObject, toUint8Array, toString } from "./utils.ts";
 import { stringify } from "./stringify.ts";
 
 /**
  * Internal input shape after normalization
  */
 interface NormalizedInput {
-  content: string | Buffer;
+  content: string | Uint8Array;
   data?: unknown;
   language?: string;
   matter?: string;
@@ -24,7 +24,7 @@ function normalizeInput(input: GrayMatterInput): NormalizedInput {
       matter: getStringProp(input, "matter"),
     };
   }
-  // string or Buffer
+  // string or Uint8Array
   return { content: input };
 }
 
@@ -38,7 +38,7 @@ export function toFile(input: GrayMatterInput): GrayMatterFile {
   const content = toString(normalized.content ?? "");
   const language = normalized.language ?? "";
   const matter = normalized.matter ?? "";
-  const orig = toBuffer(normalized.content ?? "");
+  const orig = toUint8Array(normalized.content ?? "");
 
   const file: GrayMatterFile = {
     data,
@@ -65,7 +65,6 @@ export function toFile(input: GrayMatterInput): GrayMatterFile {
 
 if (import.meta.vitest) {
   const { fc, test } = await import("@fast-check/vitest");
-  const { Buffer } = await import("node:buffer");
 
   describe("toFile", () => {
     it("should convert string to file object", () => {
@@ -78,8 +77,8 @@ if (import.meta.vitest) {
       expect(result.matter).toBe("");
     });
 
-    it("should convert Buffer to file object", () => {
-      const result = toFile(Buffer.from("buffer content"));
+    it("should convert Uint8Array to file object", () => {
+      const result = toFile(new TextEncoder().encode("buffer content"));
       expect(result.content).toBe("buffer content");
       expect(result.data).toEqual({});
     });
@@ -90,15 +89,15 @@ if (import.meta.vitest) {
       expect(result.data).toEqual({ key: "value" });
     });
 
-    it("should preserve orig as Buffer", () => {
+    it("should preserve orig as Uint8Array", () => {
       const result = toFile("test");
-      expect(Buffer.isBuffer(result.orig)).toBe(true);
-      expect(result.orig.toString()).toBe("test");
+      expect(result.orig).toBeInstanceOf(Uint8Array);
+      expect(new TextDecoder().decode(result.orig)).toBe("test");
     });
 
     it("should set stringify as a function", () => {
       const result = toFile("content");
-      expect(typeof result.stringify).toBe("function");
+      expect(result.stringify).toBeTypeOf("function");
     });
 
     it("should initialize data to empty object if not provided", () => {
@@ -126,25 +125,24 @@ if (import.meta.vitest) {
       "should always return valid file object for any string",
       (input) => {
         const result = toFile(input);
-        expect(typeof result.content).toBe("string");
-        expect(typeof result.data).toBe("object");
+        expect(result.content).toBeTypeOf("string");
+        expect(result.data).toBeTypeOf("object");
         expect(result.data).not.toBeNull();
-        expect(typeof result.isEmpty).toBe("boolean");
-        expect(typeof result.excerpt).toBe("string");
-        expect(typeof result.language).toBe("string");
-        expect(typeof result.matter).toBe("string");
-        expect(Buffer.isBuffer(result.orig)).toBe(true);
-        expect(typeof result.stringify).toBe("function");
+        expect(result.isEmpty).toBeTypeOf("boolean");
+        expect(result.excerpt).toBeTypeOf("string");
+        expect(result.language).toBeTypeOf("string");
+        expect(result.matter).toBeTypeOf("string");
+        expect(result.orig).toBeInstanceOf(Uint8Array);
+        expect(result.stringify).toBeTypeOf("function");
       },
     );
 
     test.prop([fc.uint8Array({ minLength: 0, maxLength: 200 })])(
-      "should handle any Buffer input",
+      "should handle any Uint8Array input",
       (arr) => {
-        const buffer = Buffer.from(arr);
-        const result = toFile(buffer);
-        expect(typeof result.content).toBe("string");
-        expect(Buffer.isBuffer(result.orig)).toBe(true);
+        const result = toFile(arr);
+        expect(result.content).toBeTypeOf("string");
+        expect(result.orig).toBeInstanceOf(Uint8Array);
       },
     );
 
@@ -159,7 +157,7 @@ if (import.meta.vitest) {
       const input = data !== undefined ? { content, data } : { content };
       const result = toFile(input);
       expect(result.content).toBe(content);
-      expect(typeof result.data).toBe("object");
+      expect(result.data).toBeTypeOf("object");
       if (data !== undefined) {
         expect(result.data).toEqual(data);
       }

package/src/types.ts

@@ -45,8 +45,8 @@ export interface GrayMatterFile {
   content: string;
   /** The extracted excerpt (if enabled) */
   excerpt: string;
-  /** The original input as a Buffer */
-  orig: Buffer;
+  /** The original input as a Uint8Array */
+  orig: Uint8Array;
   /** The detected/specified language */
   language: string;
   /** The raw front matter string (without delimiters) */
@@ -55,8 +55,6 @@ export interface GrayMatterFile {
   isEmpty: boolean;
   /** The original content if isEmpty is true */
   empty?: string;
-  /** File path (set by matter.read) */
-  path?: string;
   /** Stringify the file back to a string */
   stringify: (data?: Record<string, unknown>, options?: GrayMatterOptions) => string;
 }
@@ -64,21 +62,7 @@ export interface GrayMatterFile {
 /**
  * Input that can be passed to gray-matter
  */
-export type GrayMatterInput = string | Buffer | { 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;
-  read: (filepath: string, options?: GrayMatterOptions) => GrayMatterFile;
-  test: (str: string, options?: GrayMatterOptions) => boolean;
-  language: (str: string, options?: GrayMatterOptions) => { raw: string; name: string };
-  clearCache: () => void;
-  cache: Map<string, GrayMatterFile>;
-}
+export type GrayMatterInput =
+  | string
+  | Uint8Array
+  | { content: string; data?: Record<string, unknown> };

package/src/utils.ts

@@ -1,4 +1,5 @@
-import { Buffer } from "node:buffer";
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
 
 /**
  * Strip BOM (Byte Order Mark) from a string
@@ -8,33 +9,35 @@ function stripBom(str: string): string {
 }
 
 /**
- * Returns true if `val` is a Buffer
+ * Returns true if `val` is a Uint8Array
  */
-function isBuffer(val: unknown): val is Buffer {
-  return Buffer.isBuffer(val);
+function isUint8Array(val: unknown): val is Uint8Array {
+  return val instanceof Uint8Array;
 }
 
 /**
- * Returns true if `val` is a plain object (not a Buffer or other special object)
+ * Returns true if `val` is a plain object (not a Uint8Array or other special object)
  */
 export function isObject(val: unknown): val is Record<string, unknown> {
-  return typeof val === "object" && val !== null && !Array.isArray(val) && !Buffer.isBuffer(val);
+  return (
+    typeof val === "object" && val !== null && !Array.isArray(val) && !(val instanceof Uint8Array)
+  );
 }
 
 /**
- * Cast `input` to a Buffer
+ * Cast `input` to a Uint8Array
  */
-export function toBuffer(input: string | Buffer): Buffer {
-  return typeof input === "string" ? Buffer.from(input) : input;
+export function toUint8Array(input: string | Uint8Array): Uint8Array {
+  return typeof input === "string" ? textEncoder.encode(input) : input;
 }
 
 /**
  * Cast `input` to a string, stripping BOM
  */
-export function toString(input: string | Buffer): string {
-  if (isBuffer(input)) return stripBom(String(input));
+export function toString(input: string | Uint8Array): string {
+  if (isUint8Array(input)) return stripBom(textDecoder.decode(input));
   if (typeof input !== "string") {
-    throw new TypeError("expected input to be a string or buffer");
+    throw new TypeError("expected input to be a string or Uint8Array");
   }
   return stripBom(input);
 }
@@ -111,13 +114,13 @@ if (import.meta.vitest) {
       });
     });
 
-    describe("isBuffer", () => {
-      it("should return true for Buffer", () => {
-        expect(isBuffer(Buffer.from("test"))).toBe(true);
+    describe("isUint8Array", () => {
+      it("should return true for Uint8Array", () => {
+        expect(isUint8Array(new Uint8Array([1, 2, 3]))).toBe(true);
       });
 
       it("should return false for string", () => {
-        expect(isBuffer("test")).toBe(false);
+        expect(isUint8Array("test")).toBe(false);
       });
     });
 
@@ -135,8 +138,8 @@ if (import.meta.vitest) {
         expect(isObject(null)).toBe(false);
       });
 
-      it("should return false for Buffer", () => {
-        expect(isObject(Buffer.from("test"))).toBe(false);
+      it("should return false for Uint8Array", () => {
+        expect(isObject(new Uint8Array([1, 2, 3]))).toBe(false);
       });
     });