writr 4.0.0 → 4.1.0

package/README.md

@@ -32,13 +32,13 @@
 
 ## 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';
@@ -58,6 +58,26 @@ const options  = {
 const html = await writr.render(options); // <h1>Hello World ::-):</h1><p>This is a test.</p>
 ```
 
+An example passing in the options also via the constructor:
+
+```javascript
+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(arg?: string | WritrOptions, options?: WritrOptions)` 

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 type React from 'react';
-import { type HTMLReactParserOptions } from 'html-react-parser';
-import { WritrCache } from './writr-cache.js';
+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;
@@ -16,7 +41,7 @@ type RenderOptions = {
     caching?: boolean;
 };
 declare class Writr {
-    engine: import("unified").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;
     private _content;
     private readonly _cache;
@@ -42,4 +67,5 @@ declare class Writr {
     private isCacheEnabled;
     private createProcessor;
 }
-export { Writr, type WritrOptions, type RenderOptions };
+
+export { type RenderOptions, Writr, type WritrOptions };

package/dist/writr.js

@@ -1,233 +1,286 @@
-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';
-import { WritrCache } from './writr-cache.js';
-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,
-            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) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                this.engine = this.createProcessor(this._options.renderOptions);
-            }
-        }
-        if (arguments2) {
-            this._options = { ...this._options, ...arguments2 };
-            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;
-    }
-    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 '';
-        } // Return empty string if no starting delimiter is found
-        const end = this._content.indexOf('\n---\n', start + 4);
-        if (end === -1) {
-            return '';
-        } // Return empty string if no ending delimiter is found
-        return this._content.slice(start, end + 5); // Extract front matter including delimiters
-    }
-    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 the content after the closing --- marker
-        return this._content.slice(Math.max(0, end + 5)).trim();
+    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
     }
-    get markdown() {
-        return this.body;
+  };
+  _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);
+      }
     }
-    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 = `---\n${yamlString}---\n`;
-        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 };
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                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}`);
-        }
+    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;
     }
-    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 };
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                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;
+    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;
         }
-        catch (error) {
-            throw new Error(`Failed to render markdown: ${error.message}`);
+      }
+      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 parse(html, reactParseOptions);
+  }
+  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;
     }
-    renderReactSync(options, reactParseOptions) {
-        const html = this.renderSync(options);
-        return parse(html, reactParseOptions);
+    return this._options?.renderOptions?.caching ?? false;
+  }
+  createProcessor(options) {
+    const processor = unified().use(remarkParse);
+    if (options.gfm) {
+      processor.use(remarkGfm);
     }
-    async loadFromFile(filePath) {
-        const { readFile } = fs.promises;
-        this._content = await readFile(filePath, 'utf8');
+    if (options.toc) {
+      processor.use(remarkToc, { heading: "toc|table of contents" });
     }
-    loadFromFileSync(filePath) {
-        this._content = fs.readFileSync(filePath, 'utf8');
+    if (options.emoji) {
+      processor.use(remarkEmoji);
     }
-    async saveToFile(filePath) {
-        const { writeFile, mkdir } = fs.promises;
-        const directoryPath = dirname(filePath);
-        await mkdir(directoryPath, { recursive: true });
-        await writeFile(filePath, this._content, 'utf8');
+    processor.use(remarkRehype);
+    if (options.slug) {
+      processor.use(rehypeSlug);
     }
-    saveToFileSync(filePath) {
-        const directoryPath = dirname(filePath);
-        fs.mkdirSync(directoryPath, { recursive: true });
-        fs.writeFileSync(filePath, this._content, 'utf8');
+    if (options.highlight) {
+      processor.use(rehypeHighlight);
     }
-    isCacheEnabled(options) {
-        if (options?.caching !== undefined) {
-            return options.caching;
-        }
-        return this._options?.renderOptions?.caching ?? false;
+    if (options.math) {
+      processor.use(remarkMath).use(rehypeKatex);
     }
-    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);
-        }
-        processor.use(rehypeStringify);
-        return processor;
+    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 fs from 'node:fs';\nimport {dirname} from 'node:path';\nimport {unified} 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';\nimport * as yaml from 'js-yaml';\nimport {WritrCache} from './writr-cache.js';\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\tcaching?: boolean; // Caching (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\tcaching: true,\n\t\t},\n\t};\n\n\tprivate _content = '';\n\n\tprivate readonly _cache = new WritrCache();\n\n\tconstructor(arguments1?: string | WritrOptions, arguments2?: WritrOptions) {\n\t\tif (typeof arguments1 === 'string') {\n\t\t\tthis._content = arguments1;\n\t\t} else if (arguments1) {\n\t\t\tthis._options = {...this._options, ...arguments1};\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\n\t\tif (arguments2) {\n\t\t\tthis._options = {...this._options, ...arguments2};\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\tpublic get content(): string {\n\t\treturn this._content;\n\t}\n\n\tpublic set content(value: string) {\n\t\tthis._content = value;\n\t}\n\n\tpublic get cache(): WritrCache {\n\t\treturn this._cache;\n\t}\n\n\tget frontMatterRaw(): string {\n\t\tconst start = this._content.indexOf('---\\n');\n\t\tif (start === -1) {\n\t\t\treturn '';\n\t\t} // Return empty string if no starting delimiter is found\n\n\t\tconst end = this._content.indexOf('\\n---\\n', start + 4);\n\t\tif (end === -1) {\n\t\t\treturn '';\n\t\t} // Return empty string if no ending delimiter is found\n\n\t\treturn this._content.slice(start, end + 5); // Extract front matter including delimiters\n\t}\n\n\tget body(): string {\n\t\tconst start = this._content.indexOf('---\\n');\n\t\tif (start === -1) {\n\t\t\treturn this._content;\n\t\t}\n\n\t\tconst end = this._content.indexOf('\\n---\\n', start + 4);\n\t\tif (end === -1) {\n\t\t\treturn this._content;\n\t\t}\n\n\t\t// Return the content after the closing --- marker\n\t\treturn this._content.slice(Math.max(0, end + 5)).trim();\n\t}\n\n\tget markdown(): string {\n\t\treturn this.body;\n\t}\n\n\tget frontMatter(): Record<string, any> {\n\t\tconst frontMatter = this.frontMatterRaw;\n\t\tconst match = /^---\\s*([\\s\\S]*?)\\s*---\\s*/.exec(frontMatter);\n\t\tif (match) {\n\t\t\treturn yaml.load(match[1].trim()) as Record<string, any>;\n\t\t}\n\n\t\treturn {};\n\t}\n\n\tset frontMatter(data: Record<string, any>) {\n\t\tconst frontMatter = this.frontMatterRaw;\n\t\tconst yamlString = yaml.dump(data);\n\t\tconst newFrontMatter = `---\\n${yamlString}---\\n`;\n\t\tthis._content = this._content.replace(frontMatter, newFrontMatter);\n\t}\n\n\tpublic getFrontMatterValue<T>(key: string): T {\n\t\treturn this.frontMatter[key] as T;\n\t}\n\n\tasync render(options?: RenderOptions): Promise<string> {\n\t\ttry {\n\t\t\tlet result = '';\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tconst cached = await this._cache.getMarkdown(this._content, options);\n\t\t\t\tif (cached) {\n\t\t\t\t\treturn cached;\n\t\t\t\t}\n\t\t\t}\n\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(this.body);\n\t\t\tresult = String(file);\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tawait this._cache.setMarkdown(this._content, result, options);\n\t\t\t}\n\n\t\t\treturn result;\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(options?: RenderOptions): string {\n\t\ttry {\n\t\t\tlet result = '';\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tconst cached = this._cache.getMarkdownSync(this._content, options);\n\t\t\t\tif (cached) {\n\t\t\t\t\treturn cached;\n\t\t\t\t}\n\t\t\t}\n\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(this.body);\n\t\t\tresult = String(file);\n\t\t\tif (this.isCacheEnabled(options)) {\n\t\t\t\tthis._cache.setMarkdownSync(this._content, result, options);\n\t\t\t}\n\n\t\t\treturn result;\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(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): Promise<string | React.JSX.Element | React.JSX.Element[]> {\n\t\tconst html = await this.render(options);\n\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\trenderReactSync(options?: RenderOptions, reactParseOptions?: HTMLReactParserOptions): string | React.JSX.Element | React.JSX.Element[] {\n\t\tconst html = this.renderSync(options);\n\t\treturn parse(html, reactParseOptions);\n\t}\n\n\tasync loadFromFile(filePath: string): Promise<void> {\n\t\tconst {readFile} = fs.promises;\n\t\tthis._content = await readFile(filePath, 'utf8');\n\t}\n\n\tloadFromFileSync(filePath: string): void {\n\t\tthis._content = fs.readFileSync(filePath, 'utf8');\n\t}\n\n\tasync saveToFile(filePath: string): Promise<void> {\n\t\tconst {writeFile, mkdir} = fs.promises;\n\t\tconst directoryPath = dirname(filePath);\n\t\tawait mkdir(directoryPath, {recursive: true});\n\t\tawait writeFile(filePath, this._content, 'utf8');\n\t}\n\n\tsaveToFileSync(filePath: string): void {\n\t\tconst directoryPath = dirname(filePath);\n\t\tfs.mkdirSync(directoryPath, {recursive: true});\n\t\tfs.writeFileSync(filePath, this._content, 'utf8');\n\t}\n\n\tprivate isCacheEnabled(options?: RenderOptions): boolean {\n\t\tif (options?.caching !== undefined) {\n\t\t\treturn options.caching;\n\t\t}\n\n\t\treturn this._options?.renderOptions?.caching ?? false;\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,10 +1,17 @@
 {
   "name": "writr",
-  "version": "4.0.0",
+  "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": {
@@ -41,44 +48,46 @@
   ],
   "scripts": {
     "clean": "rimraf ./dist ./coverage ./node_modules ./package-lock.json ./yarn.lock ./site/README.md ./site/dist",
-    "build": "rimraf ./dist && tsc",
-    "test": "xo --fix && vitest run --coverage",
+    "build": "rimraf ./dist && tsup src/writr.ts --format cjs,esm --dts --clean",
     "prepare": "npm run build",
+    "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": {
+    "cacheable": "^1.7.1",
     "crypto": "^1.0.1",
     "fs": "^0.0.1-security",
-    "html-react-parser": "^5.1.15",
+    "html-react-parser": "^5.1.16",
     "js-yaml": "^4.1.0",
-    "keyv": "^5.0.1",
+    "keyv": "^5.0.3",
     "react": "^18.3.1",
     "rehype-highlight": "^7.0.0",
     "rehype-katex": "^7.0.1",
     "rehype-slug": "^6.0.0",
-    "rehype-stringify": "^10.0.0",
+    "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",
     "unified": "^11.0.5"
   },
   "devDependencies": {
     "@keyv/sqlite": "^4.0.1",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^22.5.1",
-    "@types/react": "^18.3.5",
-    "@vitest/coverage-v8": "^2.0.5",
-    "docula": "^0.9.0",
+    "@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",
-    "typescript": "^5.5.4",
-    "vitest": "^2.0.5",
-    "webpack": "^5.94.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "vitest": "^2.1.1",
+    "webpack": "^5.95.0",
     "xo": "^0.59.3"
   },
   "xo": {

package/dist/writr-cache.d.ts

@@ -1,22 +0,0 @@
-import { Keyv, type KeyvStoreAdapter } from 'keyv';
-import { type RenderOptions } from './writr.js';
-export declare class WritrCache {
-    private _markdownStore;
-    private _markdownStoreSync;
-    private _hashStore;
-    constructor();
-    get markdownStore(): Keyv;
-    get markdownStoreSync(): Map<string, string>;
-    get hashStore(): Map<string, string>;
-    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;
-}

package/dist/writr-cache.js

@@ -1,70 +0,0 @@
-import { createHash } from 'node:crypto';
-import { Keyv } from 'keyv';
-export class WritrCache {
-    _markdownStore;
-    _markdownStoreSync;
-    _hashStore;
-    constructor() {
-        this._markdownStore = new Keyv();
-        this._markdownStoreSync = new Map();
-        this._hashStore = new Map();
-    }
-    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 = new Map();
-        this._hashStore = new Map();
-    }
-    setStorageAdapter(adapter) {
-        this._markdownStore = new Keyv({ store: adapter });
-    }
-    hash(markdown, options) {
-        const key = JSON.stringify({ markdown, options });
-        let result = this._hashStore.get(key);
-        if (result) {
-            return result;
-        }
-        result = createHash('sha256').update(key).digest('hex');
-        this._hashStore.set(key, result);
-        return result;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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