gray-matter-es 0.1.2 → 0.1.3

package/README.md

@@ -8,6 +8,7 @@ ESM-only [gray-matter](https://github.com/jonschlinkert/gray-matter) implementat
 ## Features
 
 - 🚀 ESM-only, no CommonJS
+- 🌐 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
@@ -39,9 +40,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
 
@@ -78,11 +76,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,7 +88,7 @@ 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
@@ -100,10 +98,6 @@ Parse front matter from a string or buffer.
 
 Stringify data to front matter and append content.
 
-### `matter.read(filepath, options?)`
-
-Synchronously read and parse a file.
-
 ### `matter.test(str, options?)`
 
 Test if a string has front matter.
@@ -123,7 +117,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

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,15 +53,13 @@ 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>;
 };
@@ -71,7 +69,6 @@ type GrayMatterInput = string | Buffer | {
 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;

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);
 }
 /**
@@ -2271,7 +2270,7 @@ function toFile(input) {
 		data,
 		content,
 		excerpt: "",
-		orig: toBuffer(normalized.content ?? ""),
+		orig: toUint8Array(normalized.content ?? ""),
 		language,
 		matter: matter$1,
 		isEmpty: false,
@@ -2384,11 +2383,6 @@ const matter = Object.assign(matterImpl, {
 		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: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gray-matter-es",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "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,4 +1,3 @@
-import { readFileSync } from "node:fs";
 import { defaults } from "./defaults.ts";
 import { toBuiltinLanguage } from "./engines.ts";
 import { excerpt } from "./excerpt.ts";
@@ -179,16 +178,6 @@ const matter: MatterFunction = Object.assign(matterImpl, {
     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.
    */
@@ -218,7 +207,6 @@ export default matter;
 
 if (import.meta.vitest) {
   const { fc, test } = await import("@fast-check/vitest");
-  const { Buffer } = await import("node:buffer");
 
   describe("matter", () => {
     beforeEach(() => {
@@ -356,16 +344,16 @@ if (import.meta.vitest) {
     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",
+      "Uint8Array and string input should produce equivalent results",
       (content) => {
         matter.clearCache();
         const fromString = matter(content);
         matter.clearCache();
-        const fromBuffer = matter(Buffer.from(content));
+        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);
       },
     );
 

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,7 +62,10 @@ export interface GrayMatterFile {
 /**
  * Input that can be passed to gray-matter
  */
-export type GrayMatterInput = string | Buffer | { content: string; data?: Record<string, unknown> };
+export type GrayMatterInput =
+  | string
+  | Uint8Array
+  | { content: string; data?: Record<string, unknown> };
 
 /**
  * The matter function interface with static methods
@@ -76,7 +77,6 @@ export interface MatterFunction {
     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;

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);
       });
     });