gray-matter-es 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ryoppippi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,129 @@
+# gray-matter-es
+
+ESM-only [gray-matter](https://github.com/jonschlinkert/gray-matter) implementation.
+
+## Features
+
+- 🚀 ESM-only, no CommonJS
+- 📦 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
+
+## Installation
+
+```bash
+npm install gray-matter-es
+# or
+pnpm add gray-matter-es
+```
+
+## Usage
+
+```typescript
+import matter from "gray-matter-es";
+
+// Parse front matter
+const file = matter("---\ntitle: Hello\n---\nThis is content");
+console.log(file.data); // { title: 'Hello' }
+console.log(file.content); // 'This is content'
+
+// Stringify
+const str = matter.stringify("content", { title: "Hello" });
+// ---
+// 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
+
+// Detect language
+matter.language("---json\n{}\n---"); // { raw: 'json', name: 'json' }
+```
+
+### Custom Delimiters
+
+```typescript
+const file = matter("~~~\ntitle: Hello\n~~~\ncontent", {
+  delimiters: "~~~",
+});
+```
+
+### JSON Front Matter
+
+```typescript
+const file = matter('---json\n{"title": "Hello"}\n---\ncontent');
+console.log(file.data); // { title: 'Hello' }
+console.log(file.language); // 'json'
+```
+
+### Excerpt
+
+```typescript
+const file = matter("---\ntitle: Hello\n---\nexcerpt\n---\ncontent", {
+  excerpt: true,
+});
+console.log(file.excerpt); // 'excerpt\n'
+```
+
+## API
+
+### `matter(input, options?)`
+
+Parse front matter from a string or buffer.
+
+**Parameters:**
+
+- `input` - String, Buffer, or object with `content` property
+- `options` - Optional configuration
+
+**Returns:** `GrayMatterFile` object with:
+
+- `data` - Parsed front matter data
+- `content` - Content after front matter
+- `excerpt` - Extracted excerpt (if enabled)
+- `orig` - Original input as Buffer
+- `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 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.
+
+### `matter.language(str, options?)`
+
+Detect the language specified after the opening delimiter.
+
+### Options
+
+- `language` - Language to use for parsing (default: `'yaml'`)
+- `delimiters` - Custom delimiters (default: `'---'`)
+- `excerpt` - Enable excerpt extraction (`true`, string delimiter, or function)
+- `excerpt_separator` - Custom excerpt separator
+- `engines` - Custom parsing/stringifying engines
+
+## Differences from gray-matter
+
+- ESM-only (no CommonJS support)
+- Uses [`@std/yaml`](https://jsr.io/@std/yaml) instead of `js-yaml`
+- Removed JavaScript front matter engine (security: avoids `eval`)
+- Removed deprecated options (`lang`, `delims`, `parsers`)
+- Removed `section-matter` support
+- TypeScript-first with strict types
+
+## License
+
+MIT

package/dist/defaults.mjs

@@ -0,0 +1,19 @@
+import { arrayify } from "./utils.mjs";
+
+//#region src/defaults.ts
+/**
+* Apply default options
+*/
+function defaults(options) {
+	const delims = arrayify(options?.delimiters ?? "---");
+	const delimiters = delims.length === 1 ? [delims[0], delims[0]] : [delims[0], delims[1]];
+	return {
+		...options,
+		delimiters,
+		language: options?.language ?? "yaml"
+	};
+}
+
+//#endregion
+export { defaults };
+//# sourceMappingURL=defaults.mjs.map

package/dist/defaults.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.mjs","names":[],"sources":["../src/defaults.ts"],"sourcesContent":["import type { GrayMatterOptions, ResolvedOptions } from \"./types.ts\";\nimport { arrayify } from \"./utils.ts\";\n\n/**\n * Apply default options\n */\nexport function defaults(options?: GrayMatterOptions): ResolvedOptions {\n  const delims = arrayify(options?.delimiters ?? \"---\");\n  const delimiters: [string, string] =\n    delims.length === 1 ? [delims[0]!, delims[0]!] : [delims[0]!, delims[1]!];\n\n  return {\n    ...options,\n    delimiters,\n    language: options?.language ?? \"yaml\",\n  };\n}\n"],"mappings":";;;;;;AAMA,SAAgB,SAAS,SAA8C;CACrE,MAAM,SAAS,SAAS,SAAS,cAAc,MAAM;CACrD,MAAM,aACJ,OAAO,WAAW,IAAI,CAAC,OAAO,IAAK,OAAO,GAAI,GAAG,CAAC,OAAO,IAAK,OAAO,GAAI;AAE3E,QAAO;EACL,GAAG;EACH;EACA,UAAU,SAAS,YAAY;EAChC"}

package/dist/engines.d.mts

@@ -0,0 +1,8 @@
+//#region src/engines.d.ts
+/**
+* Built-in language names
+*/
+type BuiltinLanguage = "yaml" | "json";
+//#endregion
+export { BuiltinLanguage };
+//# sourceMappingURL=engines.d.mts.map

package/dist/engines.mjs

@@ -0,0 +1,63 @@
+import { toRecord } from "./utils.mjs";
+import { parse } from "./node_modules/.pnpm/@jsr_std__yaml@1.0.10/node_modules/@jsr/std__yaml/parse.mjs";
+import { stringify } from "./node_modules/.pnpm/@jsr_std__yaml@1.0.10/node_modules/@jsr/std__yaml/stringify.mjs";
+import "./node_modules/.pnpm/@jsr_std__yaml@1.0.10/node_modules/@jsr/std__yaml/mod.mjs";
+
+//#region src/engines.ts
+/**
+* Array of built-in language names for runtime validation
+*/
+const BUILTIN_LANGUAGES = ["yaml", "json"];
+/**
+* Check if value is a built-in language name
+*/
+function isBuiltinLanguage(value) {
+	return typeof value === "string" && BUILTIN_LANGUAGES.includes(value);
+}
+/**
+* Assert that value is a built-in language, returning the default if not
+*/
+function toBuiltinLanguage(value, defaultLang = "yaml") {
+	return isBuiltinLanguage(value) ? value : defaultLang;
+}
+/**
+* YAML engine using @std/yaml
+*/
+const yaml = {
+	parse: (str) => {
+		return toRecord(parse(str));
+	},
+	stringify: (data) => {
+		return stringify(data);
+	}
+};
+/**
+* JSON engine
+*/
+const json = {
+	parse: (str) => {
+		return toRecord(JSON.parse(str));
+	},
+	stringify: (data, options) => {
+		const opts = {
+			replacer: null,
+			space: 2,
+			...options
+		};
+		return JSON.stringify(data, opts.replacer, opts.space);
+	}
+};
+/**
+* Get engine by language name
+*/
+function getEngine(language) {
+	switch (language) {
+		case "yaml": return yaml;
+		case "json": return json;
+		default: throw new Error(`Unknown language: ${language}`);
+	}
+}
+
+//#endregion
+export { getEngine, toBuiltinLanguage };
+//# sourceMappingURL=engines.mjs.map

package/dist/engines.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"engines.mjs","names":["yamlParse","yamlStringify"],"sources":["../src/engines.ts"],"sourcesContent":["import { parse as yamlParse, stringify as yamlStringify } from \"@std/yaml\";\nimport type { Engine, GrayMatterOptions } from \"./types.ts\";\nimport { toRecord } from \"./utils.ts\";\n\n/**\n * Built-in language names\n */\nexport type BuiltinLanguage = \"yaml\" | \"json\";\n\n/**\n * Array of built-in language names for runtime validation\n */\nconst BUILTIN_LANGUAGES = [\"yaml\", \"json\"] as const satisfies readonly BuiltinLanguage[];\n\n/**\n * Check if value is a built-in language name\n */\nfunction isBuiltinLanguage(value: unknown): value is BuiltinLanguage {\n  return typeof value === \"string\" && BUILTIN_LANGUAGES.includes(value as BuiltinLanguage);\n}\n\n/**\n * Assert that value is a built-in language, returning the default if not\n */\nexport function toBuiltinLanguage(\n  value: unknown,\n  defaultLang: BuiltinLanguage = \"yaml\",\n): BuiltinLanguage {\n  return isBuiltinLanguage(value) ? value : defaultLang;\n}\n\n/**\n * YAML engine using @std/yaml\n */\nconst yaml = {\n  parse: (str: string): Record<string, unknown> => {\n    return toRecord(yamlParse(str));\n  },\n  stringify: (data: Record<string, unknown>): string => {\n    return yamlStringify(data);\n  },\n} as const satisfies Engine;\n\n/**\n * JSON engine\n */\nconst json = {\n  parse: (str: string): Record<string, unknown> => {\n    return toRecord(JSON.parse(str));\n  },\n  stringify: (\n    data: Record<string, unknown>,\n    options?: GrayMatterOptions & { replacer?: null; space?: number },\n  ): string => {\n    const opts = { replacer: null, space: 2, ...options };\n    return JSON.stringify(data, opts.replacer, opts.space);\n  },\n} as const satisfies Engine;\n\n/**\n * Get engine by language name\n */\nexport function getEngine(language: BuiltinLanguage): Engine {\n  switch (language) {\n    case \"yaml\":\n      return yaml;\n    case \"json\":\n      return json;\n    default:\n      throw new Error(`Unknown language: ${language satisfies never}`);\n  }\n}\n\nif (import.meta.vitest) {\n  const { fc, test } = await import(\"@fast-check/vitest\");\n\n  /** Arbitrary for YAML-safe values (no undefined, functions, symbols) */\n  const yamlSafeValue = fc.oneof(\n    fc.string(),\n    fc.integer(),\n    fc.double({ noNaN: true, noDefaultInfinity: true }),\n    fc.boolean(),\n    fc.constant(null),\n  );\n\n  /** Arbitrary for simple YAML-compatible objects */\n  const yamlSafeObject = fc.dictionary(\n    fc.string({ minLength: 1, maxLength: 20 }).filter((s) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s)),\n    yamlSafeValue,\n    { minKeys: 1, maxKeys: 5 },\n  );\n\n  describe(\"yaml engine\", () => {\n    it(\"should parse simple YAML\", () => {\n      const result = yaml.parse(\"title: Hello\\ncount: 42\");\n      expect(result).toEqual({ title: \"Hello\", count: 42 });\n    });\n\n    it(\"should return empty object for null YAML\", () => {\n      const result = yaml.parse(\"null\");\n      expect(result).toEqual({});\n    });\n\n    it(\"should stringify object to YAML\", () => {\n      const result = yaml.stringify({ title: \"Test\", count: 10 });\n      expect(result).toContain(\"title: Test\");\n      expect(result).toContain(\"count: 10\");\n    });\n\n    test.prop([yamlSafeObject])(\"should round-trip parse/stringify for safe objects\", (data) => {\n      const stringified = yaml.stringify(data);\n      const parsed = yaml.parse(stringified);\n      expect(parsed).toEqual(data);\n    });\n\n    test.prop([fc.string({ minLength: 1, maxLength: 100 }), fc.integer()])(\n      \"should preserve string and number types\",\n      (str, num) => {\n        const data = { str, num };\n        const stringified = yaml.stringify(data);\n        const parsed = yaml.parse(stringified);\n        expect(parsed.str).toBe(str);\n        expect(parsed.num).toBe(num);\n      },\n    );\n  });\n\n  describe(\"json engine\", () => {\n    it(\"should parse JSON\", () => {\n      const result = json.parse('{\"title\": \"Hello\", \"count\": 42}');\n      expect(result).toEqual({ title: \"Hello\", count: 42 });\n    });\n\n    it(\"should stringify object to JSON\", () => {\n      const result = json.stringify({ title: \"Test\" });\n      expect(JSON.parse(result)).toEqual({ title: \"Test\" });\n    });\n\n    it(\"should throw on invalid JSON\", () => {\n      expect(() => json.parse(\"not json\")).toThrow();\n    });\n\n    test.prop([\n      fc.record({\n        title: fc.string(),\n        count: fc.integer(),\n        active: fc.boolean(),\n      }),\n    ])(\"should round-trip parse/stringify\", (data) => {\n      const stringified = json.stringify(data);\n      const parsed = json.parse(stringified);\n      expect(parsed).toEqual(data);\n    });\n\n    test.prop([\n      fc.oneof(\n        fc.string(),\n        fc.integer(),\n        fc.boolean(),\n        fc.constant(null),\n        fc.array(fc.oneof(fc.string(), fc.integer(), fc.boolean(), fc.constant(null))),\n      ),\n    ])(\"should handle common JSON values\", (value) => {\n      const wrapped = { value };\n      const stringified = json.stringify(wrapped);\n      const parsed = json.parse(stringified);\n      expect(parsed).toEqual(wrapped);\n    });\n  });\n\n  describe(\"getEngine\", () => {\n    it(\"should return yaml engine\", () => {\n      expect(getEngine(\"yaml\")).toBe(yaml);\n    });\n\n    it(\"should return json engine\", () => {\n      expect(getEngine(\"json\")).toBe(json);\n    });\n  });\n\n  describe(\"isBuiltinLanguage\", () => {\n    it(\"should return true for yaml\", () => {\n      expect(isBuiltinLanguage(\"yaml\")).toBe(true);\n    });\n\n    it(\"should return true for json\", () => {\n      expect(isBuiltinLanguage(\"json\")).toBe(true);\n    });\n\n    it(\"should return false for unknown languages\", () => {\n      expect(isBuiltinLanguage(\"toml\")).toBe(false);\n      expect(isBuiltinLanguage(\"\")).toBe(false);\n    });\n\n    it(\"should return false for non-strings\", () => {\n      expect(isBuiltinLanguage(null)).toBe(false);\n      expect(isBuiltinLanguage(undefined)).toBe(false);\n      expect(isBuiltinLanguage(123)).toBe(false);\n    });\n  });\n\n  describe(\"toBuiltinLanguage\", () => {\n    it(\"should return valid language as-is\", () => {\n      expect(toBuiltinLanguage(\"yaml\")).toBe(\"yaml\");\n      expect(toBuiltinLanguage(\"json\")).toBe(\"json\");\n    });\n\n    it(\"should return default for invalid language\", () => {\n      expect(toBuiltinLanguage(\"toml\")).toBe(\"yaml\");\n      expect(toBuiltinLanguage(\"\")).toBe(\"yaml\");\n    });\n\n    it(\"should use custom default\", () => {\n      expect(toBuiltinLanguage(\"toml\", \"json\")).toBe(\"json\");\n    });\n  });\n}\n"],"mappings":";;;;;;;;;AAYA,MAAM,oBAAoB,CAAC,QAAQ,OAAO;;;;AAK1C,SAAS,kBAAkB,OAA0C;AACnE,QAAO,OAAO,UAAU,YAAY,kBAAkB,SAAS,MAAyB;;;;;AAM1F,SAAgB,kBACd,OACA,cAA+B,QACd;AACjB,QAAO,kBAAkB,MAAM,GAAG,QAAQ;;;;;AAM5C,MAAM,OAAO;CACX,QAAQ,QAAyC;AAC/C,SAAO,SAASA,MAAU,IAAI,CAAC;;CAEjC,YAAY,SAA0C;AACpD,SAAOC,UAAc,KAAK;;CAE7B;;;;AAKD,MAAM,OAAO;CACX,QAAQ,QAAyC;AAC/C,SAAO,SAAS,KAAK,MAAM,IAAI,CAAC;;CAElC,YACE,MACA,YACW;EACX,MAAM,OAAO;GAAE,UAAU;GAAM,OAAO;GAAG,GAAG;GAAS;AACrD,SAAO,KAAK,UAAU,MAAM,KAAK,UAAU,KAAK,MAAM;;CAEzD;;;;AAKD,SAAgB,UAAU,UAAmC;AAC3D,SAAQ,UAAR;EACE,KAAK,OACH,QAAO;EACT,KAAK,OACH,QAAO;EACT,QACE,OAAM,IAAI,MAAM,qBAAqB,WAA2B"}

package/dist/excerpt.mjs

@@ -0,0 +1,26 @@
+import { getStringProp } from "./utils.mjs";
+import { defaults } from "./defaults.mjs";
+
+//#region src/excerpt.ts
+/**
+* Extract excerpt from file content
+*/
+function excerpt(file, options) {
+	const opts = defaults(options);
+	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];
+	const idx = file.content.indexOf(delimiter);
+	if (idx !== -1) file.excerpt = file.content.slice(0, idx);
+	return file;
+}
+
+//#endregion
+export { excerpt };
+//# sourceMappingURL=excerpt.mjs.map

package/dist/excerpt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"excerpt.mjs","names":[],"sources":["../src/excerpt.ts"],"sourcesContent":["import { defaults } from \"./defaults.ts\";\nimport type { GrayMatterFile, GrayMatterOptions } from \"./types.ts\";\nimport { getStringProp } from \"./utils.ts\";\n\n/**\n * Extract excerpt from file content\n */\nexport function excerpt(file: GrayMatterFile, options?: GrayMatterOptions): GrayMatterFile {\n  const opts = defaults(options);\n\n  // Ensure data is an object (defensive check for external callers)\n  file.data ??= {};\n\n  if (typeof opts.excerpt === \"function\") {\n    opts.excerpt(file, opts);\n    return file;\n  }\n\n  const dataSep = getStringProp(file.data, \"excerpt_separator\");\n  const sep = dataSep !== \"\" ? dataSep : opts.excerpt_separator;\n\n  if (sep == null && (opts.excerpt === false || opts.excerpt == null)) {\n    return file;\n  }\n\n  const delimiter = typeof opts.excerpt === \"string\" ? opts.excerpt : (sep ?? opts.delimiters[0]);\n\n  // if enabled, get the excerpt defined after front-matter\n  const idx = file.content.indexOf(delimiter);\n  if (idx !== -1) {\n    file.excerpt = file.content.slice(0, idx);\n  }\n\n  return file;\n}\n\nif (import.meta.vitest) {\n  const { fc, test } = await import(\"@fast-check/vitest\");\n  const { Buffer } = await import(\"node:buffer\");\n\n  const makeFile = (content: string, data: Record<string, unknown> = {}): GrayMatterFile => ({\n    content,\n    data,\n    excerpt: \"\",\n    orig: Buffer.from(content),\n    language: \"yaml\",\n    matter: \"\",\n    isEmpty: false,\n    stringify: () => \"\",\n  });\n\n  describe(\"excerpt\", () => {\n    it(\"should extract excerpt using default delimiter\", () => {\n      const file = makeFile(\"This is excerpt\\n---\\nThis is content\");\n      const result = excerpt(file, { excerpt: true });\n      expect(result.excerpt).toBe(\"This is excerpt\\n\");\n    });\n\n    it(\"should extract excerpt using custom string delimiter\", () => {\n      const file = makeFile(\"This is excerpt\\n<!-- more -->\\nThis is content\");\n      const result = excerpt(file, { excerpt: \"<!-- more -->\" });\n      expect(result.excerpt).toBe(\"This is excerpt\\n\");\n    });\n\n    it(\"should use excerpt_separator from options\", () => {\n      const file = makeFile(\"Excerpt here\\n***\\nContent here\");\n      const result = excerpt(file, { excerpt: true, excerpt_separator: \"***\" });\n      expect(result.excerpt).toBe(\"Excerpt here\\n\");\n    });\n\n    it(\"should use excerpt_separator from file.data\", () => {\n      const file = makeFile(\"Excerpt\\n<!-- end -->\\nContent\", {\n        excerpt_separator: \"<!-- end -->\",\n      });\n      const result = excerpt(file, { excerpt: true });\n      expect(result.excerpt).toBe(\"Excerpt\\n\");\n    });\n\n    it(\"should not extract when excerpt is false\", () => {\n      const file = makeFile(\"Some content\\n---\\nMore content\");\n      const result = excerpt(file, { excerpt: false });\n      expect(result.excerpt).toBe(\"\");\n    });\n\n    it(\"should not modify when delimiter not found\", () => {\n      const file = makeFile(\"No delimiter here\");\n      const result = excerpt(file, { excerpt: true });\n      expect(result.excerpt).toBe(\"\");\n    });\n\n    it(\"should call custom excerpt function\", () => {\n      const file = makeFile(\"Custom content\");\n      const customFn = vi.fn((f: GrayMatterFile) => {\n        f.excerpt = \"Custom excerpt\";\n      });\n      const result = excerpt(file, { excerpt: customFn });\n      expect(customFn).toHaveBeenCalledOnce();\n      expect(result.excerpt).toBe(\"Custom excerpt\");\n    });\n\n    it(\"should initialize file.data if null\", () => {\n      const file = makeFile(\"content\");\n      file.data = null as unknown as Record<string, unknown>;\n      const result = excerpt(file, {});\n      expect(result.data).toEqual({});\n    });\n\n    test.prop([\n      fc.string({ minLength: 1, maxLength: 50 }),\n      fc.string({ minLength: 1, maxLength: 50 }),\n    ])(\"should extract correct excerpt when delimiter exists\", (excerptText, contentText) => {\n      const delimiter = \"---\";\n      const content = `${excerptText}\\n${delimiter}\\n${contentText}`;\n      const file = makeFile(content);\n      const result = excerpt(file, { excerpt: true });\n\n      expect(result.excerpt).toBe(`${excerptText}\\n`);\n    });\n\n    test.prop([fc.string({ minLength: 1, maxLength: 100 })])(\n      \"should not extract when no delimiter in content\",\n      (content) => {\n        const safeContent = content.replace(/---/g, \"___\");\n        const file = makeFile(safeContent);\n        const result = excerpt(file, { excerpt: true });\n        expect(result.excerpt).toBe(\"\");\n      },\n    );\n\n    test.prop([\n      fc.string({ minLength: 1, maxLength: 20 }),\n      fc.string({ minLength: 1, maxLength: 20 }),\n      fc\n        .string({ minLength: 1, maxLength: 10 })\n        .filter((s) => !s.includes(\"\\n\") && !/[[\\]{}()*+?.,\\\\^$|#]/.test(s)),\n    ])(\"should work with any custom delimiter\", (excerptText, contentText, customDelimiter) => {\n      const safeExcerpt = excerptText.replaceAll(customDelimiter, \"\");\n      if (safeExcerpt === \"\") return;\n      const content = `${safeExcerpt}\\n${customDelimiter}\\n${contentText}`;\n      const file = makeFile(content);\n      const result = excerpt(file, { excerpt: customDelimiter });\n\n      expect(result.excerpt).toBe(`${safeExcerpt}\\n`);\n    });\n  });\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,QAAQ,MAAsB,SAA6C;CACzF,MAAM,OAAO,SAAS,QAAQ;AAG9B,MAAK,SAAS,EAAE;AAEhB,KAAI,OAAO,KAAK,YAAY,YAAY;AACtC,OAAK,QAAQ,MAAM,KAAK;AACxB,SAAO;;CAGT,MAAM,UAAU,cAAc,KAAK,MAAM,oBAAoB;CAC7D,MAAM,MAAM,YAAY,KAAK,UAAU,KAAK;AAE5C,KAAI,OAAO,SAAS,KAAK,YAAY,SAAS,KAAK,WAAW,MAC5D,QAAO;CAGT,MAAM,YAAY,OAAO,KAAK,YAAY,WAAW,KAAK,UAAW,OAAO,KAAK,WAAW;CAG5F,MAAM,MAAM,KAAK,QAAQ,QAAQ,UAAU;AAC3C,KAAI,QAAQ,GACV,MAAK,UAAU,KAAK,QAAQ,MAAM,GAAG,IAAI;AAG3C,QAAO"}

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { Engine, GrayMatterFile, GrayMatterInput, GrayMatterOptions, MatterFunction, ResolvedOptions } from "./types.mjs";
+import { BuiltinLanguage } from "./engines.mjs";
+
+//#region src/index.d.ts
+
+/**
+* The matter function with all static methods
+*/
+declare const matter: MatterFunction;
+//#endregion
+export { type BuiltinLanguage, type Engine, type GrayMatterFile, type GrayMatterInput, type GrayMatterOptions, type MatterFunction, type ResolvedOptions, matter as default };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,126 @@
+import { defaults } from "./defaults.mjs";
+import { toBuiltinLanguage } from "./engines.mjs";
+import { excerpt } from "./excerpt.mjs";
+import { parse } from "./parse.mjs";
+import { stringify } from "./stringify.mjs";
+import { toFile } from "./to-file.mjs";
+import { readFileSync } from "node:fs";
+
+//#region src/index.ts
+/**
+* Cache for parsed results
+*/
+const cache = /* @__PURE__ */ new Map();
+/**
+* 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' }
+* ```
+*/
+function matterImpl(input, options) {
+	if (input === "") return {
+		...toFile(input),
+		isEmpty: true
+	};
+	let file = toFile(input);
+	const cached = cache.get(file.content);
+	if (!options) {
+		if (cached) {
+			file = { ...cached };
+			file.orig = cached.orig;
+			return file;
+		}
+		cache.set(file.content, file);
+	}
+	return parseMatter(file, options);
+}
+/**
+* Parse front matter from file
+*/
+function parseMatter(file, options) {
+	const opts = defaults(options);
+	const open = opts.delimiters[0];
+	const close = "\n" + opts.delimiters[1];
+	let str = file.content;
+	if (opts.language) file.language = opts.language;
+	const openLen = open.length;
+	if (!str.startsWith(open)) {
+		excerpt(file, opts);
+		return file;
+	}
+	if (str.at(openLen) === open.at(-1)) return file;
+	str = str.slice(openLen);
+	const len = str.length;
+	const lang = matterLanguage(str, opts);
+	if (lang.name) {
+		file.language = lang.name;
+		str = str.slice(lang.raw.length);
+	}
+	let closeIndex = str.indexOf(close);
+	if (closeIndex === -1) closeIndex = len;
+	file.matter = str.slice(0, closeIndex);
+	if (file.matter.replace(/^\s*#[^\n]+/gm, "").trim() === "") {
+		file.isEmpty = true;
+		file.empty = file.content;
+		file.data = {};
+	} else file.data = parse(toBuiltinLanguage(file.language), file.matter);
+	if (closeIndex === len) file.content = "";
+	else {
+		file.content = str.slice(closeIndex + close.length);
+		if (file.content.at(0) === "\r") file.content = file.content.slice(1);
+		if (file.content.at(0) === "\n") file.content = file.content.slice(1);
+	}
+	excerpt(file, opts);
+	return file;
+}
+/**
+* Detect the language to use, if one is defined after the
+* first front-matter delimiter.
+*/
+function matterLanguage(str, options) {
+	const opts = defaults(options);
+	const open = opts.delimiters[0];
+	if (matterTest(str, opts)) str = str.slice(open.length);
+	const language = str.slice(0, str.search(/\r?\n/));
+	return {
+		raw: language,
+		name: language ? language.trim() : ""
+	};
+}
+/**
+* Returns true if the given string has front matter.
+*/
+function matterTest(str, options) {
+	return str.startsWith(defaults(options).delimiters[0]);
+}
+/**
+* The matter function with all static methods
+*/
+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;
+
+//#endregion
+export { src_default as default };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { defaults } from \"./defaults.ts\";\nimport { toBuiltinLanguage } from \"./engines.ts\";\nimport { excerpt } from \"./excerpt.ts\";\nimport { parse } from \"./parse.ts\";\nimport { stringify } from \"./stringify.ts\";\nimport { toFile } from \"./to-file.ts\";\nimport type {\n  GrayMatterFile,\n  GrayMatterInput,\n  GrayMatterOptions,\n  MatterFunction,\n} from \"./types.ts\";\n\nexport type {\n  Engine,\n  GrayMatterFile,\n  GrayMatterInput,\n  GrayMatterOptions,\n  MatterFunction,\n  ResolvedOptions,\n} from \"./types.ts\";\n\nexport type { BuiltinLanguage } from \"./engines.ts\";\n\n/**\n * Cache for parsed results\n */\nconst cache = new Map<string, GrayMatterFile>();\n\n/**\n * Takes a string or object with `content` property, extracts\n * and parses front-matter from the string, then returns an object\n * with `data`, `content` and other useful properties.\n *\n * @example\n * ```ts\n * import matter from 'gray-matter-es';\n * console.log(matter('---\\ntitle: Home\\n---\\nOther stuff'));\n * //=> { data: { title: 'Home'}, content: 'Other stuff' }\n * ```\n */\nfunction matterImpl(input: GrayMatterInput, options?: GrayMatterOptions): GrayMatterFile {\n  if (input === \"\") {\n    return { ...toFile(input), isEmpty: true };\n  }\n\n  let file = toFile(input);\n  const cached = cache.get(file.content);\n\n  if (!options) {\n    if (cached) {\n      file = { ...cached };\n      file.orig = cached.orig;\n      return file;\n    }\n\n    // only cache if there are no options passed\n    cache.set(file.content, file);\n  }\n\n  return parseMatter(file, options);\n}\n\n/**\n * Parse front matter from file\n */\nfunction parseMatter(file: GrayMatterFile, options?: GrayMatterOptions): GrayMatterFile {\n  const opts = defaults(options);\n  const open = opts.delimiters[0];\n  const close = \"\\n\" + opts.delimiters[1];\n  let str = file.content;\n\n  if (opts.language) {\n    file.language = opts.language;\n  }\n\n  // get the length of the opening delimiter\n  const openLen = open.length;\n  if (!str.startsWith(open)) {\n    excerpt(file, opts);\n    return file;\n  }\n\n  // if the next character after the opening delimiter is\n  // a character from the delimiter, then it's not a front-\n  // matter delimiter\n  if (str.at(openLen) === open.at(-1)) {\n    return file;\n  }\n\n  // strip the opening delimiter\n  str = str.slice(openLen);\n  const len = str.length;\n\n  // use the language defined after first delimiter, if it exists\n  const lang = matterLanguage(str, opts);\n  if (lang.name) {\n    file.language = lang.name;\n    str = str.slice(lang.raw.length);\n  }\n\n  // get the index of the closing delimiter\n  let closeIndex = str.indexOf(close);\n  if (closeIndex === -1) {\n    closeIndex = len;\n  }\n\n  // get the raw front-matter block\n  file.matter = str.slice(0, closeIndex);\n\n  const block = file.matter.replace(/^\\s*#[^\\n]+/gm, \"\").trim();\n  if (block === \"\") {\n    file.isEmpty = true;\n    file.empty = file.content;\n    file.data = {};\n  } else {\n    // create file.data by parsing the raw file.matter block\n    file.data = parse(toBuiltinLanguage(file.language), file.matter);\n  }\n\n  // update file.content\n  if (closeIndex === len) {\n    file.content = \"\";\n  } else {\n    file.content = str.slice(closeIndex + close.length);\n    if (file.content.at(0) === \"\\r\") {\n      file.content = file.content.slice(1);\n    }\n    if (file.content.at(0) === \"\\n\") {\n      file.content = file.content.slice(1);\n    }\n  }\n\n  excerpt(file, opts);\n  return file;\n}\n\n/**\n * Detect the language to use, if one is defined after the\n * first front-matter delimiter.\n */\nfunction matterLanguage(str: string, options?: GrayMatterOptions): { raw: string; name: string } {\n  const opts = defaults(options);\n  const open = opts.delimiters[0];\n\n  if (matterTest(str, opts)) {\n    str = str.slice(open.length);\n  }\n\n  const language = str.slice(0, str.search(/\\r?\\n/));\n  return {\n    raw: language,\n    name: language ? language.trim() : \"\",\n  };\n}\n\n/**\n * Returns true if the given string has front matter.\n */\nfunction matterTest(str: string, options?: GrayMatterOptions): boolean {\n  return str.startsWith(defaults(options).delimiters[0]);\n}\n\n/**\n * The matter function with all static methods\n */\nconst matter: MatterFunction = Object.assign(matterImpl, {\n  /**\n   * Stringify an object to YAML or the specified language, and\n   * append it to the given string.\n   */\n  stringify: (\n    file: GrayMatterFile | string,\n    data?: Record<string, unknown>,\n    options?: GrayMatterOptions,\n  ): string => {\n    if (typeof file === \"string\") file = matterImpl(file, options);\n    return stringify(file, data, options);\n  },\n\n  /**\n   * Synchronously read a file from the file system and parse front matter.\n   */\n  read: (filepath: string, options?: GrayMatterOptions): GrayMatterFile => {\n    const str = readFileSync(filepath, \"utf8\");\n    const file = matterImpl(str, options);\n    file.path = filepath;\n    return file;\n  },\n\n  /**\n   * Returns true if the given string has front matter.\n   */\n  test: matterTest,\n\n  /**\n   * Detect the language to use, if one is defined after the\n   * first front-matter delimiter.\n   */\n  language: matterLanguage,\n\n  /**\n   * Clear the cache\n   */\n  clearCache: (): void => {\n    cache.clear();\n  },\n\n  /**\n   * Expose cache (read-only access)\n   */\n  cache,\n});\n\nexport default matter;\n\nif (import.meta.vitest) {\n  const { fc, test } = await import(\"@fast-check/vitest\");\n  const { Buffer } = await import(\"node:buffer\");\n\n  describe(\"matter\", () => {\n    beforeEach(() => {\n      matter.clearCache();\n    });\n\n    it(\"should extract YAML front matter\", () => {\n      const actual = matter(\"---\\nabc: xyz\\n---\");\n      expect(actual.data).toEqual({ abc: \"xyz\" });\n      expect(actual.content).toBe(\"\");\n    });\n\n    it(\"should extract YAML front matter with content\", () => {\n      const actual = matter(\"---\\nabc: xyz\\n---\\nfoo\");\n      expect(actual.data).toEqual({ abc: \"xyz\" });\n      expect(actual.content).toBe(\"foo\");\n    });\n\n    it(\"should return empty object for empty string\", () => {\n      const actual = matter(\"\");\n      expect(actual.data).toEqual({});\n      expect(actual.content).toBe(\"\");\n    });\n\n    it(\"should return content when no front matter\", () => {\n      const actual = matter(\"foo bar\");\n      expect(actual.data).toEqual({});\n      expect(actual.content).toBe(\"foo bar\");\n    });\n\n    it(\"should handle CRLF line endings\", () => {\n      const actual = matter(\"---\\r\\nabc: xyz\\r\\n---\\r\\ncontent\");\n      expect(actual.data).toEqual({ abc: \"xyz\" });\n      expect(actual.content).toBe(\"content\");\n    });\n\n    it(\"should detect language after delimiter\", () => {\n      const actual = matter('---json\\n{\"abc\": \"xyz\"}\\n---\\ncontent');\n      expect(actual.data).toEqual({ abc: \"xyz\" });\n      expect(actual.language).toBe(\"json\");\n    });\n\n    it(\"should handle custom delimiters\", () => {\n      const actual = matter(\"~~~\\nabc: xyz\\n~~~\\ncontent\", {\n        delimiters: \"~~~\",\n      });\n      expect(actual.data).toEqual({ abc: \"xyz\" });\n    });\n\n    it(\"should extract excerpt when enabled\", () => {\n      const actual = matter(\"---\\nabc: xyz\\n---\\nexcerpt\\n---\\ncontent\", {\n        excerpt: true,\n      });\n      expect(actual.excerpt).toBe(\"excerpt\\n\");\n    });\n\n    it(\"should use custom excerpt separator\", () => {\n      const actual = matter(\"---\\nabc: xyz\\n---\\nexcerpt\\n<!-- more -->\\ncontent\", {\n        excerpt: true,\n        excerpt_separator: \"<!-- more -->\",\n      });\n      expect(actual.excerpt).toBe(\"excerpt\\n\");\n    });\n\n    it(\"should cache results when no options\", () => {\n      const input = \"---\\nabc: xyz\\n---\";\n      const first = matter(input);\n      const second = matter(input);\n      expect(first.data).toEqual(second.data);\n    });\n\n    it(\"should not cache when options provided\", () => {\n      const input = \"---\\nabc: xyz\\n---\";\n      matter(input);\n      const second = matter(input, { language: \"yaml\" });\n      expect(second.data).toEqual({ abc: \"xyz\" });\n    });\n  });\n\n  describe(\"matter.stringify\", () => {\n    it(\"should stringify data to YAML front matter\", () => {\n      const result = matter.stringify(\"content\", { title: \"Hello\" });\n      expect(result).toContain(\"---\");\n      expect(result).toContain(\"title: Hello\");\n      expect(result).toContain(\"content\");\n    });\n\n    it(\"should stringify file object\", () => {\n      const file = matter(\"---\\ntitle: Test\\n---\\ncontent\");\n      const result = matter.stringify(file, { title: \"Updated\" });\n      expect(result).toContain(\"title: Updated\");\n    });\n  });\n\n  describe(\"matter.test\", () => {\n    it(\"should return true for string with front matter\", () => {\n      expect(matter.test(\"---\\nabc: xyz\\n---\")).toBe(true);\n    });\n\n    it(\"should return false for string without front matter\", () => {\n      expect(matter.test(\"foo bar\")).toBe(false);\n    });\n  });\n\n  describe(\"matter.language\", () => {\n    it(\"should detect language after delimiter\", () => {\n      const result = matter.language(\"---json\\n{}\\n---\");\n      expect(result.name).toBe(\"json\");\n    });\n\n    it(\"should return empty for no language\", () => {\n      const result = matter.language(\"---\\nabc: xyz\\n---\");\n      expect(result.name).toBe(\"\");\n    });\n  });\n\n  describe(\"property-based tests\", () => {\n    beforeEach(() => {\n      matter.clearCache();\n    });\n\n    /** Arbitrary for YAML-safe keys */\n    const yamlKey = fc\n      .string({ minLength: 1, maxLength: 20 })\n      .filter((s) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s));\n\n    /** Arbitrary for YAML-safe values */\n    const yamlSafeValue = fc.oneof(\n      fc.string({ maxLength: 50 }),\n      fc.integer({ min: -10000, max: 10000 }),\n      fc.boolean(),\n    );\n\n    /** Arbitrary for simple YAML-compatible objects */\n    const yamlSafeObject = fc.dictionary(yamlKey, yamlSafeValue, { minKeys: 1, maxKeys: 5 });\n\n    test.prop([fc.string({ minLength: 1, maxLength: 100 })])(\n      \"Buffer and string input should produce equivalent results\",\n      (content) => {\n        matter.clearCache();\n        const fromString = matter(content);\n        matter.clearCache();\n        const fromBuffer = matter(Buffer.from(content));\n\n        expect(fromString.content).toBe(fromBuffer.content);\n        expect(fromString.data).toEqual(fromBuffer.data);\n        expect(fromString.excerpt).toBe(fromBuffer.excerpt);\n      },\n    );\n\n    test.prop([yamlSafeObject, fc.string({ minLength: 0, maxLength: 50 })])(\n      \"parse then stringify should preserve data\",\n      (data, content) => {\n        const frontMatter = Object.entries(data)\n          .map(([k, v]) => `${k}: ${typeof v === \"string\" ? JSON.stringify(v) : v}`)\n          .join(\"\\n\");\n        const input = `---\\n${frontMatter}\\n---\\n${content}`;\n\n        matter.clearCache();\n        const parsed = matter(input);\n        const stringified = matter.stringify(parsed);\n        matter.clearCache();\n        const reparsed = matter(stringified);\n\n        expect(reparsed.data).toEqual(parsed.data);\n      },\n    );\n\n    test.prop([fc.string({ minLength: 0, maxLength: 100 })])(\n      \"content without front matter should be preserved\",\n      (content) => {\n        const safeContent = content.replace(/^---/gm, \"___\");\n        matter.clearCache();\n        const result = matter(safeContent);\n\n        expect(result.content).toBe(safeContent);\n        expect(result.data).toEqual({});\n      },\n    );\n\n    test.prop([\n      yamlSafeObject,\n      fc.string({ minLength: 0, maxLength: 50 }),\n      fc.string({ minLength: 1, maxLength: 50 }),\n    ])(\"matter.test should correctly detect front matter\", (data, content, noFrontMatter) => {\n      const frontMatter = Object.entries(data)\n        .map(([k, v]) => `${k}: ${typeof v === \"string\" ? JSON.stringify(v) : v}`)\n        .join(\"\\n\");\n      const withFrontMatter = `---\\n${frontMatter}\\n---\\n${content}`;\n      const withoutFrontMatter = noFrontMatter.replace(/^---/gm, \"___\");\n\n      expect(matter.test(withFrontMatter)).toBe(true);\n      expect(matter.test(withoutFrontMatter)).toBe(withoutFrontMatter.startsWith(\"---\"));\n    });\n\n    test.prop([fc.constantFrom(\"yaml\", \"json\"), yamlSafeObject, fc.string({ maxLength: 30 })])(\n      \"should handle different languages\",\n      (language, data, content) => {\n        let frontMatterContent: string;\n        if (language === \"json\") {\n          frontMatterContent = JSON.stringify(data);\n        } else {\n          frontMatterContent = Object.entries(data)\n            .map(([k, v]) => `${k}: ${typeof v === \"string\" ? JSON.stringify(v) : v}`)\n            .join(\"\\n\");\n        }\n\n        const input = `---${language}\\n${frontMatterContent}\\n---\\n${content}`;\n        matter.clearCache();\n        const result = matter(input);\n\n        expect(result.language).toBe(language);\n        expect(result.data).toEqual(data);\n      },\n    );\n\n    test.prop([fc.constantFrom(\"---\", \"~~~\", \"***\", \"+++\")])(\n      \"should handle custom delimiters\",\n      (delimiter) => {\n        const input = `${delimiter}\\ntitle: Test\\n${delimiter}\\ncontent`;\n        matter.clearCache();\n        const result = matter(input, { delimiters: delimiter });\n\n        expect(result.data).toEqual({ title: \"Test\" });\n        expect(result.content).toBe(\"content\");\n      },\n    );\n\n    test.prop([\n      fc.string({ minLength: 1, maxLength: 20 }),\n      fc.string({ minLength: 1, maxLength: 20 }),\n    ])(\"should extract excerpt with custom separator\", (excerptText, contentText) => {\n      const separator = \"<!-- more -->\";\n      const safeExcerpt = excerptText.replace(separator, \"\");\n      const safeContent = contentText.replace(separator, \"\");\n      const input = `---\\ntitle: Test\\n---\\n${safeExcerpt}\\n${separator}\\n${safeContent}`;\n\n      matter.clearCache();\n      const result = matter(input, { excerpt: true, excerpt_separator: separator });\n\n      expect(result.excerpt).toBe(`${safeExcerpt}\\n`);\n    });\n\n    test.prop([fc.string({ minLength: 0, maxLength: 50 })])(\n      \"should handle CRLF and LF consistently\",\n      (content) => {\n        const yamlData = \"title: Test\";\n        const inputLF = `---\\n${yamlData}\\n---\\n${content}`;\n        const inputCRLF = `---\\r\\n${yamlData}\\r\\n---\\r\\n${content}`;\n\n        matter.clearCache();\n        const resultLF = matter(inputLF);\n        matter.clearCache();\n        const resultCRLF = matter(inputCRLF);\n\n        expect(resultLF.data).toEqual(resultCRLF.data);\n        expect(resultLF.content).toBe(resultCRLF.content);\n      },\n    );\n  });\n}\n"],"mappings":";;;;;;;;;;;;AA4BA,MAAM,wBAAQ,IAAI,KAA6B;;;;;;;;;;;;;AAc/C,SAAS,WAAW,OAAwB,SAA6C;AACvF,KAAI,UAAU,GACZ,QAAO;EAAE,GAAG,OAAO,MAAM;EAAE,SAAS;EAAM;CAG5C,IAAI,OAAO,OAAO,MAAM;CACxB,MAAM,SAAS,MAAM,IAAI,KAAK,QAAQ;AAEtC,KAAI,CAAC,SAAS;AACZ,MAAI,QAAQ;AACV,UAAO,EAAE,GAAG,QAAQ;AACpB,QAAK,OAAO,OAAO;AACnB,UAAO;;AAIT,QAAM,IAAI,KAAK,SAAS,KAAK;;AAG/B,QAAO,YAAY,MAAM,QAAQ;;;;;AAMnC,SAAS,YAAY,MAAsB,SAA6C;CACtF,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,OAAO,KAAK,WAAW;CAC7B,MAAM,QAAQ,OAAO,KAAK,WAAW;CACrC,IAAI,MAAM,KAAK;AAEf,KAAI,KAAK,SACP,MAAK,WAAW,KAAK;CAIvB,MAAM,UAAU,KAAK;AACrB,KAAI,CAAC,IAAI,WAAW,KAAK,EAAE;AACzB,UAAQ,MAAM,KAAK;AACnB,SAAO;;AAMT,KAAI,IAAI,GAAG,QAAQ,KAAK,KAAK,GAAG,GAAG,CACjC,QAAO;AAIT,OAAM,IAAI,MAAM,QAAQ;CACxB,MAAM,MAAM,IAAI;CAGhB,MAAM,OAAO,eAAe,KAAK,KAAK;AACtC,KAAI,KAAK,MAAM;AACb,OAAK,WAAW,KAAK;AACrB,QAAM,IAAI,MAAM,KAAK,IAAI,OAAO;;CAIlC,IAAI,aAAa,IAAI,QAAQ,MAAM;AACnC,KAAI,eAAe,GACjB,cAAa;AAIf,MAAK,SAAS,IAAI,MAAM,GAAG,WAAW;AAGtC,KADc,KAAK,OAAO,QAAQ,iBAAiB,GAAG,CAAC,MAAM,KAC/C,IAAI;AAChB,OAAK,UAAU;AACf,OAAK,QAAQ,KAAK;AAClB,OAAK,OAAO,EAAE;OAGd,MAAK,OAAO,MAAM,kBAAkB,KAAK,SAAS,EAAE,KAAK,OAAO;AAIlE,KAAI,eAAe,IACjB,MAAK,UAAU;MACV;AACL,OAAK,UAAU,IAAI,MAAM,aAAa,MAAM,OAAO;AACnD,MAAI,KAAK,QAAQ,GAAG,EAAE,KAAK,KACzB,MAAK,UAAU,KAAK,QAAQ,MAAM,EAAE;AAEtC,MAAI,KAAK,QAAQ,GAAG,EAAE,KAAK,KACzB,MAAK,UAAU,KAAK,QAAQ,MAAM,EAAE;;AAIxC,SAAQ,MAAM,KAAK;AACnB,QAAO;;;;;;AAOT,SAAS,eAAe,KAAa,SAA4D;CAC/F,MAAM,OAAO,SAAS,QAAQ;CAC9B,MAAM,OAAO,KAAK,WAAW;AAE7B,KAAI,WAAW,KAAK,KAAK,CACvB,OAAM,IAAI,MAAM,KAAK,OAAO;CAG9B,MAAM,WAAW,IAAI,MAAM,GAAG,IAAI,OAAO,QAAQ,CAAC;AAClD,QAAO;EACL,KAAK;EACL,MAAM,WAAW,SAAS,MAAM,GAAG;EACpC;;;;;AAMH,SAAS,WAAW,KAAa,SAAsC;AACrE,QAAO,IAAI,WAAW,SAAS,QAAQ,CAAC,WAAW,GAAG;;;;;AAMxD,MAAM,SAAyB,OAAO,OAAO,YAAY;CAKvD,YACE,MACA,MACA,YACW;AACX,MAAI,OAAO,SAAS,SAAU,QAAO,WAAW,MAAM,QAAQ;AAC9D,SAAO,UAAU,MAAM,MAAM,QAAQ;;CAMvC,OAAO,UAAkB,YAAgD;EAEvE,MAAM,OAAO,WADD,aAAa,UAAU,OAAO,EACb,QAAQ;AACrC,OAAK,OAAO;AACZ,SAAO;;CAMT,MAAM;CAMN,UAAU;CAKV,kBAAwB;AACtB,QAAM,OAAO;;CAMf;CACD,CAAC;AAEF,kBAAe"}

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.10/node_modules/@jsr/std__yaml/_chars.mjs

@@ -0,0 +1,45 @@
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.10/node_modules/@jsr/std__yaml/_chars.js
+const BOM = 65279;
+const TAB = 9;
+const LINE_FEED = 10;
+const CARRIAGE_RETURN = 13;
+const SPACE = 32;
+const EXCLAMATION = 33;
+const DOUBLE_QUOTE = 34;
+const SHARP = 35;
+const PERCENT = 37;
+const AMPERSAND = 38;
+const SINGLE_QUOTE = 39;
+const ASTERISK = 42;
+const PLUS = 43;
+const COMMA = 44;
+const MINUS = 45;
+const DOT = 46;
+const COLON = 58;
+const SMALLER_THAN = 60;
+const GREATER_THAN = 62;
+const QUESTION = 63;
+const COMMERCIAL_AT = 64;
+const LEFT_SQUARE_BRACKET = 91;
+const BACKSLASH = 92;
+const RIGHT_SQUARE_BRACKET = 93;
+const GRAVE_ACCENT = 96;
+const LEFT_CURLY_BRACKET = 123;
+const VERTICAL_LINE = 124;
+const RIGHT_CURLY_BRACKET = 125;
+function isEOL(c) {
+	return c === LINE_FEED || c === CARRIAGE_RETURN;
+}
+function isWhiteSpace(c) {
+	return c === TAB || c === SPACE;
+}
+function isWhiteSpaceOrEOL(c) {
+	return isWhiteSpace(c) || isEOL(c);
+}
+function isFlowIndicator(c) {
+	return c === COMMA || c === LEFT_SQUARE_BRACKET || c === RIGHT_SQUARE_BRACKET || c === LEFT_CURLY_BRACKET || c === RIGHT_CURLY_BRACKET;
+}
+
+//#endregion
+export { AMPERSAND, ASTERISK, BACKSLASH, BOM, CARRIAGE_RETURN, COLON, COMMA, COMMERCIAL_AT, DOT, DOUBLE_QUOTE, EXCLAMATION, GRAVE_ACCENT, GREATER_THAN, LEFT_CURLY_BRACKET, LEFT_SQUARE_BRACKET, LINE_FEED, MINUS, PERCENT, PLUS, QUESTION, RIGHT_CURLY_BRACKET, RIGHT_SQUARE_BRACKET, SHARP, SINGLE_QUOTE, SMALLER_THAN, SPACE, VERTICAL_LINE, isEOL, isFlowIndicator, isWhiteSpace, isWhiteSpaceOrEOL };
+//# sourceMappingURL=_chars.mjs.map

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.10/node_modules/@jsr/std__yaml/_chars.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_chars.mjs","names":[],"sources":["../../../../../../../node_modules/.pnpm/@jsr+std__yaml@1.0.10/node_modules/@jsr/std__yaml/_chars.js"],"sourcesContent":["// Ported from js-yaml v3.13.1:\n// https://github.com/nodeca/js-yaml/commit/665aadda42349dcae869f12040d9b10ef18d12da\n// Copyright 2011-2015 by Vitaly Puzrin. All rights reserved. MIT license.\n// Copyright 2018-2025 the Deno authors. MIT license.\nexport const BOM = 0xfeff; /* BOM */ \nexport const TAB = 0x09; /* Tab */ \nexport const LINE_FEED = 0x0a; /* LF */ \nexport const CARRIAGE_RETURN = 0x0d; /* CR */ \nexport const SPACE = 0x20; /* Space */ \nexport const EXCLAMATION = 0x21; /* ! */ \nexport const DOUBLE_QUOTE = 0x22; /* \" */ \nexport const SHARP = 0x23; /* # */ \nexport const PERCENT = 0x25; /* % */ \nexport const AMPERSAND = 0x26; /* & */ \nexport const SINGLE_QUOTE = 0x27; /* ' */ \nexport const ASTERISK = 0x2a; /* * */ \nexport const PLUS = 0x2b; /* + */ \nexport const COMMA = 0x2c; /* , */ \nexport const MINUS = 0x2d; /* - */ \nexport const DOT = 0x2e; /* . */ \nexport const COLON = 0x3a; /* : */ \nexport const SMALLER_THAN = 0x3c; /* < */ \nexport const GREATER_THAN = 0x3e; /* > */ \nexport const QUESTION = 0x3f; /* ? */ \nexport const COMMERCIAL_AT = 0x40; /* @ */ \nexport const LEFT_SQUARE_BRACKET = 0x5b; /* [ */ \nexport const BACKSLASH = 0x5c; /* \\ */ \nexport const RIGHT_SQUARE_BRACKET = 0x5d; /* ] */ \nexport const GRAVE_ACCENT = 0x60; /* ` */ \nexport const LEFT_CURLY_BRACKET = 0x7b; /* { */ \nexport const VERTICAL_LINE = 0x7c; /* | */ \nexport const RIGHT_CURLY_BRACKET = 0x7d; /* } */ \nexport function isEOL(c) {\n  return c === LINE_FEED || c === CARRIAGE_RETURN;\n}\nexport function isWhiteSpace(c) {\n  return c === TAB || c === SPACE;\n}\nexport function isWhiteSpaceOrEOL(c) {\n  return isWhiteSpace(c) || isEOL(c);\n}\nexport function isFlowIndicator(c) {\n  return c === COMMA || c === LEFT_SQUARE_BRACKET || c === RIGHT_SQUARE_BRACKET || c === LEFT_CURLY_BRACKET || c === RIGHT_CURLY_BRACKET;\n}\n//# sourceMappingURL=_chars.js.map"],"x_google_ignoreList":[0],"mappings":";AAIA,MAAa,MAAM;AACnB,MAAa,MAAM;AACnB,MAAa,YAAY;AACzB,MAAa,kBAAkB;AAC/B,MAAa,QAAQ;AACrB,MAAa,cAAc;AAC3B,MAAa,eAAe;AAC5B,MAAa,QAAQ;AACrB,MAAa,UAAU;AACvB,MAAa,YAAY;AACzB,MAAa,eAAe;AAC5B,MAAa,WAAW;AACxB,MAAa,OAAO;AACpB,MAAa,QAAQ;AACrB,MAAa,QAAQ;AACrB,MAAa,MAAM;AACnB,MAAa,QAAQ;AACrB,MAAa,eAAe;AAC5B,MAAa,eAAe;AAC5B,MAAa,WAAW;AACxB,MAAa,gBAAgB;AAC7B,MAAa,sBAAsB;AACnC,MAAa,YAAY;AACzB,MAAa,uBAAuB;AACpC,MAAa,eAAe;AAC5B,MAAa,qBAAqB;AAClC,MAAa,gBAAgB;AAC7B,MAAa,sBAAsB;AACnC,SAAgB,MAAM,GAAG;AACvB,QAAO,MAAM,aAAa,MAAM;;AAElC,SAAgB,aAAa,GAAG;AAC9B,QAAO,MAAM,OAAO,MAAM;;AAE5B,SAAgB,kBAAkB,GAAG;AACnC,QAAO,aAAa,EAAE,IAAI,MAAM,EAAE;;AAEpC,SAAgB,gBAAgB,GAAG;AACjC,QAAO,MAAM,SAAS,MAAM,uBAAuB,MAAM,wBAAwB,MAAM,sBAAsB,MAAM"}