gray-matter-es 0.0.0

package/dist/types.d.mts

@@ -0,0 +1,85 @@
+//#region src/types.d.ts
+/**
+* Engine interface for parsing and stringifying front matter
+*/
+interface Engine {
+  parse: (str: string) => Record<string, unknown>;
+  stringify?: (data: Record<string, unknown>) => string;
+}
+/**
+* Options for gray-matter
+*/
+interface GrayMatterOptions {
+  /** Language to use for parsing (default: 'yaml') */
+  language?: "yaml" | "json";
+  /** Delimiters for front matter (default: '---') */
+  delimiters?: string | [string, string];
+  /**
+  * Extract an excerpt from the content.
+  * - `true`: use the default delimiter
+  * - `string`: use this string as the delimiter
+  * - `function`: custom excerpt function
+  */
+  excerpt?: boolean | string | ((file: GrayMatterFile, options: GrayMatterOptions) => void);
+  /** Separator for excerpt in file.data */
+  excerpt_separator?: string;
+  /** Data to merge with parsed data */
+  data?: Record<string, unknown>;
+}
+/**
+* Resolved options with defaults applied
+*/
+interface ResolvedOptions extends GrayMatterOptions {
+  delimiters: [string, string];
+  language: "yaml" | "json";
+}
+/**
+* The file object returned by gray-matter
+*/
+interface GrayMatterFile {
+  /** The parsed front matter data */
+  data: Record<string, unknown>;
+  /** The content after front matter */
+  content: string;
+  /** The extracted excerpt (if enabled) */
+  excerpt: string;
+  /** The original input as a Buffer */
+  orig: Buffer;
+  /** The detected/specified language */
+  language: string;
+  /** The raw front matter string (without delimiters) */
+  matter: string;
+  /** True if front matter block was empty */
+  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 | {
+  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
+export { Engine, GrayMatterFile, GrayMatterInput, GrayMatterOptions, MatterFunction, ResolvedOptions };
+//# sourceMappingURL=types.d.mts.map

package/dist/utils.mjs

@@ -0,0 +1,60 @@
+import { Buffer } from "node:buffer";
+
+//#region src/utils.ts
+/**
+* Strip BOM (Byte Order Mark) from a string
+*/
+function stripBom(str) {
+	return str.charCodeAt(0) === 65279 ? str.slice(1) : str;
+}
+/**
+* Returns true if `val` is a Buffer
+*/
+function isBuffer(val) {
+	return Buffer.isBuffer(val);
+}
+/**
+* Returns true if `val` is a plain object (not a Buffer or other special object)
+*/
+function isObject(val) {
+	return typeof val === "object" && val !== null && !Array.isArray(val) && !Buffer.isBuffer(val);
+}
+/**
+* Cast `input` to a Buffer
+*/
+function toBuffer(input) {
+	return typeof input === "string" ? Buffer.from(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");
+	return stripBom(input);
+}
+/**
+* Cast `val` to an array
+*/
+function arrayify(val) {
+	return val ? Array.isArray(val) ? val : [val] : [];
+}
+/**
+* Asserts that `val` is a plain object and returns it typed as Record<string, unknown>
+* If `val` is not a plain object, returns an empty object
+*/
+function toRecord(val) {
+	return isObject(val) ? val : {};
+}
+/**
+* Get a string property from an object with a default value
+*/
+function getStringProp(obj, key, defaultValue = "") {
+	if (!isObject(obj)) return defaultValue;
+	const value = obj[key];
+	return typeof value === "string" ? value : defaultValue;
+}
+
+//#endregion
+export { arrayify, getStringProp, isObject, toBuffer, toRecord, toString };
+//# sourceMappingURL=utils.mjs.map

package/dist/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import { Buffer } from \"node:buffer\";\n\n/**\n * Strip BOM (Byte Order Mark) from a string\n */\nfunction stripBom(str: string): string {\n  return str.charCodeAt(0) === 0xfeff ? str.slice(1) : str;\n}\n\n/**\n * Returns true if `val` is a Buffer\n */\nfunction isBuffer(val: unknown): val is Buffer {\n  return Buffer.isBuffer(val);\n}\n\n/**\n * Returns true if `val` is a plain object (not a Buffer or other special object)\n */\nexport function isObject(val: unknown): val is Record<string, unknown> {\n  return typeof val === \"object\" && val !== null && !Array.isArray(val) && !Buffer.isBuffer(val);\n}\n\n/**\n * Cast `input` to a Buffer\n */\nexport function toBuffer(input: string | Buffer): Buffer {\n  return typeof input === \"string\" ? Buffer.from(input) : input;\n}\n\n/**\n * Cast `input` to a string, stripping BOM\n */\nexport function toString(input: string | Buffer): string {\n  if (isBuffer(input)) return stripBom(String(input));\n  if (typeof input !== \"string\") {\n    throw new TypeError(\"expected input to be a string or buffer\");\n  }\n  return stripBom(input);\n}\n\n/**\n * Cast `val` to an array\n */\nexport function arrayify<T>(val: T | T[] | undefined | null): T[] {\n  return val ? (Array.isArray(val) ? val : [val]) : [];\n}\n\n/**\n * Asserts that `val` is a plain object and returns it typed as Record<string, unknown>\n * If `val` is not a plain object, returns an empty object\n */\nexport function toRecord(val: unknown): Record<string, unknown> {\n  return isObject(val) ? val : {};\n}\n\n/**\n * Get a string property from an object with a default value\n */\nexport function getStringProp(obj: unknown, key: string, defaultValue = \"\"): string {\n  if (!isObject(obj)) return defaultValue;\n  const value = obj[key];\n  return typeof value === \"string\" ? value : defaultValue;\n}\n\nif (import.meta.vitest) {\n  describe(\"utils\", () => {\n    describe(\"toRecord\", () => {\n      it(\"should return object as-is\", () => {\n        const obj = { a: 1, b: \"hello\" };\n        expect(toRecord(obj)).toBe(obj);\n      });\n\n      it(\"should return empty object for non-objects\", () => {\n        expect(toRecord(null)).toEqual({});\n        expect(toRecord(undefined)).toEqual({});\n        expect(toRecord(\"string\")).toEqual({});\n        expect(toRecord(123)).toEqual({});\n        expect(toRecord([])).toEqual({});\n      });\n    });\n\n    describe(\"getStringProp\", () => {\n      it(\"should return string property value\", () => {\n        expect(getStringProp({ name: \"test\" }, \"name\")).toBe(\"test\");\n      });\n\n      it(\"should return default for missing property\", () => {\n        expect(getStringProp({ other: \"value\" }, \"name\")).toBe(\"\");\n        expect(getStringProp({ other: \"value\" }, \"name\", \"default\")).toBe(\"default\");\n      });\n\n      it(\"should return default for non-string property\", () => {\n        expect(getStringProp({ count: 42 }, \"count\")).toBe(\"\");\n        expect(getStringProp({ flag: true }, \"flag\")).toBe(\"\");\n      });\n\n      it(\"should return default for non-objects\", () => {\n        expect(getStringProp(null, \"name\")).toBe(\"\");\n        expect(getStringProp(\"string\", \"name\")).toBe(\"\");\n      });\n    });\n\n    describe(\"stripBom\", () => {\n      it(\"should strip BOM from string\", () => {\n        expect(stripBom(\"\\uFEFFhello\")).toBe(\"hello\");\n      });\n\n      it(\"should return string unchanged if no BOM\", () => {\n        expect(stripBom(\"hello\")).toBe(\"hello\");\n      });\n    });\n\n    describe(\"isBuffer\", () => {\n      it(\"should return true for Buffer\", () => {\n        expect(isBuffer(Buffer.from(\"test\"))).toBe(true);\n      });\n\n      it(\"should return false for string\", () => {\n        expect(isBuffer(\"test\")).toBe(false);\n      });\n    });\n\n    describe(\"isObject\", () => {\n      it(\"should return true for plain object\", () => {\n        expect(isObject({})).toBe(true);\n        expect(isObject({ a: 1 })).toBe(true);\n      });\n\n      it(\"should return false for array\", () => {\n        expect(isObject([])).toBe(false);\n      });\n\n      it(\"should return false for null\", () => {\n        expect(isObject(null)).toBe(false);\n      });\n\n      it(\"should return false for Buffer\", () => {\n        expect(isObject(Buffer.from(\"test\"))).toBe(false);\n      });\n    });\n\n    describe(\"arrayify\", () => {\n      it(\"should wrap non-array in array\", () => {\n        expect(arrayify(\"test\")).toEqual([\"test\"]);\n      });\n\n      it(\"should return array unchanged\", () => {\n        expect(arrayify([\"a\", \"b\"])).toEqual([\"a\", \"b\"]);\n      });\n\n      it(\"should return empty array for null/undefined\", () => {\n        expect(arrayify(null)).toEqual([]);\n        expect(arrayify(undefined)).toEqual([]);\n      });\n    });\n  });\n}\n"],"mappings":";;;;;;AAKA,SAAS,SAAS,KAAqB;AACrC,QAAO,IAAI,WAAW,EAAE,KAAK,QAAS,IAAI,MAAM,EAAE,GAAG;;;;;AAMvD,SAAS,SAAS,KAA6B;AAC7C,QAAO,OAAO,SAAS,IAAI;;;;;AAM7B,SAAgB,SAAS,KAA8C;AACrE,QAAO,OAAO,QAAQ,YAAY,QAAQ,QAAQ,CAAC,MAAM,QAAQ,IAAI,IAAI,CAAC,OAAO,SAAS,IAAI;;;;;AAMhG,SAAgB,SAAS,OAAgC;AACvD,QAAO,OAAO,UAAU,WAAW,OAAO,KAAK,MAAM,GAAG;;;;;AAM1D,SAAgB,SAAS,OAAgC;AACvD,KAAI,SAAS,MAAM,CAAE,QAAO,SAAS,OAAO,MAAM,CAAC;AACnD,KAAI,OAAO,UAAU,SACnB,OAAM,IAAI,UAAU,0CAA0C;AAEhE,QAAO,SAAS,MAAM;;;;;AAMxB,SAAgB,SAAY,KAAsC;AAChE,QAAO,MAAO,MAAM,QAAQ,IAAI,GAAG,MAAM,CAAC,IAAI,GAAI,EAAE;;;;;;AAOtD,SAAgB,SAAS,KAAuC;AAC9D,QAAO,SAAS,IAAI,GAAG,MAAM,EAAE;;;;;AAMjC,SAAgB,cAAc,KAAc,KAAa,eAAe,IAAY;AAClF,KAAI,CAAC,SAAS,IAAI,CAAE,QAAO;CAC3B,MAAM,QAAQ,IAAI;AAClB,QAAO,OAAO,UAAU,WAAW,QAAQ"}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "gray-matter-es",
+  "version": "0.0.0",
+  "description": "ES-only gray-matter",
+  "keywords": [
+    "esm",
+    "front-matter",
+    "gray-matter",
+    "yaml"
+  ],
+  "homepage": "https://github.com/ryoppippi/gray-matter-es#readme",
+  "bugs": {
+    "url": "https://github.com/ryoppippi/gray-matter-es/issues"
+  },
+  "license": "MIT",
+  "author": "ryoppippi",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ryoppippi/gray-matter-es.git"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@fast-check/vitest": "^0.2.0",
+    "@std/yaml": "npm:@jsr/std__yaml@^1",
+    "@types/node": "^24.0.3",
+    "bumpp": "^10.2.3",
+    "changelogithub": "^13.16.1",
+    "knip": "^5.81.0",
+    "publint": "^0.3.5",
+    "tsdown": "^0.19.0",
+    "unplugin-unused": "^0.5.0",
+    "vitest": "^4.0.15"
+  },
+  "engines": {
+    "node": ">=20.19.6"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest",
+    "typecheck": "tsgo --noEmit",
+    "lint": "pnpm --aggregate-output run '/^lint:/'",
+    "lint:oxlint": "oxlint --max-warnings=0",
+    "lint:oxfmt": "oxfmt --no-error-on-unmatched-pattern --check .",
+    "lint:knip": "knip",
+    "format": "pnpm --no-bail --aggregate-output run '/^format:/'",
+    "format:oxlint": "oxlint --max-warnings=0 --fix",
+    "format:oxfmt": "oxfmt --no-error-on-unmatched-pattern .",
+    "format:knip": "knip --fix --no-exit-code",
+    "prerelease": "pnpm run lint && pnpm run build",
+    "release": "bumpp"
+  }
+}

package/src/defaults.ts

@@ -0,0 +1,17 @@
+import type { GrayMatterOptions, ResolvedOptions } from "./types.ts";
+import { arrayify } from "./utils.ts";
+
+/**
+ * Apply default options
+ */
+export function defaults(options?: GrayMatterOptions): ResolvedOptions {
+  const delims = arrayify(options?.delimiters ?? "---");
+  const delimiters: [string, string] =
+    delims.length === 1 ? [delims[0]!, delims[0]!] : [delims[0]!, delims[1]!];
+
+  return {
+    ...options,
+    delimiters,
+    language: options?.language ?? "yaml",
+  };
+}

package/src/engines.ts

@@ -0,0 +1,217 @@
+import { parse as yamlParse, stringify as yamlStringify } from "@std/yaml";
+import type { Engine, GrayMatterOptions } from "./types.ts";
+import { toRecord } from "./utils.ts";
+
+/**
+ * Built-in language names
+ */
+export type BuiltinLanguage = "yaml" | "json";
+
+/**
+ * Array of built-in language names for runtime validation
+ */
+const BUILTIN_LANGUAGES = ["yaml", "json"] as const satisfies readonly BuiltinLanguage[];
+
+/**
+ * Check if value is a built-in language name
+ */
+function isBuiltinLanguage(value: unknown): value is BuiltinLanguage {
+  return typeof value === "string" && BUILTIN_LANGUAGES.includes(value as BuiltinLanguage);
+}
+
+/**
+ * Assert that value is a built-in language, returning the default if not
+ */
+export function toBuiltinLanguage(
+  value: unknown,
+  defaultLang: BuiltinLanguage = "yaml",
+): BuiltinLanguage {
+  return isBuiltinLanguage(value) ? value : defaultLang;
+}
+
+/**
+ * YAML engine using @std/yaml
+ */
+const yaml = {
+  parse: (str: string): Record<string, unknown> => {
+    return toRecord(yamlParse(str));
+  },
+  stringify: (data: Record<string, unknown>): string => {
+    return yamlStringify(data);
+  },
+} as const satisfies Engine;
+
+/**
+ * JSON engine
+ */
+const json = {
+  parse: (str: string): Record<string, unknown> => {
+    return toRecord(JSON.parse(str));
+  },
+  stringify: (
+    data: Record<string, unknown>,
+    options?: GrayMatterOptions & { replacer?: null; space?: number },
+  ): string => {
+    const opts = { replacer: null, space: 2, ...options };
+    return JSON.stringify(data, opts.replacer, opts.space);
+  },
+} as const satisfies Engine;
+
+/**
+ * Get engine by language name
+ */
+export function getEngine(language: BuiltinLanguage): Engine {
+  switch (language) {
+    case "yaml":
+      return yaml;
+    case "json":
+      return json;
+    default:
+      throw new Error(`Unknown language: ${language satisfies never}`);
+  }
+}
+
+if (import.meta.vitest) {
+  const { fc, test } = await import("@fast-check/vitest");
+
+  /** Arbitrary for YAML-safe values (no undefined, functions, symbols) */
+  const yamlSafeValue = fc.oneof(
+    fc.string(),
+    fc.integer(),
+    fc.double({ noNaN: true, noDefaultInfinity: true }),
+    fc.boolean(),
+    fc.constant(null),
+  );
+
+  /** Arbitrary for simple YAML-compatible objects */
+  const yamlSafeObject = fc.dictionary(
+    fc.string({ minLength: 1, maxLength: 20 }).filter((s) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s)),
+    yamlSafeValue,
+    { minKeys: 1, maxKeys: 5 },
+  );
+
+  describe("yaml engine", () => {
+    it("should parse simple YAML", () => {
+      const result = yaml.parse("title: Hello\ncount: 42");
+      expect(result).toEqual({ title: "Hello", count: 42 });
+    });
+
+    it("should return empty object for null YAML", () => {
+      const result = yaml.parse("null");
+      expect(result).toEqual({});
+    });
+
+    it("should stringify object to YAML", () => {
+      const result = yaml.stringify({ title: "Test", count: 10 });
+      expect(result).toContain("title: Test");
+      expect(result).toContain("count: 10");
+    });
+
+    test.prop([yamlSafeObject])("should round-trip parse/stringify for safe objects", (data) => {
+      const stringified = yaml.stringify(data);
+      const parsed = yaml.parse(stringified);
+      expect(parsed).toEqual(data);
+    });
+
+    test.prop([fc.string({ minLength: 1, maxLength: 100 }), fc.integer()])(
+      "should preserve string and number types",
+      (str, num) => {
+        const data = { str, num };
+        const stringified = yaml.stringify(data);
+        const parsed = yaml.parse(stringified);
+        expect(parsed.str).toBe(str);
+        expect(parsed.num).toBe(num);
+      },
+    );
+  });
+
+  describe("json engine", () => {
+    it("should parse JSON", () => {
+      const result = json.parse('{"title": "Hello", "count": 42}');
+      expect(result).toEqual({ title: "Hello", count: 42 });
+    });
+
+    it("should stringify object to JSON", () => {
+      const result = json.stringify({ title: "Test" });
+      expect(JSON.parse(result)).toEqual({ title: "Test" });
+    });
+
+    it("should throw on invalid JSON", () => {
+      expect(() => json.parse("not json")).toThrow();
+    });
+
+    test.prop([
+      fc.record({
+        title: fc.string(),
+        count: fc.integer(),
+        active: fc.boolean(),
+      }),
+    ])("should round-trip parse/stringify", (data) => {
+      const stringified = json.stringify(data);
+      const parsed = json.parse(stringified);
+      expect(parsed).toEqual(data);
+    });
+
+    test.prop([
+      fc.oneof(
+        fc.string(),
+        fc.integer(),
+        fc.boolean(),
+        fc.constant(null),
+        fc.array(fc.oneof(fc.string(), fc.integer(), fc.boolean(), fc.constant(null))),
+      ),
+    ])("should handle common JSON values", (value) => {
+      const wrapped = { value };
+      const stringified = json.stringify(wrapped);
+      const parsed = json.parse(stringified);
+      expect(parsed).toEqual(wrapped);
+    });
+  });
+
+  describe("getEngine", () => {
+    it("should return yaml engine", () => {
+      expect(getEngine("yaml")).toBe(yaml);
+    });
+
+    it("should return json engine", () => {
+      expect(getEngine("json")).toBe(json);
+    });
+  });
+
+  describe("isBuiltinLanguage", () => {
+    it("should return true for yaml", () => {
+      expect(isBuiltinLanguage("yaml")).toBe(true);
+    });
+
+    it("should return true for json", () => {
+      expect(isBuiltinLanguage("json")).toBe(true);
+    });
+
+    it("should return false for unknown languages", () => {
+      expect(isBuiltinLanguage("toml")).toBe(false);
+      expect(isBuiltinLanguage("")).toBe(false);
+    });
+
+    it("should return false for non-strings", () => {
+      expect(isBuiltinLanguage(null)).toBe(false);
+      expect(isBuiltinLanguage(undefined)).toBe(false);
+      expect(isBuiltinLanguage(123)).toBe(false);
+    });
+  });
+
+  describe("toBuiltinLanguage", () => {
+    it("should return valid language as-is", () => {
+      expect(toBuiltinLanguage("yaml")).toBe("yaml");
+      expect(toBuiltinLanguage("json")).toBe("json");
+    });
+
+    it("should return default for invalid language", () => {
+      expect(toBuiltinLanguage("toml")).toBe("yaml");
+      expect(toBuiltinLanguage("")).toBe("yaml");
+    });
+
+    it("should use custom default", () => {
+      expect(toBuiltinLanguage("toml", "json")).toBe("json");
+    });
+  });
+}

package/src/excerpt.ts

@@ -0,0 +1,146 @@
+import { defaults } from "./defaults.ts";
+import type { GrayMatterFile, GrayMatterOptions } from "./types.ts";
+import { getStringProp } from "./utils.ts";
+
+/**
+ * Extract excerpt from file content
+ */
+export function excerpt(file: GrayMatterFile, options?: GrayMatterOptions): GrayMatterFile {
+  const opts = defaults(options);
+
+  // Ensure data is an object (defensive check for external callers)
+  file.data ??= {};
+
+  if (typeof opts.excerpt === "function") {
+    opts.excerpt(file, opts);
+    return file;
+  }
+
+  const dataSep = getStringProp(file.data, "excerpt_separator");
+  const sep = dataSep !== "" ? dataSep : opts.excerpt_separator;
+
+  if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {
+    return file;
+  }
+
+  const delimiter = typeof opts.excerpt === "string" ? opts.excerpt : (sep ?? opts.delimiters[0]);
+
+  // if enabled, get the excerpt defined after front-matter
+  const idx = file.content.indexOf(delimiter);
+  if (idx !== -1) {
+    file.excerpt = file.content.slice(0, idx);
+  }
+
+  return file;
+}
+
+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),
+    language: "yaml",
+    matter: "",
+    isEmpty: false,
+    stringify: () => "",
+  });
+
+  describe("excerpt", () => {
+    it("should extract excerpt using default delimiter", () => {
+      const file = makeFile("This is excerpt\n---\nThis is content");
+      const result = excerpt(file, { excerpt: true });
+      expect(result.excerpt).toBe("This is excerpt\n");
+    });
+
+    it("should extract excerpt using custom string delimiter", () => {
+      const file = makeFile("This is excerpt\n<!-- more -->\nThis is content");
+      const result = excerpt(file, { excerpt: "<!-- more -->" });
+      expect(result.excerpt).toBe("This is excerpt\n");
+    });
+
+    it("should use excerpt_separator from options", () => {
+      const file = makeFile("Excerpt here\n***\nContent here");
+      const result = excerpt(file, { excerpt: true, excerpt_separator: "***" });
+      expect(result.excerpt).toBe("Excerpt here\n");
+    });
+
+    it("should use excerpt_separator from file.data", () => {
+      const file = makeFile("Excerpt\n<!-- end -->\nContent", {
+        excerpt_separator: "<!-- end -->",
+      });
+      const result = excerpt(file, { excerpt: true });
+      expect(result.excerpt).toBe("Excerpt\n");
+    });
+
+    it("should not extract when excerpt is false", () => {
+      const file = makeFile("Some content\n---\nMore content");
+      const result = excerpt(file, { excerpt: false });
+      expect(result.excerpt).toBe("");
+    });
+
+    it("should not modify when delimiter not found", () => {
+      const file = makeFile("No delimiter here");
+      const result = excerpt(file, { excerpt: true });
+      expect(result.excerpt).toBe("");
+    });
+
+    it("should call custom excerpt function", () => {
+      const file = makeFile("Custom content");
+      const customFn = vi.fn((f: GrayMatterFile) => {
+        f.excerpt = "Custom excerpt";
+      });
+      const result = excerpt(file, { excerpt: customFn });
+      expect(customFn).toHaveBeenCalledOnce();
+      expect(result.excerpt).toBe("Custom excerpt");
+    });
+
+    it("should initialize file.data if null", () => {
+      const file = makeFile("content");
+      file.data = null as unknown as Record<string, unknown>;
+      const result = excerpt(file, {});
+      expect(result.data).toEqual({});
+    });
+
+    test.prop([
+      fc.string({ minLength: 1, maxLength: 50 }),
+      fc.string({ minLength: 1, maxLength: 50 }),
+    ])("should extract correct excerpt when delimiter exists", (excerptText, contentText) => {
+      const delimiter = "---";
+      const content = `${excerptText}\n${delimiter}\n${contentText}`;
+      const file = makeFile(content);
+      const result = excerpt(file, { excerpt: true });
+
+      expect(result.excerpt).toBe(`${excerptText}\n`);
+    });
+
+    test.prop([fc.string({ minLength: 1, maxLength: 100 })])(
+      "should not extract when no delimiter in content",
+      (content) => {
+        const safeContent = content.replace(/---/g, "___");
+        const file = makeFile(safeContent);
+        const result = excerpt(file, { excerpt: true });
+        expect(result.excerpt).toBe("");
+      },
+    );
+
+    test.prop([
+      fc.string({ minLength: 1, maxLength: 20 }),
+      fc.string({ minLength: 1, maxLength: 20 }),
+      fc
+        .string({ minLength: 1, maxLength: 10 })
+        .filter((s) => !s.includes("\n") && !/[[\]{}()*+?.,\\^$|#]/.test(s)),
+    ])("should work with any custom delimiter", (excerptText, contentText, customDelimiter) => {
+      const safeExcerpt = excerptText.replaceAll(customDelimiter, "");
+      if (safeExcerpt === "") return;
+      const content = `${safeExcerpt}\n${customDelimiter}\n${contentText}`;
+      const file = makeFile(content);
+      const result = excerpt(file, { excerpt: customDelimiter });
+
+      expect(result.excerpt).toBe(`${safeExcerpt}\n`);
+    });
+  });
+}