@paragraphcms/parser-vue 0.1.0

package/README.md

@@ -0,0 +1,9 @@
+# @paragraphcms/parser-vue
+
+Vue renderer for Paragraph CMS content.
+
+This package renders Paragraph CMS `markdown`, `html`, and `tiptap` content in Vue. It exports:
+
+- `ParagraphContent` Vue component
+- `useParagraphContent` composable
+- HTML rendering helpers and shared types

package/dist/index.cjs

@@ -0,0 +1,163 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ParagraphContent: () => ParagraphContent,
+  createParagraphDocumentHtml: () => createParagraphDocumentHtml,
+  defaultParagraphClassNames: () => defaultParagraphClassNames,
+  defaultParagraphMarkedOptions: () => defaultParagraphMarkedOptions,
+  defaultParagraphSanitizeOptions: () => defaultParagraphSanitizeOptions,
+  inferParagraphContentFormat: () => inferParagraphContentFormat,
+  renderParagraphContentHtml: () => renderParagraphContentHtml,
+  renderParagraphDocumentHtml: () => renderParagraphDocumentHtml,
+  resolveParagraphContentInput: () => resolveParagraphContentInput,
+  resolveParagraphRootClassName: () => resolveParagraphRootClassName,
+  resolveParagraphSlotClassName: () => resolveParagraphSlotClassName,
+  useParagraphContent: () => useParagraphContent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/component.ts
+var import_vue = require("vue");
+
+// src/renderer.ts
+var import_parser_core = require("@paragraphcms/parser-core");
+function resolveParagraphContentInput(input) {
+  return (0, import_parser_core.resolveParagraphContentInput)(input);
+}
+function inferParagraphContentFormat(content, explicitFormat = null) {
+  return (0, import_parser_core.inferParagraphContentFormat)(
+    content,
+    explicitFormat
+  );
+}
+function resolveParagraphSlotClassName(slot, className, options = {}) {
+  return (0, import_parser_core.resolveParagraphSlotClassName)(
+    slot,
+    className,
+    options
+  );
+}
+function resolveParagraphRootClassName(className, options = {}) {
+  return (0, import_parser_core.resolveParagraphRootClassName)(
+    className,
+    options
+  );
+}
+function renderParagraphContentHtml(input) {
+  return (0, import_parser_core.renderParagraphContentHtml)(input);
+}
+function renderParagraphDocumentHtml(input) {
+  return (0, import_parser_core.renderParagraphDocumentHtml)(input);
+}
+
+// src/component.ts
+var ParagraphContent = (0, import_vue.defineComponent)({
+  name: "ParagraphContent",
+  inheritAttrs: false,
+  props: {
+    as: {
+      type: String,
+      default: "article"
+    },
+    page: {
+      type: Object,
+      default: null
+    },
+    content: {
+      type: [String, Array],
+      default: null
+    },
+    contentFormat: {
+      type: String,
+      default: null
+    },
+    classNames: {
+      type: Object,
+      default: void 0
+    },
+    markedOptions: {
+      type: Object,
+      default: void 0
+    },
+    sanitizeOptions: {
+      type: Object,
+      default: void 0
+    },
+    unstyled: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props, { attrs }) {
+    return () => {
+      const html = renderParagraphContentHtml(props);
+      if (html === null) {
+        return null;
+      }
+      const className = resolveParagraphRootClassName(
+        (0, import_vue.normalizeClass)(attrs.class),
+        props
+      );
+      return (0, import_vue.h)(props.as, {
+        ...attrs,
+        class: className,
+        innerHTML: html
+      });
+    };
+  }
+});
+function useParagraphContent(input) {
+  return (0, import_vue.computed)(() => renderParagraphContentHtml((0, import_vue.toValue)(input)));
+}
+function createParagraphDocumentHtml(input) {
+  return (0, import_vue.computed)(() => {
+    const value = (0, import_vue.toValue)(input);
+    const html = renderParagraphContentHtml(value);
+    if (html === null) {
+      return null;
+    }
+    const className = resolveParagraphRootClassName(void 0, value);
+    const tagName = typeof value.as === "string" ? value.as : "article";
+    return `<${tagName}${className ? ` class="${className}"` : ""}>${html}</${tagName}>`;
+  });
+}
+
+// src/defaults.ts
+var import_parser_core2 = require("@paragraphcms/parser-core");
+var defaultParagraphClassNames = import_parser_core2.defaultParagraphClassNames;
+var defaultParagraphMarkedOptions = import_parser_core2.defaultParagraphMarkedOptions;
+var defaultParagraphSanitizeOptions = import_parser_core2.defaultParagraphSanitizeOptions;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParagraphContent,
+  createParagraphDocumentHtml,
+  defaultParagraphClassNames,
+  defaultParagraphMarkedOptions,
+  defaultParagraphSanitizeOptions,
+  inferParagraphContentFormat,
+  renderParagraphContentHtml,
+  renderParagraphDocumentHtml,
+  resolveParagraphContentInput,
+  resolveParagraphRootClassName,
+  resolveParagraphSlotClassName,
+  useParagraphContent
+});

package/dist/index.d.cts

@@ -0,0 +1,143 @@
+import * as sanitizeHtml from 'sanitize-html';
+import sanitizeHtml__default from 'sanitize-html';
+import * as marked from 'marked';
+import { MarkedOptions } from 'marked';
+import * as vue from 'vue';
+import { PropType, MaybeRefOrGetter } from 'vue';
+
+type ParagraphContentFormat = "markdown" | "html" | "tiptap";
+type ParagraphTiptapMark = {
+    type?: string;
+    attrs?: Record<string, unknown>;
+};
+type ParagraphTiptapNode = {
+    type?: string;
+    attrs?: Record<string, unknown>;
+    text?: string;
+    marks?: ParagraphTiptapMark[];
+    content?: ParagraphTiptapNode[];
+};
+type ParagraphPageContent = string | ParagraphTiptapNode[];
+type ParagraphRenderablePage<TFields = Record<string, unknown>> = {
+    content_format?: ParagraphContentFormat | null;
+    content?: ParagraphPageContent;
+    fields?: TFields;
+};
+type ParagraphComponentSlot = "root" | "p" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "a" | "strong" | "em" | "u" | "s" | "blockquote" | "code" | "pre" | "ul" | "ol" | "li" | "hr" | "br" | "img" | "figure" | "figcaption" | "imageMeta" | "imageSlug" | "imageAlt" | "table" | "thead" | "tbody" | "tr" | "th" | "td" | "faq" | "collapsible" | "summary" | "collapsibleContent" | "taskList" | "taskItem" | "taskCheckbox";
+type ParagraphClassNames = Partial<Record<ParagraphComponentSlot, string>>;
+type ParagraphRenderOptions = {
+    classNames?: ParagraphClassNames;
+    markedOptions?: MarkedOptions;
+    sanitizeOptions?: sanitizeHtml__default.IOptions;
+    unstyled?: boolean;
+};
+type ParagraphContentInput<TFields = Record<string, unknown>> = {
+    page?: ParagraphRenderablePage<TFields> | null;
+    content?: ParagraphPageContent | null;
+    contentFormat?: ParagraphContentFormat | null;
+};
+type ParagraphContentProps<TFields = Record<string, unknown>> = ParagraphRenderOptions & {
+    as?: string;
+    page?: ParagraphRenderablePage<TFields> | null;
+    content?: ParagraphPageContent | null;
+    contentFormat?: ParagraphContentFormat | null;
+};
+
+declare const ParagraphContent: vue.DefineComponent<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+    page: {
+        type: PropType<ParagraphRenderablePage | null>;
+        default: null;
+    };
+    content: {
+        type: PropType<ParagraphPageContent | null>;
+        default: null;
+    };
+    contentFormat: {
+        type: PropType<ParagraphContentFormat | null>;
+        default: null;
+    };
+    classNames: {
+        type: PropType<ParagraphClassNames | undefined>;
+        default: undefined;
+    };
+    markedOptions: {
+        type: PropType<ParagraphRenderOptions["markedOptions"]>;
+        default: undefined;
+    };
+    sanitizeOptions: {
+        type: PropType<ParagraphRenderOptions["sanitizeOptions"]>;
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+    page: {
+        type: PropType<ParagraphRenderablePage | null>;
+        default: null;
+    };
+    content: {
+        type: PropType<ParagraphPageContent | null>;
+        default: null;
+    };
+    contentFormat: {
+        type: PropType<ParagraphContentFormat | null>;
+        default: null;
+    };
+    classNames: {
+        type: PropType<ParagraphClassNames | undefined>;
+        default: undefined;
+    };
+    markedOptions: {
+        type: PropType<ParagraphRenderOptions["markedOptions"]>;
+        default: undefined;
+    };
+    sanitizeOptions: {
+        type: PropType<ParagraphRenderOptions["sanitizeOptions"]>;
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    page: ParagraphRenderablePage | null;
+    content: ParagraphPageContent | null;
+    contentFormat: ParagraphContentFormat | null;
+    classNames: Partial<Record<ParagraphComponentSlot, string>> | undefined;
+    markedOptions: marked.MarkedOptions | undefined;
+    sanitizeOptions: sanitizeHtml.IOptions | undefined;
+    unstyled: boolean;
+    as: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare function useParagraphContent<TFields = Record<string, unknown>>(input: MaybeRefOrGetter<ParagraphContentInput<TFields> & ParagraphRenderOptions>): vue.ComputedRef<string | null>;
+declare function createParagraphDocumentHtml<TFields = Record<string, unknown>>(input: MaybeRefOrGetter<ParagraphContentProps<TFields>>): vue.ComputedRef<string | null>;
+
+declare const defaultParagraphClassNames: ParagraphClassNames;
+declare const defaultParagraphMarkedOptions: NonNullable<ParagraphRenderOptions["markedOptions"]>;
+declare const defaultParagraphSanitizeOptions: NonNullable<ParagraphRenderOptions["sanitizeOptions"]>;
+
+declare function resolveParagraphContentInput<TFields = Record<string, unknown>>(input: ParagraphContentInput<TFields>): {
+    content: ParagraphPageContent | null;
+    contentFormat: ParagraphContentFormat | null;
+};
+declare function inferParagraphContentFormat(content: ParagraphPageContent, explicitFormat?: ParagraphContentFormat | null): ParagraphContentFormat;
+declare function resolveParagraphSlotClassName(slot: ParagraphComponentSlot, className: string | undefined, options?: ParagraphRenderOptions): string | undefined;
+declare function resolveParagraphRootClassName(className: string | undefined, options?: ParagraphRenderOptions): string | undefined;
+declare function renderParagraphContentHtml<TFields = Record<string, unknown>>(input: ParagraphContentInput<TFields> & ParagraphRenderOptions): string | null;
+declare function renderParagraphDocumentHtml<TFields = Record<string, unknown>>(input: ParagraphContentProps<TFields> & {
+    className?: string;
+}): string | null;
+
+export { type ParagraphClassNames, type ParagraphComponentSlot, ParagraphContent, type ParagraphContentFormat, type ParagraphContentInput, type ParagraphContentProps, type ParagraphPageContent, type ParagraphRenderOptions, type ParagraphRenderablePage, type ParagraphTiptapMark, type ParagraphTiptapNode, createParagraphDocumentHtml, defaultParagraphClassNames, defaultParagraphMarkedOptions, defaultParagraphSanitizeOptions, inferParagraphContentFormat, renderParagraphContentHtml, renderParagraphDocumentHtml, resolveParagraphContentInput, resolveParagraphRootClassName, resolveParagraphSlotClassName, useParagraphContent };

package/dist/index.d.ts

@@ -0,0 +1,143 @@
+import * as sanitizeHtml from 'sanitize-html';
+import sanitizeHtml__default from 'sanitize-html';
+import * as marked from 'marked';
+import { MarkedOptions } from 'marked';
+import * as vue from 'vue';
+import { PropType, MaybeRefOrGetter } from 'vue';
+
+type ParagraphContentFormat = "markdown" | "html" | "tiptap";
+type ParagraphTiptapMark = {
+    type?: string;
+    attrs?: Record<string, unknown>;
+};
+type ParagraphTiptapNode = {
+    type?: string;
+    attrs?: Record<string, unknown>;
+    text?: string;
+    marks?: ParagraphTiptapMark[];
+    content?: ParagraphTiptapNode[];
+};
+type ParagraphPageContent = string | ParagraphTiptapNode[];
+type ParagraphRenderablePage<TFields = Record<string, unknown>> = {
+    content_format?: ParagraphContentFormat | null;
+    content?: ParagraphPageContent;
+    fields?: TFields;
+};
+type ParagraphComponentSlot = "root" | "p" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "a" | "strong" | "em" | "u" | "s" | "blockquote" | "code" | "pre" | "ul" | "ol" | "li" | "hr" | "br" | "img" | "figure" | "figcaption" | "imageMeta" | "imageSlug" | "imageAlt" | "table" | "thead" | "tbody" | "tr" | "th" | "td" | "faq" | "collapsible" | "summary" | "collapsibleContent" | "taskList" | "taskItem" | "taskCheckbox";
+type ParagraphClassNames = Partial<Record<ParagraphComponentSlot, string>>;
+type ParagraphRenderOptions = {
+    classNames?: ParagraphClassNames;
+    markedOptions?: MarkedOptions;
+    sanitizeOptions?: sanitizeHtml__default.IOptions;
+    unstyled?: boolean;
+};
+type ParagraphContentInput<TFields = Record<string, unknown>> = {
+    page?: ParagraphRenderablePage<TFields> | null;
+    content?: ParagraphPageContent | null;
+    contentFormat?: ParagraphContentFormat | null;
+};
+type ParagraphContentProps<TFields = Record<string, unknown>> = ParagraphRenderOptions & {
+    as?: string;
+    page?: ParagraphRenderablePage<TFields> | null;
+    content?: ParagraphPageContent | null;
+    contentFormat?: ParagraphContentFormat | null;
+};
+
+declare const ParagraphContent: vue.DefineComponent<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+    page: {
+        type: PropType<ParagraphRenderablePage | null>;
+        default: null;
+    };
+    content: {
+        type: PropType<ParagraphPageContent | null>;
+        default: null;
+    };
+    contentFormat: {
+        type: PropType<ParagraphContentFormat | null>;
+        default: null;
+    };
+    classNames: {
+        type: PropType<ParagraphClassNames | undefined>;
+        default: undefined;
+    };
+    markedOptions: {
+        type: PropType<ParagraphRenderOptions["markedOptions"]>;
+        default: undefined;
+    };
+    sanitizeOptions: {
+        type: PropType<ParagraphRenderOptions["sanitizeOptions"]>;
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+    page: {
+        type: PropType<ParagraphRenderablePage | null>;
+        default: null;
+    };
+    content: {
+        type: PropType<ParagraphPageContent | null>;
+        default: null;
+    };
+    contentFormat: {
+        type: PropType<ParagraphContentFormat | null>;
+        default: null;
+    };
+    classNames: {
+        type: PropType<ParagraphClassNames | undefined>;
+        default: undefined;
+    };
+    markedOptions: {
+        type: PropType<ParagraphRenderOptions["markedOptions"]>;
+        default: undefined;
+    };
+    sanitizeOptions: {
+        type: PropType<ParagraphRenderOptions["sanitizeOptions"]>;
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    page: ParagraphRenderablePage | null;
+    content: ParagraphPageContent | null;
+    contentFormat: ParagraphContentFormat | null;
+    classNames: Partial<Record<ParagraphComponentSlot, string>> | undefined;
+    markedOptions: marked.MarkedOptions | undefined;
+    sanitizeOptions: sanitizeHtml.IOptions | undefined;
+    unstyled: boolean;
+    as: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare function useParagraphContent<TFields = Record<string, unknown>>(input: MaybeRefOrGetter<ParagraphContentInput<TFields> & ParagraphRenderOptions>): vue.ComputedRef<string | null>;
+declare function createParagraphDocumentHtml<TFields = Record<string, unknown>>(input: MaybeRefOrGetter<ParagraphContentProps<TFields>>): vue.ComputedRef<string | null>;
+
+declare const defaultParagraphClassNames: ParagraphClassNames;
+declare const defaultParagraphMarkedOptions: NonNullable<ParagraphRenderOptions["markedOptions"]>;
+declare const defaultParagraphSanitizeOptions: NonNullable<ParagraphRenderOptions["sanitizeOptions"]>;
+
+declare function resolveParagraphContentInput<TFields = Record<string, unknown>>(input: ParagraphContentInput<TFields>): {
+    content: ParagraphPageContent | null;
+    contentFormat: ParagraphContentFormat | null;
+};
+declare function inferParagraphContentFormat(content: ParagraphPageContent, explicitFormat?: ParagraphContentFormat | null): ParagraphContentFormat;
+declare function resolveParagraphSlotClassName(slot: ParagraphComponentSlot, className: string | undefined, options?: ParagraphRenderOptions): string | undefined;
+declare function resolveParagraphRootClassName(className: string | undefined, options?: ParagraphRenderOptions): string | undefined;
+declare function renderParagraphContentHtml<TFields = Record<string, unknown>>(input: ParagraphContentInput<TFields> & ParagraphRenderOptions): string | null;
+declare function renderParagraphDocumentHtml<TFields = Record<string, unknown>>(input: ParagraphContentProps<TFields> & {
+    className?: string;
+}): string | null;
+
+export { type ParagraphClassNames, type ParagraphComponentSlot, ParagraphContent, type ParagraphContentFormat, type ParagraphContentInput, type ParagraphContentProps, type ParagraphPageContent, type ParagraphRenderOptions, type ParagraphRenderablePage, type ParagraphTiptapMark, type ParagraphTiptapNode, createParagraphDocumentHtml, defaultParagraphClassNames, defaultParagraphMarkedOptions, defaultParagraphSanitizeOptions, inferParagraphContentFormat, renderParagraphContentHtml, renderParagraphDocumentHtml, resolveParagraphContentInput, resolveParagraphRootClassName, resolveParagraphSlotClassName, useParagraphContent };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,sBAAsB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEpE,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC9B,OAAO,CAAC,EAAE,mBAAmB,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,mBAAmB,EAAE,CAAC;AAElE,MAAM,MAAM,uBAAuB,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IACvE,cAAc,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAC/C,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,wBAAwB,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IACxE,IAAI,CAAC,EAAE,uBAAuB,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC/C,OAAO,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACtC,aAAa,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAC;CAC/C,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1E,KAAK,EAAE,wBAAwB,CAAC,OAAO,CAAC;;;EAWzC;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,oBAAoB,EAC7B,cAAc,GAAE,sBAAsB,GAAG,IAAW,GACnD,sBAAsB,CAYxB"}

package/dist/index.js

@@ -0,0 +1,142 @@
+// src/component.ts
+import {
+  computed,
+  defineComponent,
+  h,
+  normalizeClass,
+  toValue
+} from "vue";
+
+// src/renderer.ts
+import {
+  inferParagraphContentFormat as coreInferParagraphContentFormat,
+  renderParagraphContentHtml as coreRenderParagraphContentHtml,
+  renderParagraphDocumentHtml as coreRenderParagraphDocumentHtml,
+  resolveParagraphContentInput as coreResolveParagraphContentInput,
+  resolveParagraphRootClassName as coreResolveParagraphRootClassName,
+  resolveParagraphSlotClassName as coreResolveParagraphSlotClassName
+} from "@paragraphcms/parser-core";
+function resolveParagraphContentInput(input) {
+  return coreResolveParagraphContentInput(input);
+}
+function inferParagraphContentFormat(content, explicitFormat = null) {
+  return coreInferParagraphContentFormat(
+    content,
+    explicitFormat
+  );
+}
+function resolveParagraphSlotClassName(slot, className, options = {}) {
+  return coreResolveParagraphSlotClassName(
+    slot,
+    className,
+    options
+  );
+}
+function resolveParagraphRootClassName(className, options = {}) {
+  return coreResolveParagraphRootClassName(
+    className,
+    options
+  );
+}
+function renderParagraphContentHtml(input) {
+  return coreRenderParagraphContentHtml(input);
+}
+function renderParagraphDocumentHtml(input) {
+  return coreRenderParagraphDocumentHtml(input);
+}
+
+// src/component.ts
+var ParagraphContent = defineComponent({
+  name: "ParagraphContent",
+  inheritAttrs: false,
+  props: {
+    as: {
+      type: String,
+      default: "article"
+    },
+    page: {
+      type: Object,
+      default: null
+    },
+    content: {
+      type: [String, Array],
+      default: null
+    },
+    contentFormat: {
+      type: String,
+      default: null
+    },
+    classNames: {
+      type: Object,
+      default: void 0
+    },
+    markedOptions: {
+      type: Object,
+      default: void 0
+    },
+    sanitizeOptions: {
+      type: Object,
+      default: void 0
+    },
+    unstyled: {
+      type: Boolean,
+      default: false
+    }
+  },
+  setup(props, { attrs }) {
+    return () => {
+      const html = renderParagraphContentHtml(props);
+      if (html === null) {
+        return null;
+      }
+      const className = resolveParagraphRootClassName(
+        normalizeClass(attrs.class),
+        props
+      );
+      return h(props.as, {
+        ...attrs,
+        class: className,
+        innerHTML: html
+      });
+    };
+  }
+});
+function useParagraphContent(input) {
+  return computed(() => renderParagraphContentHtml(toValue(input)));
+}
+function createParagraphDocumentHtml(input) {
+  return computed(() => {
+    const value = toValue(input);
+    const html = renderParagraphContentHtml(value);
+    if (html === null) {
+      return null;
+    }
+    const className = resolveParagraphRootClassName(void 0, value);
+    const tagName = typeof value.as === "string" ? value.as : "article";
+    return `<${tagName}${className ? ` class="${className}"` : ""}>${html}</${tagName}>`;
+  });
+}
+
+// src/defaults.ts
+import {
+  defaultParagraphClassNames as coreDefaultParagraphClassNames,
+  defaultParagraphMarkedOptions as coreDefaultParagraphMarkedOptions,
+  defaultParagraphSanitizeOptions as coreDefaultParagraphSanitizeOptions
+} from "@paragraphcms/parser-core";
+var defaultParagraphClassNames = coreDefaultParagraphClassNames;
+var defaultParagraphMarkedOptions = coreDefaultParagraphMarkedOptions;
+var defaultParagraphSanitizeOptions = coreDefaultParagraphSanitizeOptions;
+export {
+  ParagraphContent,
+  createParagraphDocumentHtml,
+  defaultParagraphClassNames,
+  defaultParagraphMarkedOptions,
+  defaultParagraphSanitizeOptions,
+  inferParagraphContentFormat,
+  renderParagraphContentHtml,
+  renderParagraphDocumentHtml,
+  resolveParagraphContentInput,
+  resolveParagraphRootClassName,
+  resolveParagraphSlotClassName,
+  useParagraphContent
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@paragraphcms/parser-vue",
+  "version": "0.1.0",
+  "description": "Vue renderer for Paragraph CMS content.",
+  "license": "MIT",
+  "author": "Paragraph CMS",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run check && npm run build"
+  },
+  "peerDependencies": {
+    "vue": "^3.4.0"
+  },
+  "dependencies": {
+    "@paragraphcms/parser-core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/sanitize-html": "^2.13.0",
+    "marked": "^15.0.12",
+    "sanitize-html": "^2.15.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vue": "^3.5.13"
+  }
+}