@markdown-next/vue 0.0.1-alpha

package/LICENSE

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

package/dist/components/MarkdownRenderer.d.ts

@@ -0,0 +1,66 @@
+import type { PropType } from 'vue';
+import type { ParserOptions } from '@markdown-next/parser';
+import type { MarkdownComponent, MarkdownComponents } from '../types';
+export declare const MarkdownRenderer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        required: true;
+    };
+    parserOptions: {
+        type: PropType<ParserOptions>;
+        required: false;
+        default: undefined;
+    };
+    components: {
+        type: PropType<MarkdownComponents>;
+        required: false;
+        default: undefined;
+    };
+    codeRenderer: {
+        type: PropType<MarkdownComponent>;
+        required: false;
+        default: undefined;
+    };
+    dynamic: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    debounceMs: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    markdown: {
+        type: StringConstructor;
+        required: true;
+    };
+    parserOptions: {
+        type: PropType<ParserOptions>;
+        required: false;
+        default: undefined;
+    };
+    components: {
+        type: PropType<MarkdownComponents>;
+        required: false;
+        default: undefined;
+    };
+    codeRenderer: {
+        type: PropType<MarkdownComponent>;
+        required: false;
+        default: undefined;
+    };
+    dynamic: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    debounceMs: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    parserOptions: ParserOptions;
+    codeRenderer: MarkdownComponent;
+    components: MarkdownComponents;
+    dynamic: boolean;
+    debounceMs: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/components/MarkdownWorkerPoll.d.ts

@@ -0,0 +1,3 @@
+import type { DefineComponent } from 'vue';
+import type { MarkdownWorkerPollProps } from '../types';
+export declare const MarkdownWorkerPoll: DefineComponent<MarkdownWorkerPollProps>;

package/dist/context.d.ts

@@ -0,0 +1,9 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+import type { ParserWorkerPool } from '@markdown-next/parser';
+import type { MarkdownRenderOptions } from './types';
+export interface MarkdownWorkerContext {
+    pool: ParserWorkerPool;
+    renderOptions: ComputedRef<MarkdownRenderOptions | undefined>;
+    forceRenderOptions: ComputedRef<boolean>;
+}
+export declare const markdownWorkerContextKey: InjectionKey<MarkdownWorkerContext>;

package/dist/hooks/useMarkdownParser.d.ts

@@ -0,0 +1,5 @@
+import type { ParserOptions } from '@markdown-next/parser';
+import type { MarkdownRenderOptions, UseMarkdownResult } from '../types';
+import type { ShallowRef, VNodeChild } from 'vue';
+import { type MaybeRef } from './useMarkdownRender';
+export declare function useMarkdownParser(markdown: MaybeRef<string>, parserOptions?: ParserOptions, renderOptions?: MaybeRef<MarkdownRenderOptions | undefined>): UseMarkdownResult<ShallowRef<VNodeChild | null>>;

package/dist/hooks/useMarkdownRender.d.ts

@@ -0,0 +1,4 @@
+import type { Ref, ShallowRef, VNodeChild } from 'vue';
+import type { MarkdownRenderOptions, UseMarkdownResult } from '../types';
+export type MaybeRef<T> = T | Ref<T>;
+export declare function useMarkdownRender(markdown: MaybeRef<string>, render: (value: string, options?: MarkdownRenderOptions) => Promise<VNodeChild>, renderOptions?: MaybeRef<MarkdownRenderOptions | undefined>): UseMarkdownResult<ShallowRef<VNodeChild | null>>;

package/dist/hooks/useMarkdownWorkerPool.d.ts

@@ -0,0 +1,5 @@
+import type { ParserWorkerPool } from '@markdown-next/parser';
+import type { MarkdownRenderOptions, UseMarkdownResult } from '../types';
+import type { ShallowRef, VNodeChild } from 'vue';
+import { type MaybeRef } from './useMarkdownRender';
+export declare function useMarkdownWorkerPool(markdown: MaybeRef<string>, pool: ParserWorkerPool, renderOptions?: MaybeRef<MarkdownRenderOptions | undefined>): UseMarkdownResult<ShallowRef<VNodeChild | null>>;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { MarkdownRenderer } from './components/MarkdownRenderer';
+export { MarkdownWorkerPoll } from './components/MarkdownWorkerPoll';
+export { useMarkdownParser } from './hooks/useMarkdownParser';
+export { useMarkdownWorkerPool } from './hooks/useMarkdownWorkerPool';
+export type { MarkdownComponent, MarkdownComponents, MarkdownRenderOptions, MarkdownRendererProps, MarkdownWorkerPollProps, UseMarkdownResult, } from './types';

package/dist/index.mjs

@@ -0,0 +1,513 @@
+import { h, Fragment as W, shallowRef as O, ref as k, watch as v, unref as x, onBeforeUnmount as C, defineComponent as T, useAttrs as F, toRef as E, inject as L, computed as y, onErrorCaptured as j, createVNode as g, mergeProps as H, createTextVNode as b, provide as J } from "vue";
+import { createParser as X, createWorkerPool as G } from "@markdown-next/parser";
+const R = Symbol("MarkdownWorkerPoll"), I = {
+  color: "#1f2328",
+  backgroundColor: "#ffffff",
+  fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans", Helvetica, Arial, sans-serif',
+  fontSize: "16px",
+  lineHeight: "1.5",
+  wordWrap: "break-word"
+}, M = {
+  h1: {
+    fontSize: "2em",
+    fontWeight: 600,
+    margin: "0.67em 0",
+    paddingBottom: "0.3em",
+    borderBottom: "1px solid #d0d7de"
+  },
+  h2: {
+    fontSize: "1.5em",
+    fontWeight: 600,
+    margin: "0.83em 0",
+    paddingBottom: "0.3em",
+    borderBottom: "1px solid #d0d7de"
+  },
+  h3: {
+    fontSize: "1.25em",
+    fontWeight: 600,
+    margin: "1em 0"
+  },
+  h4: {
+    fontSize: "1em",
+    fontWeight: 600,
+    margin: "1em 0"
+  },
+  h5: {
+    fontSize: "0.875em",
+    fontWeight: 600,
+    margin: "1em 0"
+  },
+  h6: {
+    fontSize: "0.85em",
+    fontWeight: 600,
+    margin: "1em 0",
+    color: "#656d76"
+  },
+  p: {
+    marginTop: 0,
+    marginBottom: "16px"
+  },
+  blockquote: {
+    padding: "0 1em",
+    color: "#656d76",
+    borderLeft: "0.25em solid #d0d7de",
+    margin: "0 0 16px 0"
+  },
+  ul: {
+    marginTop: 0,
+    marginBottom: "16px",
+    paddingLeft: "2em"
+  },
+  ol: {
+    marginTop: 0,
+    marginBottom: "16px",
+    paddingLeft: "2em"
+  },
+  li: {
+    marginTop: "0.25em"
+  },
+  table: {
+    borderCollapse: "collapse",
+    width: "100%",
+    marginBottom: "16px"
+  },
+  th: {
+    border: "1px solid #d0d7de",
+    padding: "6px 13px",
+    backgroundColor: "#f6f8fa",
+    fontWeight: 600
+  },
+  td: {
+    border: "1px solid #d0d7de",
+    padding: "6px 13px"
+  },
+  pre: {
+    backgroundColor: "#f6f8fa",
+    borderRadius: "6px",
+    padding: "16px",
+    overflow: "auto",
+    fontSize: "85%",
+    lineHeight: "1.45",
+    marginBottom: "16px"
+  },
+  code: {
+    fontFamily: 'SFMono-Regular, Consolas, "Liberation Mono", Menlo, monospace',
+    fontSize: "85%",
+    backgroundColor: "rgba(175, 184, 193, 0.2)",
+    borderRadius: "6px",
+    padding: "0.2em 0.4em"
+  },
+  a: {
+    color: "#0969da",
+    textDecoration: "none"
+  },
+  hr: {
+    border: 0,
+    borderTop: "1px solid #d0d7de",
+    margin: "24px 0"
+  },
+  img: {
+    maxWidth: "100%"
+  },
+  kbd: {
+    display: "inline-block",
+    padding: "3px 5px",
+    fontSize: "11px",
+    lineHeight: "10px",
+    color: "#1f2328",
+    verticalAlign: "middle",
+    backgroundColor: "#f6f8fa",
+    border: "1px solid #d0d7de",
+    borderRadius: "6px",
+    boxShadow: "inset 0 -1px 0 #d0d7de"
+  },
+  del: {
+    color: "#656d76"
+  }
+}, D = "mjx-", U = /* @__PURE__ */ new Set(["math"]);
+function P(e) {
+  if (!e) return {};
+  const n = { ...e };
+  return "className" in n && (n.class = n.className, delete n.className), "htmlFor" in n && (n.for = n.htmlFor, delete n.htmlFor), n;
+}
+function N(e, n) {
+  return n ? Array.isArray(n) ? [e ?? {}, ...n] : [e ?? {}, n] : e;
+}
+function c(e) {
+  return (n) => {
+    const { children: r, style: t, ...a } = n, i = { ...a };
+    delete i.node;
+    const d = r ?? void 0, s = { ...i, style: N(M[e], t) };
+    return d === void 0 ? h(e, s) : h(e, s, d);
+  };
+}
+function V() {
+  return (e) => {
+    const {
+      children: n,
+      style: r,
+      class: t,
+      className: a,
+      ...i
+    } = e, d = { ...i };
+    delete d.node;
+    const s = t ?? a, f = typeof s == "string" ? s : void 0, p = !!(f && f.includes("language-")), u = M.code ?? {}, o = p ? {
+      fontFamily: u.fontFamily,
+      fontSize: u.fontSize,
+      padding: 0,
+      backgroundColor: "transparent"
+    } : u, l = n ?? void 0, m = {
+      ...d,
+      class: s,
+      style: N(o, r)
+    };
+    return l === void 0 ? h("code", m) : h("code", m, l);
+  };
+}
+function _() {
+  return {
+    h1: c("h1"),
+    h2: c("h2"),
+    h3: c("h3"),
+    h4: c("h4"),
+    h5: c("h5"),
+    h6: c("h6"),
+    p: c("p"),
+    blockquote: c("blockquote"),
+    ul: c("ul"),
+    ol: c("ol"),
+    li: c("li"),
+    table: c("table"),
+    th: c("th"),
+    td: c("td"),
+    pre: c("pre"),
+    code: V(),
+    a: c("a"),
+    hr: c("hr"),
+    img: c("img"),
+    kbd: c("kbd"),
+    del: c("del")
+  };
+}
+const K = _();
+function Q(e) {
+  const n = { ...e };
+  for (const r of Object.keys(n))
+    (r.startsWith(D) || U.has(r)) && delete n[r];
+  return n;
+}
+function Y(e) {
+  const n = {
+    ...K,
+    ...(e == null ? void 0 : e.components) ?? {}
+  };
+  return e != null && e.codeRenderer && (n.code = e.codeRenderer), Q(n);
+}
+const S = (e, n, r) => {
+  const t = P(n), { children: a, ...i } = t, d = r == null ? i : { ...i, key: r };
+  if (typeof e == "string") {
+    const f = { ...d };
+    return delete f.node, a == null ? h(e, f) : h(e, f, a);
+  }
+  if (a == null)
+    return h(e, d);
+  const s = { ...d, children: a };
+  return h(e, s, a);
+};
+function w(e, n) {
+  const r = [];
+  for (let t = 0; t < e.children.length; t += 1) {
+    const a = q(e.children[t], n, t);
+    a != null && r.push(a);
+  }
+  return r;
+}
+function q(e, n, r) {
+  switch (e.type) {
+    case "root": {
+      const t = w(e, n);
+      return t.length ? S(W, { children: t }, void 0) : null;
+    }
+    case "element": {
+      const t = e, a = n[t.tagName] ?? t.tagName, i = P(
+        t.properties ?? {}
+      );
+      i.node = t;
+      const d = t.tagName === "template" && t.content ? t.content : t, s = w(d, n);
+      return s.length && (i.children = s), S(a, i, r == null ? void 0 : r.toString());
+    }
+    case "text":
+      return e.value;
+    case "comment":
+    case "doctype":
+    default:
+      return null;
+  }
+}
+function z(e, n) {
+  const r = Y(n);
+  return q(e, r);
+}
+function A(e) {
+  if (e instanceof Error) return e;
+  if (typeof e == "string") return new Error(e);
+  try {
+    return new Error(JSON.stringify(e));
+  } catch {
+    return new Error("Unknown error");
+  }
+}
+function B(e, n, r) {
+  const t = O(null), a = k(!1), i = k(null);
+  let d = null, s = 0;
+  const f = async (u, o) => {
+    const l = ++s;
+    a.value = !0, i.value = null;
+    try {
+      const m = await n(u, o);
+      l === s && (t.value = m);
+    } catch (m) {
+      l === s && (i.value = A(m));
+    } finally {
+      l === s && (a.value = !1);
+    }
+  }, p = (u, o) => {
+    const l = (o == null ? void 0 : o.dynamic) ?? !1, m = (o == null ? void 0 : o.debounceMs) ?? 250;
+    if (d != null && (globalThis.clearTimeout(d), d = null), l) {
+      d = globalThis.setTimeout(() => {
+        f(u, o);
+      }, m);
+      return;
+    }
+    f(u, o);
+  };
+  return v(
+    () => [x(e), r ? x(r) : void 0],
+    ([u, o]) => {
+      p(u ?? "", o);
+    },
+    { immediate: !0, deep: !0 }
+  ), C(() => {
+    d != null && globalThis.clearTimeout(d);
+  }), {
+    content: t,
+    loading: a,
+    error: i
+  };
+}
+function Z(e, n, r) {
+  const t = X(n ?? {});
+  return B(
+    e,
+    async (a, i) => {
+      const d = await t.parseToHAST(a);
+      return z(d, i);
+    },
+    r
+  );
+}
+function $(e, n, r) {
+  return B(
+    e,
+    async (t, a) => {
+      const i = await n.parseToHAST(t);
+      return z(i, a);
+    },
+    r
+  );
+}
+const ee = {
+  display: "inline-flex",
+  alignItems: "center",
+  gap: "8px",
+  color: "#57606a",
+  fontSize: "14px"
+}, ne = {
+  padding: "12px 16px",
+  borderRadius: "8px",
+  backgroundColor: "#ffebe9",
+  color: "#cf222e",
+  border: "1px solid #ff8182",
+  fontSize: "14px"
+}, oe = /* @__PURE__ */ T({
+  name: "MarkdownRenderer",
+  inheritAttrs: !1,
+  props: {
+    markdown: {
+      type: String,
+      required: !0
+    },
+    parserOptions: {
+      type: Object,
+      required: !1,
+      default: void 0
+    },
+    components: {
+      type: Object,
+      required: !1,
+      default: void 0
+    },
+    codeRenderer: {
+      type: [Object, Function, String],
+      required: !1,
+      default: void 0
+    },
+    dynamic: {
+      type: Boolean,
+      default: !1
+    },
+    debounceMs: {
+      type: Number,
+      default: 250
+    }
+  },
+  setup(e) {
+    const n = F(), r = E(e, "markdown"), t = L(R, null), a = k(null), i = y(() => {
+      const o = {
+        dynamic: e.dynamic,
+        debounceMs: e.debounceMs
+      };
+      if (t != null && t.forceRenderOptions.value) {
+        const l = t.renderOptions.value;
+        return l != null && l.components && (o.components = l.components), l != null && l.codeRenderer && (o.codeRenderer = l.codeRenderer), o.dynamic = (l == null ? void 0 : l.dynamic) ?? !1, o.debounceMs = (l == null ? void 0 : l.debounceMs) ?? 250, o;
+      }
+      return e.components && (o.components = e.components), e.codeRenderer && (o.codeRenderer = e.codeRenderer), o;
+    }), d = t ? $(r, t.pool, i) : Z(r, e.parserOptions, i);
+    j((o) => (a.value = A(o), !1)), v(r, () => {
+      a.value = null;
+    });
+    const s = y(() => [I, n.style]), f = y(() => {
+      const l = {
+        ...n
+      };
+      return delete l.style, l;
+    }), p = () => g("div", {
+      style: ee
+    }, [g("svg", {
+      width: "16",
+      height: "16",
+      viewBox: "0 0 50 50",
+      "aria-hidden": "true"
+    }, [g("circle", {
+      cx: "25",
+      cy: "25",
+      r: "20",
+      fill: "none",
+      stroke: "#57606a",
+      "stroke-width": "4",
+      "stroke-linecap": "round",
+      "stroke-dasharray": "31.4 31.4"
+    }, [g("animateTransform", {
+      attributeName: "transform",
+      type: "rotate",
+      from: "0 25 25",
+      to: "360 25 25",
+      dur: "1s",
+      repeatCount: "indefinite"
+    }, null)])]), g("span", null, [b("Rendering markdown...")])]), u = (o) => g("div", {
+      style: ne
+    }, [g("strong", null, [b("Markdown render error:")]), b(" "), o.message]);
+    return () => {
+      const o = a.value ?? d.error.value, l = d.content.value, m = d.loading.value && !l && !o;
+      return g("div", H(f.value, {
+        style: s.value
+      }), [o ? u(o) : m ? p() : l]);
+    };
+  }
+}), de = /* @__PURE__ */ T({
+  name: "MarkdownWorkerPoll",
+  props: {
+    parserOptions: {
+      type: Object,
+      required: !1,
+      default: void 0
+    },
+    workerCount: {
+      type: Number,
+      required: !0
+    },
+    customTags: {
+      type: Array,
+      required: !1,
+      default: void 0
+    },
+    extendedGrammar: {
+      type: Array,
+      required: !1,
+      default: void 0
+    },
+    remarkPlugins: {
+      type: Array,
+      required: !1,
+      default: void 0
+    },
+    rehypePlugins: {
+      type: Array,
+      required: !1,
+      default: void 0
+    },
+    mathJaxConfig: {
+      type: Object,
+      required: !1,
+      default: void 0
+    },
+    supportsLaTeX: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    components: {
+      type: Object,
+      required: !1,
+      default: void 0
+    },
+    codeRenderer: {
+      type: [Object, Function, String],
+      required: !1,
+      default: void 0
+    },
+    dynamic: {
+      type: Boolean,
+      required: !1,
+      default: void 0
+    },
+    debounceMs: {
+      type: Number,
+      required: !1,
+      default: void 0
+    }
+  },
+  setup(e, {
+    slots: n
+  }) {
+    const r = {
+      ...e.parserOptions ?? {}
+    };
+    e.workerCount != null && (r.workerCount = e.workerCount), e.customTags && (r.customTags = e.customTags), e.extendedGrammar && (r.extendedGrammar = e.extendedGrammar), e.remarkPlugins && (r.remarkPlugins = e.remarkPlugins), e.rehypePlugins && (r.rehypePlugins = e.rehypePlugins), e.mathJaxConfig && (r.mathJaxConfig = e.mathJaxConfig), e.supportsLaTeX != null && (r.supportsLaTeX = e.supportsLaTeX);
+    const t = G(r), a = y(() => {
+      if (e.components == null && e.codeRenderer == null && e.dynamic == null && e.debounceMs == null)
+        return;
+      const d = {
+        dynamic: e.dynamic ?? !1,
+        debounceMs: e.debounceMs ?? 250
+      };
+      return e.components && (d.components = e.components), e.codeRenderer && (d.codeRenderer = e.codeRenderer), d;
+    }), i = y(() => a.value !== void 0);
+    return J(R, {
+      pool: t,
+      renderOptions: a,
+      forceRenderOptions: i
+    }), C(() => {
+      t.destroy();
+    }), () => {
+      var d;
+      return (d = n.default) == null ? void 0 : d.call(n);
+    };
+  }
+});
+export {
+  oe as MarkdownRenderer,
+  de as MarkdownWorkerPoll,
+  Z as useMarkdownParser,
+  $ as useMarkdownWorkerPool
+};

package/dist/render/hastToVue.d.ts

@@ -0,0 +1,4 @@
+import type { Root } from 'hast';
+import type { VNodeChild } from 'vue';
+import type { MarkdownRenderOptions } from '../types';
+export declare function renderHastToVue(tree: Root, options?: MarkdownRenderOptions): VNodeChild;

package/dist/styles/themeGithub.d.ts

@@ -0,0 +1,3 @@
+import type { CSSProperties } from 'vue';
+export declare const githubContainerStyle: CSSProperties;
+export declare const githubTagStyles: Record<string, CSSProperties>;

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+import type { Component, FunctionalComponent, Ref } from 'vue';
+import type { ParserOptions } from '@markdown-next/parser';
+export type MarkdownComponent = Component | FunctionalComponent | string;
+export type MarkdownComponents = Record<string, MarkdownComponent>;
+export interface MarkdownRenderOptions {
+    components?: MarkdownComponents;
+    codeRenderer?: MarkdownComponent;
+    dynamic?: boolean;
+    debounceMs?: number;
+}
+export interface MarkdownRendererProps extends MarkdownRenderOptions {
+    markdown: string;
+    parserOptions?: ParserOptions;
+}
+export interface MarkdownWorkerPollProps extends MarkdownRenderOptions {
+    parserOptions?: ParserOptions;
+    workerCount?: number;
+    customTags?: string[];
+    extendedGrammar?: ParserOptions['extendedGrammar'];
+    remarkPlugins?: ParserOptions['remarkPlugins'];
+    rehypePlugins?: ParserOptions['rehypePlugins'];
+    mathJaxConfig?: ParserOptions['mathJaxConfig'];
+    supportsLaTeX?: ParserOptions['supportsLaTeX'];
+}
+export interface UseMarkdownResult<T> {
+    content: T;
+    loading: Ref<boolean>;
+    error: Ref<Error | null>;
+}

package/dist/utils/toError.d.ts

@@ -0,0 +1 @@
+export declare function toError(value: unknown): Error;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@markdown-next/vue",
+  "version": "0.0.1-alpha",
+  "type": "module",
+  "description": "Vue renderer for markdown-next",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "./dist",
+    "./package.json",
+    "./README.md"
+  ],
+  "keywords": [
+    "markdown",
+    "vue",
+    "renderer",
+    "worker"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/vue-markdown-next.git",
+    "directory": "packages/vue"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/vue-markdown-next/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "hast-util-to-jsx-runtime": "^2.3.0",
+    "@markdown-next/parser": "0.0.1-alpha"
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.4",
+    "@types/node": "^25.0.3",
+    "@vitejs/plugin-vue-jsx": "^4.2.0",
+    "vite": "^5.4.10",
+    "vitest": "^4.0.16",
+    "vue": "^3.5.0"
+  },
+  "peerDependencies": {
+    "vue": ">=3.2.0"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -b",
+    "lint": "eslint src --ext .ts,.tsx",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
+    "test": "vitest"
+  }
+}