@lupinum/nuxt-email 0.1.0

package/dist/runtime/components/EButton.padding.js

@@ -0,0 +1,118 @@
+import { normalizeEmailStyle } from "./style.js";
+export function convertToPixels(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError(`EButton padding must be a finite non-negative value; received ${String(value)}`);
+    }
+    return value;
+  }
+  if (typeof value !== "string") {
+    throw new TypeError(`EButton padding must be a number or CSS length string; received ${String(value)}`);
+  }
+  const normalizedValue = value.trim();
+  if (normalizedValue === "0") {
+    return 0;
+  }
+  const matches = /^(\d+(?:\.\d+)?|\.\d+)(px|em|rem|%)$/.exec(normalizedValue);
+  if (!matches) {
+    throw new TypeError(
+      `EButton padding supports only non-negative px, em, rem, and % values; received ${value}`
+    );
+  }
+  const amount = Number.parseFloat(matches[1]);
+  if (!Number.isFinite(amount)) {
+    throw new TypeError(`EButton padding must resolve to finite pixels; received ${value}`);
+  }
+  switch (matches[2]) {
+    case "em":
+    case "rem":
+      return amount * 16;
+    case "%":
+      return amount / 100 * 600;
+    default:
+      return amount;
+  }
+}
+function expandPadding(value) {
+  if (typeof value === "number") {
+    return {
+      paddingTop: value,
+      paddingBottom: value,
+      paddingLeft: value,
+      paddingRight: value
+    };
+  }
+  if (typeof value === "string") {
+    const values = value.trim().split(/\s+/);
+    if (values.length === 1) {
+      return {
+        paddingTop: values[0],
+        paddingBottom: values[0],
+        paddingLeft: values[0],
+        paddingRight: values[0]
+      };
+    }
+    if (values.length === 2) {
+      return {
+        paddingTop: values[0],
+        paddingRight: values[1],
+        paddingBottom: values[0],
+        paddingLeft: values[1]
+      };
+    }
+    if (values.length === 3) {
+      return {
+        paddingTop: values[0],
+        paddingRight: values[1],
+        paddingBottom: values[2],
+        paddingLeft: values[1]
+      };
+    }
+    if (values.length === 4) {
+      return {
+        paddingTop: values[0],
+        paddingRight: values[1],
+        paddingBottom: values[2],
+        paddingLeft: values[3]
+      };
+    }
+  }
+  throw new TypeError(`EButton padding shorthand must contain one to four values; received ${String(value)}`);
+}
+function convertOptionalPadding(value) {
+  return value === void 0 ? void 0 : convertToPixels(value);
+}
+export function parseButtonPadding(style) {
+  let paddingTop;
+  let paddingRight;
+  let paddingBottom;
+  let paddingLeft;
+  for (const [property, value] of Object.entries(normalizeEmailStyle(style) ?? {})) {
+    if (property === "padding") {
+      ({ paddingTop, paddingRight, paddingBottom, paddingLeft } = expandPadding(value));
+    } else if (property === "paddingTop") {
+      paddingTop = value;
+    } else if (property === "paddingRight") {
+      paddingRight = value;
+    } else if (property === "paddingBottom") {
+      paddingBottom = value;
+    } else if (property === "paddingLeft") {
+      paddingLeft = value;
+    }
+  }
+  return {
+    paddingTop: convertOptionalPadding(paddingTop),
+    paddingRight: convertOptionalPadding(paddingRight),
+    paddingBottom: convertOptionalPadding(paddingBottom),
+    paddingLeft: convertOptionalPadding(paddingLeft)
+  };
+}
+export function pixelsToPoints(pixels) {
+  return typeof pixels === "number" && !Number.isNaN(Number(pixels)) ? pixels * 3 / 4 : void 0;
+}
+export function pixelStyle(value) {
+  if (value === void 0 || value === 0) {
+    return value;
+  }
+  return `${value}px`;
+}

package/dist/runtime/components/ECodeInline.d.ts

@@ -0,0 +1,13 @@
+import type { DefineComponent, HTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type ECodeInlineProps = SafeEmailAttributes<HTMLAttributes>;
+/**
+ * Byte-identical to React Email's Orange.fr fix-up `<style>` (see
+ * code-inline.tsx). Exported so conformance can assert the exact bytes.
+ *
+ * On the Orange.fr email client the head/html elements are removed, turning
+ * the meta tag into a sibling; the `meta ~` selectors then swap which copy of
+ * the children is visible.
+ */
+export declare const ORANGE_FR_STYLE = "\n        meta ~ .cino {\n          display: none !important;\n          opacity: 0 !important;\n        }\n\n        meta ~ .cio {\n          display: block !important;\n        }\n      ";
+export declare const ECodeInline: DefineComponent<ECodeInlineProps>;

package/dist/runtime/components/ECodeInline.js

@@ -0,0 +1,43 @@
+import { defineComponent, h } from "vue";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { mergeEmailStyles } from "./style.js";
+export const ORANGE_FR_STYLE = `
+        meta ~ .cino {
+          display: none !important;
+          opacity: 0 !important;
+        }
+
+        meta ~ .cio {
+          display: block !important;
+        }
+      `;
+export const ECodeInline = defineComponent({
+  name: "ECodeInline",
+  inheritAttrs: false,
+  setup(_props, { attrs, slots }) {
+    return () => {
+      assertSafeEmailAttributes("ECodeInline", attrs);
+      const { class: className, style, ...attributes } = attrs;
+      const userClass = typeof className === "string" && className ? className : "";
+      const codeProps = {
+        ...attributes,
+        class: `${userClass} cino`
+      };
+      if (style !== void 0) {
+        codeProps.style = style;
+      }
+      return [
+        h("style", ORANGE_FR_STYLE),
+        // Does not render on Orange.fr
+        h("code", codeProps, slots.default?.()),
+        // Renders only on Orange.fr
+        h("span", {
+          ...attributes,
+          "class": `${userClass} cio`,
+          "style": mergeEmailStyles({ display: "none" }, style),
+          "data-skip-in-text": "true"
+        }, slots.default?.())
+      ];
+    };
+  }
+});

package/dist/runtime/components/EColumn.d.ts

@@ -0,0 +1,4 @@
+import type { DefineComponent, TdHTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type EColumnProps = SafeEmailAttributes<TdHTMLAttributes>;
+export declare const EColumn: DefineComponent<EColumnProps>;

package/dist/runtime/components/EColumn.js

@@ -0,0 +1,12 @@
+import { defineComponent, h } from "vue";
+import { assertSafeEmailAttributes } from "./attributes.js";
+export const EColumn = defineComponent({
+  name: "EColumn",
+  inheritAttrs: false,
+  setup(_props, { attrs, slots }) {
+    return () => {
+      assertSafeEmailAttributes("EColumn", attrs);
+      return h("td", attrs, slots.default?.());
+    };
+  }
+});

package/dist/runtime/components/EContainer.d.ts

@@ -0,0 +1,4 @@
+import type { DefineComponent, TableHTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type EContainerProps = Omit<SafeEmailAttributes<TableHTMLAttributes>, 'border' | 'cellpadding' | 'cellspacing' | 'role'>;
+export declare const EContainer: DefineComponent<EContainerProps>;

package/dist/runtime/components/EContainer.js

@@ -0,0 +1,35 @@
+import { defineComponent, h, inject } from "vue";
+import { resolveNestedTailwindStyle, TAILWIND_NESTED_KEY } from "../tailwind/nested.js";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { assertFixedPresentationTable } from "./presentation-table.js";
+import { splitTablePadding } from "./table-padding.js";
+export const EContainer = defineComponent({
+  name: "EContainer",
+  inheritAttrs: false,
+  setup(_props, { attrs, slots }) {
+    const holder = inject(TAILWIND_NESTED_KEY, null);
+    return () => {
+      assertSafeEmailAttributes("EContainer", attrs);
+      assertFixedPresentationTable("EContainer", attrs);
+      const { style, ...attributes } = attrs;
+      const effectiveStyle = resolveNestedTailwindStyle(holder, attributes, style).style;
+      const { tableStyle, cellStyle } = splitTablePadding(effectiveStyle);
+      return h("table", {
+        align: "center",
+        width: "100%",
+        ...attributes,
+        border: 0,
+        cellpadding: "0",
+        cellspacing: "0",
+        role: "presentation",
+        style: { maxWidth: "37.5em", ...tableStyle }
+      }, [
+        h("tbody", [
+          h("tr", { style: { width: "100%" } }, [
+            h("td", Object.keys(cellStyle).length > 0 ? { style: cellStyle } : {}, slots.default?.())
+          ])
+        ])
+      ]);
+    };
+  }
+});

package/dist/runtime/components/EFont.d.ts

@@ -0,0 +1,24 @@
+import type { DefineComponent } from 'vue';
+export type FontFallback = 'Arial' | 'Helvetica' | 'Verdana' | 'Georgia' | 'Times New Roman' | 'serif' | 'sans-serif' | 'monospace' | 'cursive' | 'fantasy';
+export type FontFormat = 'woff' | 'woff2' | 'truetype' | 'opentype' | 'embedded-opentype' | 'svg';
+export interface FontWebFont {
+    url: string;
+    format: FontFormat;
+}
+export type FontStyle = 'normal' | 'italic' | 'oblique';
+export type FontWeight = number | 'normal' | 'bold' | 'bolder' | 'lighter';
+export type FontFallbackList = readonly [FontFallback, ...FontFallback[]];
+export interface EFontProps {
+    /** The font you want to use. Do not insert multiple fonts here, use fallbackFontFamily for that. */
+    fontFamily: string;
+    /** A non-empty array is possible; the order of the array is the priority order. */
+    fallbackFontFamily: FontFallback | FontFallbackList;
+    /** Web font source; not all clients support web fonts. */
+    webFont?: FontWebFont;
+    /** Default: 'normal' */
+    fontStyle?: FontStyle;
+    /** Default: 400 */
+    fontWeight?: FontWeight;
+}
+/** The component MUST be placed inside the <head> tag. */
+export declare const EFont: DefineComponent<EFontProps>;

package/dist/runtime/components/EFont.js

@@ -0,0 +1,124 @@
+import { defineComponent, h } from "vue";
+const FONT_FALLBACKS = /* @__PURE__ */ new Set([
+  "Arial",
+  "Helvetica",
+  "Verdana",
+  "Georgia",
+  "Times New Roman",
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy"
+]);
+const FONT_FORMATS = /* @__PURE__ */ new Set([
+  "woff",
+  "woff2",
+  "truetype",
+  "opentype",
+  "embedded-opentype",
+  "svg"
+]);
+const FONT_STYLES = /* @__PURE__ */ new Set(["normal", "italic", "oblique"]);
+const FONT_WEIGHTS = /* @__PURE__ */ new Set(["normal", "bold", "bolder", "lighter"]);
+const SAFE_UNQUOTED_URL = /^[\w\-.~:/?#[\]@!$&*+,;=%]+$/;
+function cssString(value) {
+  return value.replace(/[\\'\n\r\f\0<>]/g, (character) => {
+    switch (character) {
+      case "\\":
+        return "\\\\";
+      case "'":
+        return "\\'";
+      case "\n":
+      case "\r":
+      case "\f":
+        return "\\A ";
+      case "\0":
+        return "\\FFFD ";
+      case "<":
+        return "\\3C ";
+      case ">":
+        return "\\3E ";
+      default:
+        return character;
+    }
+  });
+}
+function cssUrl(value) {
+  return SAFE_UNQUOTED_URL.test(value) ? value : `'${cssString(value)}'`;
+}
+function assertValidFontProps(props) {
+  if (props.fontFamily.trim().length === 0) {
+    throw new TypeError("EFont fontFamily must be a non-empty string");
+  }
+  const fallbacks = Array.isArray(props.fallbackFontFamily) ? props.fallbackFontFamily : [props.fallbackFontFamily];
+  if (fallbacks.length === 0) {
+    throw new TypeError("EFont fallbackFontFamily must contain at least one fallback");
+  }
+  const invalidFallback = fallbacks.find((fallback) => !FONT_FALLBACKS.has(fallback));
+  if (invalidFallback !== void 0) {
+    throw new TypeError(`EFont fallbackFontFamily contains unsupported fallback ${JSON.stringify(invalidFallback)}`);
+  }
+  if (!FONT_STYLES.has(props.fontStyle ?? "normal")) {
+    throw new TypeError(`EFont fontStyle must be normal, italic, or oblique; received ${JSON.stringify(props.fontStyle)}`);
+  }
+  const weight = props.fontWeight ?? 400;
+  if (typeof weight === "number" ? !Number.isFinite(weight) || weight < 1 || weight > 1e3 : !FONT_WEIGHTS.has(weight)) {
+    throw new TypeError(`EFont fontWeight must be between 1 and 1000 or a supported keyword; received ${JSON.stringify(weight)}`);
+  }
+  if (props.webFont !== void 0) {
+    if (props.webFont.url.trim().length === 0) {
+      throw new TypeError("EFont webFont.url must be a non-empty string");
+    }
+    if (!FONT_FORMATS.has(props.webFont.format)) {
+      throw new TypeError(`EFont webFont.format is unsupported: ${JSON.stringify(props.webFont.format)}`);
+    }
+  }
+}
+export const EFont = defineComponent({
+  name: "EFont",
+  inheritAttrs: false,
+  props: {
+    fontFamily: {
+      type: String,
+      required: true
+    },
+    fallbackFontFamily: {
+      type: [String, Array],
+      required: true
+    },
+    webFont: {
+      type: Object,
+      default: void 0
+    },
+    fontStyle: {
+      type: String,
+      default: "normal"
+    },
+    fontWeight: {
+      type: [String, Number],
+      default: 400
+    }
+  },
+  setup(props) {
+    return () => {
+      assertValidFontProps(props);
+      const fallbacks = Array.isArray(props.fallbackFontFamily) ? props.fallbackFontFamily : [props.fallbackFontFamily];
+      const src = props.webFont ? `src: url(${cssUrl(props.webFont.url)}) format('${props.webFont.format}');` : "";
+      const style = `
+    @font-face {
+      font-family: '${cssString(props.fontFamily)}';
+      font-style: ${props.fontStyle};
+      font-weight: ${props.fontWeight};
+      mso-font-alt: '${fallbacks[0]}';
+      ${src}
+    }
+
+    * {
+      font-family: '${cssString(props.fontFamily)}', ${fallbacks.join(", ")};
+    }
+  `;
+      return h("style", { innerHTML: style });
+    };
+  }
+});

package/dist/runtime/components/EHead.d.ts

@@ -0,0 +1,4 @@
+import type { DefineComponent, HTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type EHeadProps = SafeEmailAttributes<HTMLAttributes>;
+export declare const EHead: DefineComponent<EHeadProps>;

package/dist/runtime/components/EHead.js

@@ -0,0 +1,17 @@
+import { defineComponent, h } from "vue";
+import { assertSafeEmailAttributes } from "./attributes.js";
+export const EHead = defineComponent({
+  name: "EHead",
+  inheritAttrs: false,
+  setup(_props, { attrs, slots }) {
+    return () => {
+      assertSafeEmailAttributes("EHead", attrs);
+      const children = slots.default?.() ?? [];
+      return h("head", attrs, [
+        h("meta", { "content": "text/html; charset=UTF-8", "http-equiv": "Content-Type" }),
+        h("meta", { name: "x-apple-disable-message-reformatting" }),
+        ...children
+      ]);
+    };
+  }
+});

package/dist/runtime/components/EHeading.d.ts

@@ -0,0 +1,7 @@
+import type { DefineComponent, HTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export type EHeadingProps = SafeEmailAttributes<HTMLAttributes> & {
+    as?: HeadingTag;
+};
+export declare const EHeading: DefineComponent<EHeadingProps>;

package/dist/runtime/components/EHeading.js

@@ -0,0 +1,23 @@
+import { defineComponent, h } from "vue";
+import { assertSafeEmailAttributes } from "./attributes.js";
+const HEADING_TAGS = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+export const EHeading = defineComponent({
+  name: "EHeading",
+  inheritAttrs: false,
+  props: {
+    as: {
+      type: String,
+      default: "h1"
+    }
+  },
+  setup(props, { attrs, slots }) {
+    return () => {
+      assertSafeEmailAttributes("EHeading", attrs);
+      const tag = props.as ?? "h1";
+      if (!HEADING_TAGS.has(tag)) {
+        throw new TypeError(`EHeading as must be one of ${[...HEADING_TAGS].join(", ")}; received ${String(tag)}`);
+      }
+      return h(tag, attrs, slots.default?.());
+    };
+  }
+});

package/dist/runtime/components/EHr.d.ts

@@ -0,0 +1,4 @@
+import type { DefineComponent, HTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type EHrProps = SafeEmailAttributes<HTMLAttributes>;
+export declare const EHr: DefineComponent<EHrProps>;

package/dist/runtime/components/EHr.js

@@ -0,0 +1,26 @@
+import { defineComponent, h, inject } from "vue";
+import { resolveNestedTailwindStyle, TAILWIND_NESTED_KEY } from "../tailwind/nested.js";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { mergeEmailStyles } from "./style.js";
+const DEFAULT_HR_STYLE = {
+  width: "100%",
+  border: "none",
+  borderColor: "transparent",
+  borderTop: "1px solid #eaeaea"
+};
+export const EHr = defineComponent({
+  name: "EHr",
+  inheritAttrs: false,
+  setup(_props, { attrs }) {
+    const holder = inject(TAILWIND_NESTED_KEY, null);
+    return () => {
+      assertSafeEmailAttributes("EHr", attrs);
+      const { style, ...attributes } = attrs;
+      const effectiveStyle = resolveNestedTailwindStyle(holder, attributes, style).style;
+      return h("hr", {
+        ...attributes,
+        style: mergeEmailStyles(DEFAULT_HR_STYLE, effectiveStyle)
+      });
+    };
+  }
+});

package/dist/runtime/components/EHtml.d.ts

@@ -0,0 +1,4 @@
+import type { DefineComponent, HTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type EHtmlProps = SafeEmailAttributes<HTMLAttributes>;
+export declare const EHtml: DefineComponent<EHtmlProps>;

package/dist/runtime/components/EHtml.js

@@ -0,0 +1,17 @@
+import { defineComponent, h } from "vue";
+import { assertSafeEmailAttributes } from "./attributes.js";
+export const EHtml = defineComponent({
+  name: "EHtml",
+  inheritAttrs: false,
+  setup(_props, { attrs, slots }) {
+    return () => {
+      assertSafeEmailAttributes("EHtml", attrs);
+      const { dir = "ltr", lang = "en", ...attributes } = attrs;
+      return h("html", {
+        ...attributes,
+        dir,
+        lang
+      }, slots.default?.());
+    };
+  }
+});

package/dist/runtime/components/EImg.d.ts

@@ -0,0 +1,7 @@
+import type { DefineComponent, ImgHTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type EImgProps = Omit<SafeEmailAttributes<ImgHTMLAttributes>, 'alt' | 'src'> & {
+    alt: string;
+    src: string;
+};
+export declare const EImg: DefineComponent<EImgProps>;

package/dist/runtime/components/EImg.js

@@ -0,0 +1,44 @@
+import { defineComponent, h, inject } from "vue";
+import { resolveNestedTailwindStyle, TAILWIND_NESTED_KEY } from "../tailwind/nested.js";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { mergeEmailStyles } from "./style.js";
+const DEFAULT_IMAGE_STYLE = {
+  display: "block",
+  outline: "none",
+  border: "none",
+  textDecoration: "none"
+};
+export const EImg = defineComponent({
+  name: "EImg",
+  inheritAttrs: false,
+  props: {
+    alt: {
+      type: String,
+      required: true
+    },
+    src: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props, { attrs }) {
+    const holder = inject(TAILWIND_NESTED_KEY, null);
+    return () => {
+      assertSafeEmailAttributes("EImg", attrs);
+      if (typeof props.alt !== "string") {
+        throw new TypeError("EImg alt must be a string; use an empty string for decorative images");
+      }
+      if (typeof props.src !== "string" || props.src.length === 0) {
+        throw new TypeError("EImg src must be a non-empty string");
+      }
+      const { style, ...attributes } = attrs;
+      const effectiveStyle = resolveNestedTailwindStyle(holder, attributes, style).style;
+      return h("img", {
+        ...attributes,
+        alt: props.alt,
+        src: props.src,
+        style: mergeEmailStyles(DEFAULT_IMAGE_STYLE, effectiveStyle)
+      });
+    };
+  }
+});

package/dist/runtime/components/ELink.d.ts

@@ -0,0 +1,6 @@
+import type { AnchorHTMLAttributes, DefineComponent } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type ELinkProps = Omit<SafeEmailAttributes<AnchorHTMLAttributes>, 'href'> & {
+    href: string;
+};
+export declare const ELink: DefineComponent<ELinkProps>;

package/dist/runtime/components/ELink.js

@@ -0,0 +1,35 @@
+import { defineComponent, h, inject } from "vue";
+import { resolveNestedTailwindStyle, TAILWIND_NESTED_KEY } from "../tailwind/nested.js";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { mergeEmailStyles } from "./style.js";
+const DEFAULT_LINK_STYLE = {
+  color: "#067df7",
+  textDecorationLine: "none"
+};
+export const ELink = defineComponent({
+  name: "ELink",
+  inheritAttrs: false,
+  props: {
+    href: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props, { attrs, slots }) {
+    const holder = inject(TAILWIND_NESTED_KEY, null);
+    return () => {
+      assertSafeEmailAttributes("ELink", attrs);
+      if (typeof props.href !== "string" || props.href.length === 0) {
+        throw new TypeError("ELink href must be a non-empty string");
+      }
+      const { style, ...attributes } = attrs;
+      const effectiveStyle = resolveNestedTailwindStyle(holder, attributes, style).style;
+      return h("a", {
+        ...attributes,
+        href: props.href,
+        style: mergeEmailStyles(DEFAULT_LINK_STYLE, effectiveStyle),
+        target: attrs.target ?? "_blank"
+      }, slots.default?.());
+    };
+  }
+});

package/dist/runtime/components/EMarkdown.d.ts

@@ -0,0 +1,8 @@
+import type { DefineComponent, HTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+import type { StylesType } from './markdown/styles.js';
+export type EMarkdownProps = SafeEmailAttributes<HTMLAttributes> & {
+    source?: string;
+    markdownCustomStyles?: StylesType;
+};
+export declare const EMarkdown: DefineComponent<EMarkdownProps>;

package/dist/runtime/components/EMarkdown.js

@@ -0,0 +1,64 @@
+import { Comment, defineComponent, Fragment, h, isVNode, Text } from "vue";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { renderMarkdown } from "./markdown/render-markdown.js";
+function appendSlotText(child, text) {
+  if (child === null || child === void 0 || typeof child === "boolean") {
+    return;
+  }
+  if (typeof child === "string" || typeof child === "number") {
+    text.value += String(child);
+    return;
+  }
+  if (Array.isArray(child)) {
+    for (const nestedChild of child) {
+      appendSlotText(nestedChild, text);
+    }
+    return;
+  }
+  if (!isVNode(child)) {
+    throw new TypeError("EMarkdown default slot must contain text only");
+  }
+  if (child.type === Comment) {
+    return;
+  }
+  if (child.type === Text) {
+    appendSlotText(child.children, text);
+    return;
+  }
+  if (child.type === Fragment && Array.isArray(child.children)) {
+    appendSlotText(child.children, text);
+    return;
+  }
+  throw new TypeError("EMarkdown default slot must contain text only");
+}
+function slotSource(children) {
+  const text = { value: "" };
+  appendSlotText(children, text);
+  return text.value;
+}
+export const EMarkdown = defineComponent({
+  name: "EMarkdown",
+  inheritAttrs: false,
+  props: {
+    source: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    markdownCustomStyles: {
+      type: Object,
+      required: false,
+      default: void 0
+    }
+  },
+  setup(props, { attrs, slots }) {
+    return () => {
+      assertSafeEmailAttributes("EMarkdown", attrs);
+      const source = typeof props.source === "string" ? props.source : slotSource(slots.default?.() ?? []);
+      return h("div", {
+        ...attrs,
+        innerHTML: renderMarkdown(source, props.markdownCustomStyles)
+      });
+    };
+  }
+});