writr 3.2.3 → 4.1.0

package/README.md

@@ -3,7 +3,7 @@
 ---
 
 ## Markdown Rendering Simplified
-[![Build](https://github.com/jaredwray/writr/actions/workflows/tests.yml/badge.svg)](https://github.com/jaredwray/writr/actions/workflows/tests.yml)
+[![tests](https://github.com/jaredwray/writr/actions/workflows/tests.yml/badge.svg)](https://github.com/jaredwray/writr/actions/workflows/tests.yml)
 [![GitHub license](https://img.shields.io/github/license/jaredwray/writr)](https://github.com/jaredwray/writr/blob/master/LICENSE)
 [![codecov](https://codecov.io/gh/jaredwray/writr/branch/master/graph/badge.svg?token=1YdMesM07X)](https://codecov.io/gh/jaredwray/writr)
 [![npm](https://img.shields.io/npm/dm/writr)](https://npmjs.com/package/writr)
@@ -16,8 +16,9 @@
 - [License - MIT](#license)
 
 ## Features
-* Takes the complexity of Remark and makes it easy to use.
-* Simpke to use and easy API
+* Removes the remark / unified complexity and easy to use.
+* Built in caching 💥 making it render very fast when there isnt a change
+* Frontmatter support built in by default. :tada:
 * Easily Render to `React` or `HTML`.
 * Generates a Table of Contents for your markdown files (remark-toc).
 * Slug generation for your markdown files (rehype-slug).
@@ -27,67 +28,65 @@
 * Github Flavor Markdown (remark-gfm).
 * Emoji Support (remark-emoji).
 * MDX Support (remark-mdx).
+* ESM and Node 20+
 
 ## Getting Started 
 
-## 1. Install Writr
+## Install Writr
 
 ```bash
 > npm install writr
 ```
 
-## 2. Render from Markdown
+Then you can use it like this:
 
 ```javascript
 import { Writr } from 'writr';
 
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
 
-const html = await writr.render(markdown); // <h1>Hello World 🙂</h1><p>This is a test.</p>
+const html = await writr.render(); // <h1>Hello World 🙂</h1><p>This is a test.</p>
 ```
 Its just that simple. Want to add some options? No problem.
 
 ```javascript
 import { Writr } from 'writr';
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
 const options  = {
 	emoji: false
 }
-const html = await writr.render(markdown, options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
-```
-
-Want to render to a translation? No problem.
-
-```javascript
-import { Writr } from 'writr';
-const writr = new Writr({ openai: 'your-api-key'});
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const langCode = 'es';
-const html = await writr.renderTranslation(markdown, langCode, options); // <h1>Hola Mundo 🙂</h1><p>Esta es una prueba.</p>
+const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
 ```
 
-How about generating keywords and descriptions for your front matter?
+An example passing in the options also via the constructor:
 
 ```javascript
-import { Writr } from 'writr';
-const writr = new Writr({ openai: 'your-api-key'});
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const keywords = await writr.keywords(markdown); // ['Hello World', 'Test']
-const description = await writr.description(markdown); // 'Hello World Test'
+import { Writr, WritrOptions } from 'writr';
+const writrOptions = {
+  renderOptions: {
+    emoji: true,
+    toc: true,
+    slug: true,
+    highlight: true,
+    gfm: true,
+    math: true,
+    mdx: true,
+    caching: true,
+  }
+};
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`, writrOptions);
+const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
 ```
 
 ## API
 
-### `new Writr(options?: WritrOptions)`
+### `new Writr(arg?: string | WritrOptions, options?: WritrOptions)` 
 
-You can access the `WritrOptions` from the instance of Writr. Here is an example of WritrOptions.
+By default the constructor takes in a markdown `string` or `WritrOptions` in the first parameter. You can also send in nothing and set the markdown via `.content` property. If you want to pass in your markdown and options you can easily do this with `new Writr('## Your Markdown Here', { ...options here})`. You can access the `WritrOptions` from the instance of Writr. Here is an example of WritrOptions.
 
 ```javascript
 import { Writr, WritrOptions } from 'writr';
 const writrOptions = {
-  openai: 'your-api-key', // openai api key (default: undefined)
   renderOptions: {
     emoji: true,
     toc: true,
@@ -95,22 +94,59 @@ const writrOptions = {
     highlight: true,
     gfm: true,
     math: true,
-    mdx: true
+    mdx: true,
+    caching: true,
   }
 };
 const writr = new Writr(writrOptions);
 ```
 
-### `.engine`
+### `.content`
 
-Accessing the underlying engine for this instance of Writr. This is a `Processor<Root, Root, Root, undefined, undefined>` fromt the unified `.use()` function. You can use this to add additional plugins to the engine.
+Setting the markdown content for the instance of Writr. This can be set via the constructor or directly on the instance and can even handle `frontmatter`.
 
+```javascript
+
+import { Writr } from 'writr';
+const writr = new Writr();
+writr.content = `---
+title: Hello World
+---
+# Hello World ::-):\n\n This is a test.`;
+```
 
 ### `.options`
 
 Accessing the default options for this instance of Writr.
 
-### `.render(markdown: string, options?: RenderOptions): Promise<string>`
+### `.cache`
+
+Accessing the cache for this instance of Writr. By default this is an in memory cache and is enabled by default. You can disable this by setting `caching: false` in the `RenderOptions` of the `WritrOptions` or when calling render passing the `RenderOptions` like here:
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const options  = {
+  caching: false
+}
+const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
+```
+
+If you would like to use a specific storage adapter from https://keyv.org you can pass in the adapter like so:
+
+```javascript
+import { Writr } from 'writr';
+import Keyv from '@keyv/redis';
+const keyvRedis = new Keyv('redis://user:pass@localhost:6379');
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+writr.cache.setStorageAdapter(keyvRedis);
+```
+
+### `.engine`
+
+Accessing the underlying engine for this instance of Writr. This is a `Processor<Root, Root, Root, undefined, undefined>` fro the unified `.use()` function. You can use this to add additional plugins to the engine.
+
+### `.render(options?: RenderOptions): Promise<string>`
 
 Rendering markdown to HTML. the options are based on RenderOptions. Which you can access from the Writr instance.
 
@@ -120,48 +156,76 @@ import { Writr, RenderOptions } from 'writr';
 ## `RenderOptions`
 
 ```js
-interface RenderOptions {
-  emoji?: boolean; // emoji support
-  toc?: boolean; // table of contents generation
-  slug?: boolean; // slug generation
-  highlight?: boolean; // code highlighting
-  gfm?: boolean; // github flavor markdown
-}
+type RenderOptions = {
+	emoji?: boolean; // Emoji support (default: true)
+	toc?: boolean; // Table of contents generation (default: true)
+	slug?: boolean; // Slug generation (default: true)
+	highlight?: boolean; // Code highlighting (default: true)
+	gfm?: boolean; // Github flavor markdown (default: true)
+	math?: boolean; // Math support (default: true)
+	mdx?: boolean; // MDX support (default: true)
+	caching?: boolean; // Caching (default: true)
+};
 ```
 
-### `.renderSync(markdown: string, options?: RenderOptions): string`
+### `.renderSync(options?: RenderOptions): string`
 
 Rendering markdown to HTML synchronously. the options are based on RenderOptions. Which you can access from the Writr instance. The parameters are the same as the `.render()` function.
 
 ```javascript
 import { Writr } from 'writr';
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const html = writr.renderSync(markdown); // <h1>Hello World 🙂</h1><p>This is a test.</p>
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const html = writr.renderSync(); // <h1>Hello World 🙂</h1><p>This is a test.</p>
 ```
 
-### '.renderReact(markdown: string, options?: RenderOptions, reactOptions?: HTMLReactParserOptions): Promise<React.JSX.Element />'
+### '.renderReact(options?: RenderOptions, reactOptions?: HTMLReactParserOptions): Promise<React.JSX.Element />'
 
 Rendering markdown to React. The options are based on RenderOptions and now HTMLReactParserOptions from `html-react-parser`.
 
 ```javascript
 import { Writr } from 'writr';
-const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const reactElement = await writr.renderReact(markdown); // Will return a React.JSX.Element
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const reactElement = await writr.renderReact(); // Will return a React.JSX.Element
 ```
 
-### '.renderReactSync(markdown: string, options?: RenderOptions, reactOptions?: HTMLReactParserOptions): React.JSX.Element'
+### '.renderReactSync( options?: RenderOptions, reactOptions?: HTMLReactParserOptions): React.JSX.Element'
 
 Rendering markdown to React. The options are based on RenderOptions and now HTMLReactParserOptions from `html-react-parser`.
 
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+const reactElement = writr.renderReactSync(); // Will return a React.JSX.Element
+```
+
+### `.loadFromFile(filePath: string): Promise<void>`
+
+Load your markdown content from a file path.
+
 ```javascript
 import { Writr } from 'writr';
 const writr = new Writr();
-const markdown = `# Hello World ::-):\n\n This is a test.`;
-const reactElement = writr.renderReactSync(markdown); // Will return a React.JSX.Element
+await writr.loadFromFile('path/to/file.md');
 ```
 
+### `.loadFromFileSync(filePath: string): void`
+
+Load your markdown content from a file path synchronously.
+
+### `.saveToFile(filePath: string): Promise<void>`
+
+Save your markdown and frontmatter (if included) content to a file path.
+
+```javascript
+import { Writr } from 'writr';
+const writr = new Writr(`# Hello World ::-):\n\n This is a test.`);
+await writr.saveToFile('path/to/file.md');
+```
+
+### `.saveToFileSync(filePath: string): void`
+
+Save your markdown and frontmatter (if included) content to a file path synchronously.
+
 ## Code of Conduct and Contributing
 [Code of Conduct](CODE_OF_CONDUCT.md) and [Contributing](CONTRIBUTING.md) guidelines.
 

package/dist/writr.cjs

@@ -0,0 +1,321 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/writr.ts
+var writr_exports = {};
+__export(writr_exports, {
+  Writr: () => Writr
+});
+module.exports = __toCommonJS(writr_exports);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = require("path");
+var import_unified = require("unified");
+var import_remark_parse = __toESM(require("remark-parse"), 1);
+var import_remark_rehype = __toESM(require("remark-rehype"), 1);
+var import_rehype_slug = __toESM(require("rehype-slug"), 1);
+var import_rehype_highlight = __toESM(require("rehype-highlight"), 1);
+var import_rehype_stringify = __toESM(require("rehype-stringify"), 1);
+var import_remark_toc = __toESM(require("remark-toc"), 1);
+var import_remark_math = __toESM(require("remark-math"), 1);
+var import_rehype_katex = __toESM(require("rehype-katex"), 1);
+var import_remark_gfm = __toESM(require("remark-gfm"), 1);
+var import_remark_emoji = __toESM(require("remark-emoji"), 1);
+var import_remark_mdx = __toESM(require("remark-mdx"), 1);
+var import_html_react_parser = __toESM(require("html-react-parser"), 1);
+var yaml = __toESM(require("js-yaml"), 1);
+
+// src/writr-cache.ts
+var import_node_crypto = require("crypto");
+var import_cacheable = require("cacheable");
+var WritrCache = class {
+  _markdownStore = new import_cacheable.Cacheable();
+  _markdownStoreSync = new import_cacheable.CacheableMemory();
+  _hashStore = new import_cacheable.CacheableMemory();
+  get markdownStore() {
+    return this._markdownStore;
+  }
+  get markdownStoreSync() {
+    return this._markdownStoreSync;
+  }
+  get hashStore() {
+    return this._hashStore;
+  }
+  async getMarkdown(markdown, options) {
+    const key = this.hash(markdown, options);
+    return this.get(key);
+  }
+  getMarkdownSync(markdown, options) {
+    const key = this.hash(markdown, options);
+    return this.getSync(key);
+  }
+  async setMarkdown(markdown, value, options) {
+    const key = this.hash(markdown, options);
+    return this.set(key, value);
+  }
+  setMarkdownSync(markdown, value, options) {
+    const key = this.hash(markdown, options);
+    this.setSync(key, value);
+    return true;
+  }
+  async get(key) {
+    return this._markdownStore.get(key);
+  }
+  getSync(key) {
+    return this._markdownStoreSync.get(key);
+  }
+  async set(key, value) {
+    return this._markdownStore.set(key, value);
+  }
+  setSync(key, value) {
+    this._markdownStoreSync.set(key, value);
+    return true;
+  }
+  async clear() {
+    await this._markdownStore.clear();
+    this._markdownStoreSync.clear();
+    this._hashStore.clear();
+  }
+  setStorageAdapter(adapter) {
+    this._markdownStore = new import_cacheable.Cacheable({ primary: adapter });
+  }
+  hash(markdown, options) {
+    const key = JSON.stringify({ markdown, options });
+    let result = this._hashStore.get(key);
+    if (result) {
+      return result;
+    }
+    result = (0, import_node_crypto.createHash)("sha256").update(key).digest("hex");
+    this._hashStore.set(key, result);
+    return result;
+  }
+};
+
+// src/writr.ts
+var Writr = class {
+  engine = (0, import_unified.unified)().use(import_remark_parse.default).use(import_remark_gfm.default).use(import_remark_toc.default).use(import_remark_emoji.default).use(import_remark_rehype.default).use(import_rehype_slug.default).use(import_remark_math.default).use(import_rehype_katex.default).use(import_rehype_highlight.default).use(import_remark_mdx.default).use(import_rehype_stringify.default);
+  // Stringify HTML
+  _options = {
+    openai: void 0,
+    renderOptions: {
+      emoji: true,
+      toc: true,
+      slug: true,
+      highlight: true,
+      gfm: true,
+      math: true,
+      mdx: true,
+      caching: true
+    }
+  };
+  _content = "";
+  _cache = new WritrCache();
+  constructor(arguments1, arguments2) {
+    if (typeof arguments1 === "string") {
+      this._content = arguments1;
+    } else if (arguments1) {
+      this._options = { ...this._options, ...arguments1 };
+      if (this._options.renderOptions) {
+        this.engine = this.createProcessor(this._options.renderOptions);
+      }
+    }
+    if (arguments2) {
+      this._options = { ...this._options, ...arguments2 };
+      if (this._options.renderOptions) {
+        this.engine = this.createProcessor(this._options.renderOptions);
+      }
+    }
+  }
+  get options() {
+    return this._options;
+  }
+  get content() {
+    return this._content;
+  }
+  set content(value) {
+    this._content = value;
+  }
+  get cache() {
+    return this._cache;
+  }
+  get frontMatterRaw() {
+    const start = this._content.indexOf("---\n");
+    if (start === -1) {
+      return "";
+    }
+    const end = this._content.indexOf("\n---\n", start + 4);
+    if (end === -1) {
+      return "";
+    }
+    return this._content.slice(start, end + 5);
+  }
+  get body() {
+    const start = this._content.indexOf("---\n");
+    if (start === -1) {
+      return this._content;
+    }
+    const end = this._content.indexOf("\n---\n", start + 4);
+    if (end === -1) {
+      return this._content;
+    }
+    return this._content.slice(Math.max(0, end + 5)).trim();
+  }
+  get markdown() {
+    return this.body;
+  }
+  get frontMatter() {
+    const frontMatter = this.frontMatterRaw;
+    const match = /^---\s*([\s\S]*?)\s*---\s*/.exec(frontMatter);
+    if (match) {
+      return yaml.load(match[1].trim());
+    }
+    return {};
+  }
+  set frontMatter(data) {
+    const frontMatter = this.frontMatterRaw;
+    const yamlString = yaml.dump(data);
+    const newFrontMatter = `---
+${yamlString}---
+`;
+    this._content = this._content.replace(frontMatter, newFrontMatter);
+  }
+  getFrontMatterValue(key) {
+    return this.frontMatter[key];
+  }
+  async render(options) {
+    try {
+      let result = "";
+      if (this.isCacheEnabled(options)) {
+        const cached = await this._cache.getMarkdown(this._content, options);
+        if (cached) {
+          return cached;
+        }
+      }
+      let { engine } = this;
+      if (options) {
+        options = { ...this._options.renderOptions, ...options };
+        engine = this.createProcessor(options);
+      }
+      const file = await engine.process(this.body);
+      result = String(file);
+      if (this.isCacheEnabled(options)) {
+        await this._cache.setMarkdown(this._content, result, options);
+      }
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to render markdown: ${error.message}`);
+    }
+  }
+  renderSync(options) {
+    try {
+      let result = "";
+      if (this.isCacheEnabled(options)) {
+        const cached = this._cache.getMarkdownSync(this._content, options);
+        if (cached) {
+          return cached;
+        }
+      }
+      let { engine } = this;
+      if (options) {
+        options = { ...this._options.renderOptions, ...options };
+        engine = this.createProcessor(options);
+      }
+      const file = engine.processSync(this.body);
+      result = String(file);
+      if (this.isCacheEnabled(options)) {
+        this._cache.setMarkdownSync(this._content, result, options);
+      }
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to render markdown: ${error.message}`);
+    }
+  }
+  async renderReact(options, reactParseOptions) {
+    const html = await this.render(options);
+    return (0, import_html_react_parser.default)(html, reactParseOptions);
+  }
+  renderReactSync(options, reactParseOptions) {
+    const html = this.renderSync(options);
+    return (0, import_html_react_parser.default)(html, reactParseOptions);
+  }
+  async loadFromFile(filePath) {
+    const { readFile } = import_node_fs.default.promises;
+    this._content = await readFile(filePath, "utf8");
+  }
+  loadFromFileSync(filePath) {
+    this._content = import_node_fs.default.readFileSync(filePath, "utf8");
+  }
+  async saveToFile(filePath) {
+    const { writeFile, mkdir } = import_node_fs.default.promises;
+    const directoryPath = (0, import_node_path.dirname)(filePath);
+    await mkdir(directoryPath, { recursive: true });
+    await writeFile(filePath, this._content, "utf8");
+  }
+  saveToFileSync(filePath) {
+    const directoryPath = (0, import_node_path.dirname)(filePath);
+    import_node_fs.default.mkdirSync(directoryPath, { recursive: true });
+    import_node_fs.default.writeFileSync(filePath, this._content, "utf8");
+  }
+  isCacheEnabled(options) {
+    if (options?.caching !== void 0) {
+      return options.caching;
+    }
+    return this._options?.renderOptions?.caching ?? false;
+  }
+  createProcessor(options) {
+    const processor = (0, import_unified.unified)().use(import_remark_parse.default);
+    if (options.gfm) {
+      processor.use(import_remark_gfm.default);
+    }
+    if (options.toc) {
+      processor.use(import_remark_toc.default, { heading: "toc|table of contents" });
+    }
+    if (options.emoji) {
+      processor.use(import_remark_emoji.default);
+    }
+    processor.use(import_remark_rehype.default);
+    if (options.slug) {
+      processor.use(import_rehype_slug.default);
+    }
+    if (options.highlight) {
+      processor.use(import_rehype_highlight.default);
+    }
+    if (options.math) {
+      processor.use(import_remark_math.default).use(import_rehype_katex.default);
+    }
+    if (options.mdx) {
+      processor.use(import_remark_mdx.default);
+    }
+    processor.use(import_rehype_stringify.default);
+    return processor;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Writr
+});

package/dist/writr.d.cts

@@ -0,0 +1,71 @@
+import * as unified from 'unified';
+import * as hast from 'hast';
+import * as mdast from 'mdast';
+import React from 'react';
+import { HTMLReactParserOptions } from 'html-react-parser';
+import { Cacheable, CacheableMemory } from 'cacheable';
+import { KeyvStoreAdapter } from 'keyv';
+
+declare class WritrCache {
+    private _markdownStore;
+    private readonly _markdownStoreSync;
+    private readonly _hashStore;
+    get markdownStore(): Cacheable;
+    get markdownStoreSync(): CacheableMemory;
+    get hashStore(): CacheableMemory;
+    getMarkdown(markdown: string, options?: RenderOptions): Promise<string | undefined>;
+    getMarkdownSync(markdown: string, options?: RenderOptions): string | undefined;
+    setMarkdown(markdown: string, value: string, options?: RenderOptions): Promise<boolean>;
+    setMarkdownSync(markdown: string, value: string, options?: RenderOptions): boolean;
+    get(key: string): Promise<string | undefined>;
+    getSync(key: string): string | undefined;
+    set(key: string, value: string): Promise<boolean>;
+    setSync(key: string, value: string): boolean;
+    clear(): Promise<void>;
+    setStorageAdapter(adapter: KeyvStoreAdapter): void;
+    hash(markdown: string, options?: RenderOptions): string;
+}
+
+type WritrOptions = {
+    openai?: string;
+    renderOptions?: RenderOptions;
+};
+type RenderOptions = {
+    emoji?: boolean;
+    toc?: boolean;
+    slug?: boolean;
+    highlight?: boolean;
+    gfm?: boolean;
+    math?: boolean;
+    mdx?: boolean;
+    caching?: boolean;
+};
+declare class Writr {
+    engine: unified.Processor<mdast.Root, mdast.Root, hast.Root, hast.Root, string>;
+    private readonly _options;
+    private _content;
+    private readonly _cache;
+    constructor(arguments1?: string | WritrOptions, arguments2?: WritrOptions);
+    get options(): WritrOptions;
+    get content(): string;
+    set content(value: string);
+    get cache(): WritrCache;
+    get frontMatterRaw(): string;
+    get body(): string;
+    get markdown(): string;
+    get frontMatter(): Record<string, any>;
+    set frontMatter(data: Record<string, any>);
+    getFrontMatterValue<T>(key: string): T;
+    render(options?: RenderOptions): Promise<string>;
+    renderSync(options?: RenderOptions): string;
+    renderReact(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]>;
+    renderReactSync(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[];
+    loadFromFile(filePath: string): Promise<void>;
+    loadFromFileSync(filePath: string): void;
+    saveToFile(filePath: string): Promise<void>;
+    saveToFileSync(filePath: string): void;
+    private isCacheEnabled;
+    private createProcessor;
+}
+
+export { type RenderOptions, Writr, type WritrOptions };

package/dist/writr.d.ts

@@ -1,6 +1,31 @@
-import { Processor } from 'unified';
-import type React from 'react';
-import { type HTMLReactParserOptions } from 'html-react-parser';
+import * as unified from 'unified';
+import * as hast from 'hast';
+import * as mdast from 'mdast';
+import React from 'react';
+import { HTMLReactParserOptions } from 'html-react-parser';
+import { Cacheable, CacheableMemory } from 'cacheable';
+import { KeyvStoreAdapter } from 'keyv';
+
+declare class WritrCache {
+    private _markdownStore;
+    private readonly _markdownStoreSync;
+    private readonly _hashStore;
+    get markdownStore(): Cacheable;
+    get markdownStoreSync(): CacheableMemory;
+    get hashStore(): CacheableMemory;
+    getMarkdown(markdown: string, options?: RenderOptions): Promise<string | undefined>;
+    getMarkdownSync(markdown: string, options?: RenderOptions): string | undefined;
+    setMarkdown(markdown: string, value: string, options?: RenderOptions): Promise<boolean>;
+    setMarkdownSync(markdown: string, value: string, options?: RenderOptions): boolean;
+    get(key: string): Promise<string | undefined>;
+    getSync(key: string): string | undefined;
+    set(key: string, value: string): Promise<boolean>;
+    setSync(key: string, value: string): boolean;
+    clear(): Promise<void>;
+    setStorageAdapter(adapter: KeyvStoreAdapter): void;
+    hash(markdown: string, options?: RenderOptions): string;
+}
+
 type WritrOptions = {
     openai?: string;
     renderOptions?: RenderOptions;
@@ -13,16 +38,34 @@ type RenderOptions = {
     gfm?: boolean;
     math?: boolean;
     mdx?: boolean;
+    caching?: boolean;
 };
 declare class Writr {
-    engine: Processor<import("mdast").Root, import("mdast").Root, import("hast").Root, import("hast").Root, string>;
+    engine: unified.Processor<mdast.Root, mdast.Root, hast.Root, hast.Root, string>;
     private readonly _options;
-    constructor(options?: WritrOptions);
+    private _content;
+    private readonly _cache;
+    constructor(arguments1?: string | WritrOptions, arguments2?: WritrOptions);
     get options(): WritrOptions;
-    render(markdown: string, options?: RenderOptions): Promise<string>;
-    renderSync(markdown: string, options?: RenderOptions): string;
-    renderReact(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]>;
-    renderReactSync(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[];
+    get content(): string;
+    set content(value: string);
+    get cache(): WritrCache;
+    get frontMatterRaw(): string;
+    get body(): string;
+    get markdown(): string;
+    get frontMatter(): Record<string, any>;
+    set frontMatter(data: Record<string, any>);
+    getFrontMatterValue<T>(key: string): T;
+    render(options?: RenderOptions): Promise<string>;
+    renderSync(options?: RenderOptions): string;
+    renderReact(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]>;
+    renderReactSync(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[];
+    loadFromFile(filePath: string): Promise<void>;
+    loadFromFileSync(filePath: string): void;
+    saveToFile(filePath: string): Promise<void>;
+    saveToFileSync(filePath: string): void;
+    private isCacheEnabled;
     private createProcessor;
 }
-export { Writr, type WritrOptions, type RenderOptions };
+
+export { type RenderOptions, Writr, type WritrOptions };

package/dist/writr.js

@@ -1,118 +1,286 @@
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkRehype from 'remark-rehype';
-import rehypeSlug from 'rehype-slug';
-import rehypeHighlight from 'rehype-highlight';
-import rehypeStringify from 'rehype-stringify';
-import remarkToc from 'remark-toc';
-import remarkMath from 'remark-math';
-import rehypeKatex from 'rehype-katex';
-import remarkGfm from 'remark-gfm';
-import remarkEmoji from 'remark-emoji';
-import remarkMDX from 'remark-mdx';
-import parse from 'html-react-parser';
-class Writr {
-    engine = unified()
-        .use(remarkParse)
-        .use(remarkGfm) // Use GitHub Flavored Markdown
-        .use(remarkToc) // Add table of contents
-        .use(remarkEmoji) // Add emoji support
-        .use(remarkRehype) // Convert markdown to HTML
-        .use(rehypeSlug) // Add slugs to headings in HTML
-        .use(remarkMath) // Add math support
-        .use(rehypeKatex) // Add math support
-        .use(rehypeHighlight) // Apply syntax highlighting
-        .use(remarkMDX) // Add MDX support
-        .use(rehypeStringify); // Stringify HTML
-    _options = {
-        openai: undefined,
-        renderOptions: {
-            emoji: true,
-            toc: true,
-            slug: true,
-            highlight: true,
-            gfm: true,
-            math: true,
-            mdx: true,
-        },
-    };
-    constructor(options) {
-        if (options) {
-            this._options = { ...this._options, ...options };
-            if (this._options.renderOptions) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                this.engine = this.createProcessor(this._options.renderOptions);
-            }
-        }
+// src/writr.ts
+import fs from "node:fs";
+import { dirname } from "node:path";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import rehypeSlug from "rehype-slug";
+import rehypeHighlight from "rehype-highlight";
+import rehypeStringify from "rehype-stringify";
+import remarkToc from "remark-toc";
+import remarkMath from "remark-math";
+import rehypeKatex from "rehype-katex";
+import remarkGfm from "remark-gfm";
+import remarkEmoji from "remark-emoji";
+import remarkMDX from "remark-mdx";
+import parse from "html-react-parser";
+import * as yaml from "js-yaml";
+
+// src/writr-cache.ts
+import { createHash } from "node:crypto";
+import { Cacheable, CacheableMemory } from "cacheable";
+var WritrCache = class {
+  _markdownStore = new Cacheable();
+  _markdownStoreSync = new CacheableMemory();
+  _hashStore = new CacheableMemory();
+  get markdownStore() {
+    return this._markdownStore;
+  }
+  get markdownStoreSync() {
+    return this._markdownStoreSync;
+  }
+  get hashStore() {
+    return this._hashStore;
+  }
+  async getMarkdown(markdown, options) {
+    const key = this.hash(markdown, options);
+    return this.get(key);
+  }
+  getMarkdownSync(markdown, options) {
+    const key = this.hash(markdown, options);
+    return this.getSync(key);
+  }
+  async setMarkdown(markdown, value, options) {
+    const key = this.hash(markdown, options);
+    return this.set(key, value);
+  }
+  setMarkdownSync(markdown, value, options) {
+    const key = this.hash(markdown, options);
+    this.setSync(key, value);
+    return true;
+  }
+  async get(key) {
+    return this._markdownStore.get(key);
+  }
+  getSync(key) {
+    return this._markdownStoreSync.get(key);
+  }
+  async set(key, value) {
+    return this._markdownStore.set(key, value);
+  }
+  setSync(key, value) {
+    this._markdownStoreSync.set(key, value);
+    return true;
+  }
+  async clear() {
+    await this._markdownStore.clear();
+    this._markdownStoreSync.clear();
+    this._hashStore.clear();
+  }
+  setStorageAdapter(adapter) {
+    this._markdownStore = new Cacheable({ primary: adapter });
+  }
+  hash(markdown, options) {
+    const key = JSON.stringify({ markdown, options });
+    let result = this._hashStore.get(key);
+    if (result) {
+      return result;
     }
-    get options() {
-        return this._options;
-    }
-    async render(markdown, options) {
-        try {
-            let { engine } = this;
-            if (options) {
-                options = { ...this._options.renderOptions, ...options };
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                engine = this.createProcessor(options);
-            }
-            const file = await engine.process(markdown);
-            return String(file);
-        }
-        catch (error) {
-            throw new Error(`Failed to render markdown: ${error.message}`);
-        }
+    result = createHash("sha256").update(key).digest("hex");
+    this._hashStore.set(key, result);
+    return result;
+  }
+};
+
+// src/writr.ts
+var Writr = class {
+  engine = unified().use(remarkParse).use(remarkGfm).use(remarkToc).use(remarkEmoji).use(remarkRehype).use(rehypeSlug).use(remarkMath).use(rehypeKatex).use(rehypeHighlight).use(remarkMDX).use(rehypeStringify);
+  // Stringify HTML
+  _options = {
+    openai: void 0,
+    renderOptions: {
+      emoji: true,
+      toc: true,
+      slug: true,
+      highlight: true,
+      gfm: true,
+      math: true,
+      mdx: true,
+      caching: true
     }
-    renderSync(markdown, options) {
-        try {
-            let { engine } = this;
-            if (options) {
-                options = { ...this._options.renderOptions, ...options };
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                engine = this.createProcessor(options);
-            }
-            const file = engine.processSync(markdown);
-            return String(file);
-        }
-        catch (error) {
-            throw new Error(`Failed to render markdown: ${error.message}`);
-        }
+  };
+  _content = "";
+  _cache = new WritrCache();
+  constructor(arguments1, arguments2) {
+    if (typeof arguments1 === "string") {
+      this._content = arguments1;
+    } else if (arguments1) {
+      this._options = { ...this._options, ...arguments1 };
+      if (this._options.renderOptions) {
+        this.engine = this.createProcessor(this._options.renderOptions);
+      }
     }
-    async renderReact(markdown, options, reactParseOptions) {
-        const html = await this.render(markdown, options);
-        return parse(html, reactParseOptions);
+    if (arguments2) {
+      this._options = { ...this._options, ...arguments2 };
+      if (this._options.renderOptions) {
+        this.engine = this.createProcessor(this._options.renderOptions);
+      }
     }
-    renderReactSync(markdown, options, reactParseOptions) {
-        const html = this.renderSync(markdown, options);
-        return parse(html, reactParseOptions);
+  }
+  get options() {
+    return this._options;
+  }
+  get content() {
+    return this._content;
+  }
+  set content(value) {
+    this._content = value;
+  }
+  get cache() {
+    return this._cache;
+  }
+  get frontMatterRaw() {
+    const start = this._content.indexOf("---\n");
+    if (start === -1) {
+      return "";
     }
-    createProcessor(options) {
-        const processor = unified().use(remarkParse);
-        if (options.gfm) {
-            processor.use(remarkGfm);
-        }
-        if (options.toc) {
-            processor.use(remarkToc, { heading: 'toc|table of contents' });
-        }
-        if (options.emoji) {
-            processor.use(remarkEmoji);
-        }
-        processor.use(remarkRehype);
-        if (options.slug) {
-            processor.use(rehypeSlug);
-        }
-        if (options.highlight) {
-            processor.use(rehypeHighlight);
-        }
-        if (options.math) {
-            processor.use(remarkMath).use(rehypeKatex);
+    const end = this._content.indexOf("\n---\n", start + 4);
+    if (end === -1) {
+      return "";
+    }
+    return this._content.slice(start, end + 5);
+  }
+  get body() {
+    const start = this._content.indexOf("---\n");
+    if (start === -1) {
+      return this._content;
+    }
+    const end = this._content.indexOf("\n---\n", start + 4);
+    if (end === -1) {
+      return this._content;
+    }
+    return this._content.slice(Math.max(0, end + 5)).trim();
+  }
+  get markdown() {
+    return this.body;
+  }
+  get frontMatter() {
+    const frontMatter = this.frontMatterRaw;
+    const match = /^---\s*([\s\S]*?)\s*---\s*/.exec(frontMatter);
+    if (match) {
+      return yaml.load(match[1].trim());
+    }
+    return {};
+  }
+  set frontMatter(data) {
+    const frontMatter = this.frontMatterRaw;
+    const yamlString = yaml.dump(data);
+    const newFrontMatter = `---
+${yamlString}---
+`;
+    this._content = this._content.replace(frontMatter, newFrontMatter);
+  }
+  getFrontMatterValue(key) {
+    return this.frontMatter[key];
+  }
+  async render(options) {
+    try {
+      let result = "";
+      if (this.isCacheEnabled(options)) {
+        const cached = await this._cache.getMarkdown(this._content, options);
+        if (cached) {
+          return cached;
         }
-        if (options.mdx) {
-            processor.use(remarkMDX);
+      }
+      let { engine } = this;
+      if (options) {
+        options = { ...this._options.renderOptions, ...options };
+        engine = this.createProcessor(options);
+      }
+      const file = await engine.process(this.body);
+      result = String(file);
+      if (this.isCacheEnabled(options)) {
+        await this._cache.setMarkdown(this._content, result, options);
+      }
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to render markdown: ${error.message}`);
+    }
+  }
+  renderSync(options) {
+    try {
+      let result = "";
+      if (this.isCacheEnabled(options)) {
+        const cached = this._cache.getMarkdownSync(this._content, options);
+        if (cached) {
+          return cached;
         }
-        processor.use(rehypeStringify);
-        return processor;
+      }
+      let { engine } = this;
+      if (options) {
+        options = { ...this._options.renderOptions, ...options };
+        engine = this.createProcessor(options);
+      }
+      const file = engine.processSync(this.body);
+      result = String(file);
+      if (this.isCacheEnabled(options)) {
+        this._cache.setMarkdownSync(this._content, result, options);
+      }
+      return result;
+    } catch (error) {
+      throw new Error(`Failed to render markdown: ${error.message}`);
+    }
+  }
+  async renderReact(options, reactParseOptions) {
+    const html = await this.render(options);
+    return parse(html, reactParseOptions);
+  }
+  renderReactSync(options, reactParseOptions) {
+    const html = this.renderSync(options);
+    return parse(html, reactParseOptions);
+  }
+  async loadFromFile(filePath) {
+    const { readFile } = fs.promises;
+    this._content = await readFile(filePath, "utf8");
+  }
+  loadFromFileSync(filePath) {
+    this._content = fs.readFileSync(filePath, "utf8");
+  }
+  async saveToFile(filePath) {
+    const { writeFile, mkdir } = fs.promises;
+    const directoryPath = dirname(filePath);
+    await mkdir(directoryPath, { recursive: true });
+    await writeFile(filePath, this._content, "utf8");
+  }
+  saveToFileSync(filePath) {
+    const directoryPath = dirname(filePath);
+    fs.mkdirSync(directoryPath, { recursive: true });
+    fs.writeFileSync(filePath, this._content, "utf8");
+  }
+  isCacheEnabled(options) {
+    if (options?.caching !== void 0) {
+      return options.caching;
+    }
+    return this._options?.renderOptions?.caching ?? false;
+  }
+  createProcessor(options) {
+    const processor = unified().use(remarkParse);
+    if (options.gfm) {
+      processor.use(remarkGfm);
+    }
+    if (options.toc) {
+      processor.use(remarkToc, { heading: "toc|table of contents" });
+    }
+    if (options.emoji) {
+      processor.use(remarkEmoji);
+    }
+    processor.use(remarkRehype);
+    if (options.slug) {
+      processor.use(rehypeSlug);
+    }
+    if (options.highlight) {
+      processor.use(rehypeHighlight);
+    }
+    if (options.math) {
+      processor.use(remarkMath).use(rehypeKatex);
+    }
+    if (options.mdx) {
+      processor.use(remarkMDX);
     }
-}
-export { Writr };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writr.js","sourceRoot":"","sources":["../src/writr.ts"],"names":[],"mappings":"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","sourcesContent":["import {unified, Processor} from 'unified';\nimport remarkParse from 'remark-parse';\nimport remarkRehype from 'remark-rehype';\nimport rehypeSlug from 'rehype-slug';\nimport rehypeHighlight from 'rehype-highlight';\nimport rehypeStringify from 'rehype-stringify';\nimport remarkToc from 'remark-toc';\nimport remarkMath from 'remark-math';\nimport rehypeKatex from 'rehype-katex';\nimport remarkGfm from 'remark-gfm';\nimport remarkEmoji from 'remark-emoji';\nimport remarkMDX from 'remark-mdx';\nimport type React from 'react';\nimport parse, {type HTMLReactParserOptions} from 'html-react-parser';\n\ntype WritrOptions = {\n\topenai?: string; // Openai api key (default: undefined)\n\trenderOptions?: RenderOptions; // Default render options (default: undefined)\n};\n\ntype RenderOptions = {\n\temoji?: boolean; // Emoji support (default: true)\n\ttoc?: boolean; // Table of contents generation (default: true)\n\tslug?: boolean; // Slug generation (default: true)\n\thighlight?: boolean; // Code highlighting (default: true)\n\tgfm?: boolean; // Github flavor markdown (default: true)\n\tmath?: boolean; // Math support (default: true)\n\tmdx?: boolean; // MDX support (default: true)\n};\n\nclass Writr {\n\tpublic engine = unified()\n\t\t.use(remarkParse)\n\t\t.use(remarkGfm) // Use GitHub Flavored Markdown\n\t\t.use(remarkToc) // Add table of contents\n\t\t.use(remarkEmoji) // Add emoji support\n\t\t.use(remarkRehype) // Convert markdown to HTML\n\t\t.use(rehypeSlug) // Add slugs to headings in HTML\n\t\t.use(remarkMath) // Add math support\n\t\t.use(rehypeKatex) // Add math support\n\t\t.use(rehypeHighlight) // Apply syntax highlighting\n\t\t.use(remarkMDX) // Add MDX support\n\t\t.use(rehypeStringify); // Stringify HTML\n\n\tprivate readonly _options: WritrOptions = {\n\t\topenai: undefined,\n\t\trenderOptions: {\n\t\t\temoji: true,\n\t\t\ttoc: true,\n\t\t\tslug: true,\n\t\t\thighlight: true,\n\t\t\tgfm: true,\n\t\t\tmath: true,\n\t\t\tmdx: true,\n\t\t},\n\t};\n\n\tconstructor(options?: WritrOptions) {\n\t\tif (options) {\n\t\t\tthis._options = {...this._options, ...options};\n\t\t\tif (this._options.renderOptions) {\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tthis.engine = this.createProcessor(this._options.renderOptions);\n\t\t\t}\n\t\t}\n\t}\n\n\tpublic get options(): WritrOptions {\n\t\treturn this._options;\n\t}\n\n\tasync render(markdown: string, options?: RenderOptions): Promise<string> {\n\t\ttry {\n\t\t\tlet {engine} = this;\n\t\t\tif (options) {\n\t\t\t\toptions = {...this._options.renderOptions, ...options};\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tengine = this.createProcessor(options);\n\t\t\t}\n\n\t\t\tconst file = await engine.process(markdown);\n\t\t\treturn String(file);\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to render markdown: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\trenderSync(markdown: string, options?: RenderOptions): string {\n\t\ttry {\n\t\t\tlet {engine} = this;\n\t\t\tif (options) {\n\t\t\t\toptions = {...this._options.renderOptions, ...options};\n\t\t\t\t// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n\t\t\t\tengine = this.createProcessor(options);\n\t\t\t}\n\n\t\t\tconst file = engine.processSync(markdown);\n\t\t\treturn String(file);\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to render markdown: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\tasync renderReact(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]> {\n\t\tconst html = await this.render(markdown, options);\n\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\trenderReactSync(markdown: string, options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[] {\n\t\tconst html = this.renderSync(markdown, options);\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\tprivate createProcessor(options: RenderOptions): any {\n\t\tconst processor = unified().use(remarkParse);\n\n\t\tif (options.gfm) {\n\t\t\tprocessor.use(remarkGfm);\n\t\t}\n\n\t\tif (options.toc) {\n\t\t\tprocessor.use(remarkToc, {heading: 'toc|table of contents'});\n\t\t}\n\n\t\tif (options.emoji) {\n\t\t\tprocessor.use(remarkEmoji);\n\t\t}\n\n\t\tprocessor.use(remarkRehype);\n\n\t\tif (options.slug) {\n\t\t\tprocessor.use(rehypeSlug);\n\t\t}\n\n\t\tif (options.highlight) {\n\t\t\tprocessor.use(rehypeHighlight);\n\t\t}\n\n\t\tif (options.math) {\n\t\t\tprocessor.use(remarkMath).use(rehypeKatex);\n\t\t}\n\n\t\tif (options.mdx) {\n\t\t\tprocessor.use(remarkMDX);\n\t\t}\n\n\t\tprocessor.use(rehypeStringify);\n\n\t\treturn processor;\n\t}\n}\n\nexport {Writr, type WritrOptions, type RenderOptions};\n\n"]}
+    processor.use(rehypeStringify);
+    return processor;
+  }
+};
+export {
+  Writr
+};

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "writr",
-  "version": "3.2.3",
+  "version": "4.1.0",
   "description": "Markdown Rendering Simplified",
   "type": "module",
-  "exports": "./dist/writr.js",
+  "main": "./dist/writr.cjs",
+  "module": "./dist/writr.js",
   "types": "./dist/writr.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/writr.cjs",
+      "import": "./dist/writr.js"
+    }
+  },
   "repository": "https://github.com/jaredwray/writr.git",
   "author": "Jared Wray <me@jaredwray.com>",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20"
   },
   "license": "MIT",
   "keywords": [
@@ -40,40 +47,48 @@
     "markdown-to-react"
   ],
   "scripts": {
-    "clean": "rimraf ./dist ./coverage ./node_modules ./package-lock.json ./yarn.lock ./site/README.md ./site-output",
-    "build": "rimraf ./dist && tsc",
-    "test": "xo --fix && vitest run --coverage",
+    "clean": "rimraf ./dist ./coverage ./node_modules ./package-lock.json ./yarn.lock ./site/README.md ./site/dist",
+    "build": "rimraf ./dist && tsup src/writr.ts --format cjs,esm --dts --clean",
     "prepare": "npm run build",
-    "website:build": "rimraf ./site/README.md ./site-output && npx docula build -s ./site -o ./site-output",
-    "website:serve": "rimraf ./site/README.md ./site-output && npx docula serve -s ./site -o ./site-output"
+    "test": "xo --fix && vitest run --coverage",
+    "website:build": "rimraf ./site/README.md ./site/dist && npx docula build -s ./site -o ./site/dist",
+    "website:serve": "rimraf ./site/README.md ./site/dist && npx docula serve -s ./site -o ./site/dist"
   },
   "dependencies": {
-    "html-react-parser": "^5.1.10",
+    "cacheable": "^1.7.1",
+    "crypto": "^1.0.1",
+    "fs": "^0.0.1-security",
+    "html-react-parser": "^5.1.16",
+    "js-yaml": "^4.1.0",
+    "keyv": "^5.0.3",
     "react": "^18.3.1",
     "rehype-highlight": "^7.0.0",
-    "rehype-katex": "^7.0.0",
+    "rehype-katex": "^7.0.1",
     "rehype-slug": "^6.0.0",
-    "rehype-stringify": "^10.0.0",
-    "remark-emoji": "^4.0.1",
+    "rehype-stringify": "^10.0.1",
+    "remark-emoji": "^5.0.1",
     "remark-gfm": "^4.0.0",
     "remark-math": "^6.0.0",
     "remark-mdx": "^3.0.1",
     "remark-parse": "^11.0.0",
-    "remark-rehype": "^11.1.0",
+    "remark-rehype": "^11.1.1",
     "remark-toc": "^9.0.0",
-    "ts-node": "^10.9.2",
-    "unified": "^11.0.4"
+    "unified": "^11.0.5"
   },
   "devDependencies": {
-    "@types/node": "^20.12.11",
-    "@types/react": "^18.3.2",
-    "@vitest/coverage-v8": "^1.6.0",
-    "docula": "^0.5.3",
-    "rimraf": "^5.0.7",
-    "typescript": "^5.4.5",
-    "vitest": "^1.6.0",
-    "webpack": "^5.91.0",
-    "xo": "^0.58.0"
+    "@keyv/sqlite": "^4.0.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.7.4",
+    "@types/react": "^18.3.10",
+    "@vitest/coverage-v8": "^2.1.1",
+    "docula": "^0.9.1",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "vitest": "^2.1.1",
+    "webpack": "^5.95.0",
+    "xo": "^0.59.3"
   },
   "xo": {
     "ignores": [
@@ -81,6 +96,8 @@
     ]
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ]
 }