@lupinum/nuxt-email 0.1.0

package/dist/module.mjs

@@ -0,0 +1,300 @@
+import { relative, isAbsolute, sep, resolve } from 'node:path';
+import { resolveFiles, defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, addServerImports, addComponent, addServerHandler, useNitro, updateTemplates } from '@nuxt/kit';
+import vueRollup from 'unplugin-vue/rollup';
+import { stat } from 'node:fs/promises';
+import { EMAIL_COMPONENT_NAMES } from '../dist/runtime/components/email-component-names.js';
+
+function previewFixturePath(sourcePath) {
+  return `${sourcePath.slice(0, -".vue".length)}.fixtures.ts`;
+}
+async function existingPreviewFixturePath(sourcePath) {
+  const fixturePath = previewFixturePath(sourcePath);
+  try {
+    const fixture = await stat(fixturePath);
+    return fixture.isFile() ? fixturePath : void 0;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw new Error(`Failed to inspect preview fixture ${fixturePath}`, { cause: error });
+  }
+}
+async function attachPreviewFixtures(templates) {
+  return Promise.all(templates.map(async (template) => {
+    const fixturePath = await existingPreviewFixturePath(template.sourcePath);
+    return fixturePath ? { ...template, fixturePath } : { ...template };
+  }));
+}
+
+class DuplicateEmailTemplateError extends Error {
+  templateName;
+  sourcePaths;
+  constructor(templateName, sourcePaths) {
+    const sortedSourcePaths = [...sourcePaths].sort();
+    super(`Duplicate email template name "${templateName}" from: ${sortedSourcePaths.join(", ")}`);
+    this.name = "DuplicateEmailTemplateError";
+    this.templateName = templateName;
+    this.sourcePaths = sortedSourcePaths;
+  }
+}
+class EmailTemplateDiscoveryError extends Error {
+  sourcePath;
+  constructor(sourcePath, cause) {
+    super(`Failed to discover email templates under ${sourcePath}`, { cause });
+    this.name = "EmailTemplateDiscoveryError";
+    this.sourcePath = sourcePath;
+  }
+}
+
+function compareCodePoints(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function normalizeSeparators(value) {
+  return value.split(sep).join("/").replaceAll("\\", "/");
+}
+function templatesFromSourcePaths(emailDirectory, sourcePaths) {
+  const templates = sourcePaths.map((sourcePath) => {
+    const relativePath = normalizeSeparators(relative(emailDirectory, sourcePath));
+    if (relativePath.startsWith("../") || relativePath === ".." || isAbsolute(relativePath)) {
+      throw new EmailTemplateDiscoveryError(sourcePath, new TypeError("Template path is outside app/emails"));
+    }
+    return {
+      name: relativePath.slice(0, -".vue".length),
+      sourcePath: normalizeSeparators(sourcePath)
+    };
+  }).sort((left, right) => {
+    return compareCodePoints(left.name, right.name) || compareCodePoints(left.sourcePath, right.sourcePath);
+  });
+  const pathsByName = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const paths = pathsByName.get(template.name) ?? [];
+    paths.push(template.sourcePath);
+    pathsByName.set(template.name, paths);
+  }
+  const duplicate = [...pathsByName.entries()].filter(([, paths]) => paths.length > 1).sort(([left], [right]) => compareCodePoints(left, right))[0];
+  if (duplicate) {
+    throw new DuplicateEmailTemplateError(duplicate[0], duplicate[1]);
+  }
+  return templates;
+}
+async function discoverEmailTemplates(emailDirectory) {
+  let sourcePaths;
+  try {
+    sourcePaths = await resolveFiles(emailDirectory, "**/*.vue", {
+      followSymbolicLinks: false,
+      ignore: ["components/**"]
+    });
+  } catch (error) {
+    throw new EmailTemplateDiscoveryError(emailDirectory, error);
+  }
+  return templatesFromSourcePaths(emailDirectory, sourcePaths);
+}
+
+function importPath(path) {
+  return JSON.stringify(path.replaceAll("\\", "/"));
+}
+function generateEmailRegistry(templates, runtimePaths) {
+  const entries = templates.map((template) => {
+    const fixture = template.fixturePath ? `
+    fixture: () => import(${importPath(template.fixturePath)}),` : "";
+    return `  [${JSON.stringify(template.name)}]: {
+    component: () => import(${importPath(template.sourcePath)}),${fixture}
+  },`;
+  });
+  return `import { EmailRenderError } from ${importPath(runtimePaths.emailRenderError)}
+import { renderEmailComponent } from ${importPath(runtimePaths.renderEmailComponent)}
+import { UnknownEmailTemplateError } from ${importPath(runtimePaths.templateRegistryErrors)}
+
+export const emailTemplates = Object.freeze({
+${entries.join("\n")}
+})
+
+export async function renderEmail(name, props) {
+  const loader = typeof name === 'string' && Object.hasOwn(emailTemplates, name)
+    ? emailTemplates[name]
+    : undefined
+  if (!loader) {
+    throw new UnknownEmailTemplateError(String(name), Object.keys(emailTemplates))
+  }
+
+  try {
+    const templateModule = await loader.component()
+    return await renderEmailComponent(templateModule.default, props)
+  }
+  catch (error) {
+    throw new EmailRenderError(name, error instanceof EmailRenderError ? error.cause : error)
+  }
+}
+`;
+}
+function generateEmailTypes(templates, typePaths) {
+  const entries = templates.map((template) => {
+    const fixture = template.fixturePath ? `
+    fixture: () => Promise<typeof import(${importPath(template.fixturePath)})>` : "";
+    return `  ${JSON.stringify(template.name)}: {
+    component: () => Promise<typeof import(${importPath(template.sourcePath)})>${fixture}
+  }`;
+  });
+  return `export const emailTemplates: Readonly<{
+${entries.join("\n")}
+}>
+
+export type EmailTemplateName = keyof typeof emailTemplates
+type _EmailComponent = abstract new (...args: never[]) => { $props: object }
+type _DeclaredEmailProps<Component extends _EmailComponent> = Omit<
+  InstanceType<Component>['$props'],
+  keyof import('vue').PublicProps
+>
+type _EmailProps<Component extends _EmailComponent> = keyof _DeclaredEmailProps<Component> extends never
+  ? Record<string, never>
+  : _DeclaredEmailProps<Component>
+
+export type EmailTemplateProps = {
+  [Name in EmailTemplateName]: _EmailProps<Awaited<ReturnType<(typeof emailTemplates)[Name]['component']>>['default']>
+}
+
+export function renderEmail<Name extends EmailTemplateName>(
+  name: Name,
+  props: NoInfer<EmailTemplateProps[Name]>,
+): Promise<import(${importPath(typePaths.renderedEmail)}).RenderedEmail>
+`;
+}
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@lupinum/nuxt-email",
+    configKey: "nuxtEmail",
+    compatibility: {
+      nuxt: ">=4.5.1 <5"
+    }
+  },
+  async setup(options, nuxt) {
+    const optionNames = Object.keys(options).filter((name) => name !== "codeBlock").sort();
+    if (optionNames.length > 0) {
+      throw new TypeError(`nuxt-email received unsupported module options: ${optionNames.join(", ")}`);
+    }
+    const resolver = createResolver(import.meta.url);
+    const defineEmailPublicPath = await resolver.resolvePath("./runtime/define-email");
+    const errorsPublicPath = await resolver.resolvePath("./runtime/errors");
+    let renderEmailComponentPath = await resolver.resolvePath("./runtime/testing");
+    if (options.codeBlock !== void 0) {
+      const { setupCodeBlock } = await import('./chunks/setup.mjs');
+      renderEmailComponentPath = setupCodeBlock(options.codeBlock, resolver);
+    }
+    const emailDirectory = resolve(nuxt.options.srcDir, "emails");
+    const loadTemplates = async () => {
+      const discoveredTemplates = await discoverEmailTemplates(emailDirectory);
+      return nuxt.options.dev ? attachPreviewFixtures(discoveredTemplates) : discoveredTemplates;
+    };
+    let templates = await loadTemplates();
+    const registryRuntimePaths = {
+      emailRenderError: resolver.resolve("./runtime/render/errors"),
+      renderEmailComponent: renderEmailComponentPath,
+      templateRegistryErrors: resolver.resolve("./runtime/template-registry/errors")
+    };
+    const registryTypePaths = {
+      renderedEmail: resolver.resolve("./runtime/render/types")
+    };
+    const registryId = "#nuxt-email/registry";
+    addServerTemplate({
+      filename: registryId,
+      getContents: () => generateEmailRegistry(templates, registryRuntimePaths)
+    });
+    const typeTemplate = addTypeTemplate({
+      filename: "types/nuxt-email.d.ts",
+      write: true,
+      getContents: () => generateEmailTypes(templates, registryTypePaths)
+    }, { nitro: true });
+    addServerImports([
+      {
+        name: "renderEmail",
+        from: registryId
+      }
+    ]);
+    for (const name of EMAIL_COMPONENT_NAMES) {
+      addComponent({
+        name,
+        export: name,
+        filePath: resolver.resolve(`./runtime/components/${name}`),
+        mode: "server"
+      });
+    }
+    if (nuxt.options.dev) {
+      addServerHandler({
+        route: "/__email",
+        method: "get",
+        env: "dev",
+        handler: resolver.resolve("./runtime/dev-preview/page.get")
+      });
+      addServerHandler({
+        route: "/__email/api/templates",
+        method: "get",
+        env: "dev",
+        handler: resolver.resolve("./runtime/dev-preview/templates.get")
+      });
+      addServerHandler({
+        route: "/__email/render",
+        method: "get",
+        env: "dev",
+        handler: resolver.resolve("./runtime/dev-preview/render.get")
+      });
+    }
+    let reloadRegistry = async () => {
+    };
+    nuxt.hook("ready", () => {
+      const nitro2 = useNitro();
+      reloadRegistry = async () => {
+        await nitro2.hooks.callHook("rollup:reload");
+      };
+    });
+    let registryUpdates = Promise.resolve();
+    nuxt.hook("builder:watch", (event, path) => {
+      const structureChanged = ["add", "unlink", "addDir", "unlinkDir"].includes(event);
+      if (event !== "change" && !structureChanged) {
+        return;
+      }
+      const absolutePath = isAbsolute(path) ? path : resolve(nuxt.options.srcDir, path);
+      const relativePath = relative(emailDirectory, absolutePath).replaceAll("\\", "/");
+      if (relativePath === ".." || relativePath.startsWith("../") || isAbsolute(relativePath)) {
+        return;
+      }
+      const update = async () => {
+        if (structureChanged) {
+          templates = await loadTemplates();
+          await updateTemplates({
+            filter: (template) => template.filename === typeTemplate.filename
+          });
+        }
+        await reloadRegistry();
+      };
+      const queuedUpdate = registryUpdates.then(update, update);
+      registryUpdates = queuedUpdate.catch(() => {
+      });
+      return queuedUpdate;
+    });
+    const nuxtOptions = nuxt.options;
+    const nitro = nuxtOptions.nitro ??= {};
+    const alias = nitro.alias ??= {};
+    alias["#nuxt-email/testing"] = renderEmailComponentPath;
+    alias["@lupinum/nuxt-email/define-email"] = defineEmailPublicPath;
+    alias["@lupinum/nuxt-email/errors"] = errorsPublicPath;
+    const externals = nitro.externals ??= {};
+    const inline = externals.inline ??= [];
+    for (const publicRuntimePath of [defineEmailPublicPath, errorsPublicPath]) {
+      if (!inline.includes(publicRuntimePath)) {
+        inline.push(publicRuntimePath);
+      }
+    }
+    const typescript = nitro.typescript ??= {};
+    const tsConfig = typescript.tsConfig ??= {};
+    const compilerOptions = tsConfig.compilerOptions ??= {};
+    const paths = compilerOptions.paths ??= {};
+    paths[registryId] = [typeTemplate.dst];
+    paths["#nuxt-email/testing"] = [renderEmailComponentPath];
+    nitro.rollupConfig ??= {};
+    const existingPlugins = nitro.rollupConfig.plugins;
+    nitro.rollupConfig.plugins = existingPlugins ? [existingPlugins, vueRollup()] : [vueRollup()];
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/code-block/create-component.d.ts

@@ -0,0 +1,16 @@
+import type { TokensResult } from '@shikijs/core';
+import type { DefineComponent, HTMLAttributes } from 'vue';
+import type { SafeEmailAttributes } from '../components/attributes.js';
+export type ECodeBlockProps<Language extends string> = {
+    code: string;
+    language: Language;
+    lineNumbers?: boolean;
+    fontFamily?: string;
+} & SafeEmailAttributes<HTMLAttributes>;
+interface CodeBlockComponentOptions<Language extends string> {
+    enabledLanguages: readonly Language[];
+    theme: string;
+    highlight: (code: string, language: Language) => Promise<TokensResult>;
+}
+export declare function createCodeBlockComponent<const Language extends string>(options: CodeBlockComponentOptions<Language>): DefineComponent<ECodeBlockProps<Language>>;
+export {};

package/dist/runtime/code-block/create-component.js

@@ -0,0 +1,106 @@
+import { defineComponent, h } from "vue";
+import { assertSafeEmailAttributes } from "../components/attributes.js";
+import { mergeEmailStyles } from "../components/style.js";
+const FONT_STYLE_ITALIC = 1;
+const FONT_STYLE_BOLD = 2;
+const FONT_STYLE_UNDERLINE = 4;
+const FONT_STYLE_STRIKETHROUGH = 8;
+function tokenStyle(token) {
+  if (token.htmlStyle !== void 0) {
+    return { ...token.htmlStyle };
+  }
+  const style = {
+    color: token.color,
+    backgroundColor: token.bgColor
+  };
+  const fontStyle = token.fontStyle ?? 0;
+  if (fontStyle > 0) {
+    if ((fontStyle & FONT_STYLE_ITALIC) !== 0) {
+      style.fontStyle = "italic";
+    }
+    if ((fontStyle & FONT_STYLE_BOLD) !== 0) {
+      style.fontWeight = "bold";
+    }
+    const decorations = [];
+    if ((fontStyle & FONT_STYLE_UNDERLINE) !== 0) {
+      decorations.push("underline");
+    }
+    if ((fontStyle & FONT_STYLE_STRIKETHROUGH) !== 0) {
+      decorations.push("line-through");
+    }
+    if (decorations.length > 0) {
+      style.textDecoration = decorations.join(" ");
+    }
+  }
+  return style;
+}
+function renderTokens(tokens, lineNumbers) {
+  const children = [];
+  const lineNumberWidth = `${String(tokens.length).length + 1}ch`;
+  for (const [lineIndex, line] of tokens.entries()) {
+    if (lineNumbers) {
+      children.push(h("span", {
+        "aria-hidden": "true",
+        "data-skip-in-text": "true",
+        "style": {
+          display: "inline-block",
+          userSelect: "none",
+          width: lineNumberWidth
+        }
+      }, String(lineIndex + 1)));
+    }
+    for (const token of line) {
+      children.push(h("span", { style: tokenStyle(token) }, token.content));
+    }
+    if (lineIndex < tokens.length - 1) {
+      children.push("\n");
+    }
+  }
+  return children;
+}
+export function createCodeBlockComponent(options) {
+  const enabledLanguages = new Set(options.enabledLanguages);
+  return defineComponent({
+    name: "ECodeBlock",
+    inheritAttrs: false,
+    props: {
+      code: { type: String, required: true },
+      language: { type: String, required: true },
+      lineNumbers: { type: Boolean, default: false },
+      fontFamily: { type: String, default: "ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace" }
+    },
+    async setup(props, { attrs }) {
+      assertSafeEmailAttributes("ECodeBlock", attrs);
+      const language = props.language;
+      if (!enabledLanguages.has(language)) {
+        throw new TypeError(
+          `ECodeBlock language ${JSON.stringify(language)} is not enabled. Enabled languages: ${options.enabledLanguages.join(", ")}`
+        );
+      }
+      const highlighted = await options.highlight(props.code, language);
+      return () => {
+        const { class: className, style, ...attributes } = attrs;
+        const preStyle = {
+          backgroundColor: highlighted.bg,
+          color: highlighted.fg,
+          fontFamily: props.fontFamily,
+          margin: 0,
+          overflowWrap: "break-word",
+          whiteSpace: "pre-wrap"
+        };
+        return h("pre", {
+          ...attributes,
+          "class": className,
+          "data-code-theme": options.theme,
+          "style": mergeEmailStyles(preStyle, style),
+          "tabindex": attributes.tabindex ?? 0
+        }, [
+          h("code", { style: { fontFamily: props.fontFamily } }, renderTokens(
+            highlighted.tokens,
+            props.lineNumbers === true
+          ))
+        ]);
+      };
+    }
+  });
+}

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

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

package/dist/runtime/components/EBody.js

@@ -0,0 +1,75 @@
+import { defineComponent, h, inject } from "vue";
+import { resolveNestedTailwindStyle, TAILWIND_NESTED_KEY } from "../tailwind/nested.js";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { normalizeEmailStyle } from "./style.js";
+const RESET_PROPERTIES = [
+  "margin",
+  "marginTop",
+  "marginBottom",
+  "marginRight",
+  "marginLeft",
+  "marginInline",
+  "marginBlock",
+  "marginBlockStart",
+  "marginBlockEnd",
+  "marginInlineStart",
+  "marginInlineEnd",
+  "padding",
+  "paddingTop",
+  "paddingBottom",
+  "paddingRight",
+  "paddingLeft",
+  "paddingInline",
+  "paddingBlock",
+  "paddingBlockStart",
+  "paddingBlockEnd",
+  "paddingInlineStart",
+  "paddingInlineEnd"
+];
+export const EBody = defineComponent({
+  name: "EBody",
+  inheritAttrs: false,
+  setup(_props, { attrs, slots }) {
+    const holder = inject(TAILWIND_NESTED_KEY, null);
+    return () => {
+      assertSafeEmailAttributes("EBody", attrs);
+      const { style, ...bodyAttributes } = attrs;
+      const effectiveStyle = resolveNestedTailwindStyle(holder, bodyAttributes, style).style;
+      const normalizedStyle = normalizeEmailStyle(effectiveStyle);
+      const hasUserStyle = normalizedStyle !== void 0 && Object.keys(normalizedStyle).length > 0;
+      const dir = attrs.dir ?? "ltr";
+      const lang = attrs.lang ?? "en";
+      const bodyStyle = {};
+      if (hasUserStyle) {
+        bodyStyle.background = normalizedStyle.background;
+        bodyStyle.backgroundColor = normalizedStyle.backgroundColor;
+        for (const property of RESET_PROPERTIES) {
+          if (normalizedStyle[property] !== void 0) {
+            bodyStyle[property] = 0;
+          }
+        }
+      }
+      return h("body", {
+        ...bodyAttributes,
+        dir,
+        lang,
+        ...Object.values(bodyStyle).some((value) => value !== void 0) ? { style: bodyStyle } : {}
+      }, [
+        h("table", {
+          border: 0,
+          width: "100%",
+          cellpadding: "0",
+          cellspacing: "0",
+          role: "presentation",
+          align: "center"
+        }, [
+          h("tbody", [
+            h("tr", [
+              h("td", { dir, lang, ...hasUserStyle ? { style: effectiveStyle } : {} }, slots.default?.())
+            ])
+          ])
+        ])
+      ]);
+    };
+  }
+});

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

@@ -0,0 +1,11 @@
+import type { AnchorHTMLAttributes, DefineComponent } from 'vue';
+import type { SafeEmailAttributes } from './attributes.js';
+export type EButtonProps = Omit<SafeEmailAttributes<AnchorHTMLAttributes>, 'href'> & {
+    href: string;
+};
+/**
+ * Outlook spacing behavior adapted from React Email's MIT-licensed Button.
+ * Copyright 2024 Plus Five Five, Inc; pinned source commit 6eb428924c4c2774228a07cbec1977ad8898f143.
+ */
+export declare function computeMsoFontWidthAndSpaceCount(expectedWidth: number): readonly [number, number];
+export declare const EButton: DefineComponent<EButtonProps>;

package/dist/runtime/components/EButton.js

@@ -0,0 +1,89 @@
+import { createCommentVNode, defineComponent, h, inject } from "vue";
+import { resolveNestedTailwindStyle, TAILWIND_NESTED_KEY } from "../tailwind/nested.js";
+import { assertSafeEmailAttributes } from "./attributes.js";
+import { parseButtonPadding, pixelsToPoints, pixelStyle } from "./EButton.padding.js";
+import { normalizeEmailStyle } from "./style.js";
+const MAX_MSO_FONT_WIDTH = 5;
+const MAX_MSO_SPACE_COUNT = 1e3;
+export function computeMsoFontWidthAndSpaceCount(expectedWidth) {
+  if (!Number.isFinite(expectedWidth)) {
+    throw new TypeError(`EButton padding must resolve to finite pixels; received ${String(expectedWidth)}`);
+  }
+  if (expectedWidth === 0) {
+    return [0, 0];
+  }
+  if (expectedWidth < 0) {
+    throw new TypeError(`EButton padding must be a finite non-negative value; received ${String(expectedWidth)}`);
+  }
+  const spaceCount = Math.max(1, Math.ceil(expectedWidth / (MAX_MSO_FONT_WIDTH * 2)));
+  if (spaceCount > MAX_MSO_SPACE_COUNT) {
+    throw new TypeError(
+      `EButton horizontal padding requires ${spaceCount} Outlook spacer characters; maximum is ${MAX_MSO_SPACE_COUNT}`
+    );
+  }
+  return [expectedWidth / spaceCount / 2, spaceCount];
+}
+export const EButton = defineComponent({
+  name: "EButton",
+  inheritAttrs: false,
+  props: {
+    href: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props, { attrs, slots }) {
+    const holder = inject(TAILWIND_NESTED_KEY, null);
+    return () => {
+      assertSafeEmailAttributes("EButton", attrs);
+      if (typeof props.href !== "string" || props.href.length === 0) {
+        throw new TypeError("EButton href must be a non-empty string");
+      }
+      const { style, target: requestedTarget, ...attributes } = attrs;
+      const effectiveStyle = resolveNestedTailwindStyle(holder, attributes, style).style;
+      const normalizedStyle = normalizeEmailStyle(effectiveStyle) ?? {};
+      const { paddingTop, paddingRight, paddingBottom, paddingLeft } = parseButtonPadding(normalizedStyle);
+      const textRaise = pixelsToPoints((paddingTop ?? 0) + (paddingBottom ?? 0));
+      const [leftFontWidth, leftSpaceCount] = computeMsoFontWidthAndSpaceCount(paddingLeft ?? 0);
+      const [rightFontWidth, rightSpaceCount] = computeMsoFontWidthAndSpaceCount(paddingRight ?? 0);
+      const target = requestedTarget ?? "_blank";
+      return h("a", {
+        ...attributes,
+        href: props.href,
+        style: {
+          lineHeight: "100%",
+          textDecoration: "none",
+          display: "inline-block",
+          maxWidth: "100%",
+          msoPaddingAlt: "0px",
+          ...normalizedStyle,
+          paddingTop: pixelStyle(paddingTop),
+          paddingRight: pixelStyle(paddingRight),
+          paddingBottom: pixelStyle(paddingBottom),
+          paddingLeft: pixelStyle(paddingLeft)
+        },
+        target
+      }, [
+        h("span", [
+          createCommentVNode(
+            `[if mso]><i style="mso-font-width:${leftFontWidth * 100}%;mso-text-raise:${textRaise}px" hidden>${"&#8202;".repeat(leftSpaceCount)}</i><![endif]`
+          )
+        ]),
+        h("span", {
+          style: {
+            maxWidth: "100%",
+            display: "inline-block",
+            lineHeight: "120%",
+            msoPaddingAlt: "0px",
+            msoTextRaise: pixelStyle(pixelsToPoints(paddingBottom))
+          }
+        }, slots.default?.()),
+        h("span", [
+          createCommentVNode(
+            `[if mso]><i style="mso-font-width:${rightFontWidth * 100}%" hidden>${"&#8202;".repeat(rightSpaceCount)}&#8203;</i><![endif]`
+          )
+        ])
+      ]);
+    };
+  }
+});

package/dist/runtime/components/EButton.padding.d.ts

@@ -0,0 +1,12 @@
+type PaddingValue = unknown;
+export interface ParsedPadding {
+    paddingTop: number | undefined;
+    paddingRight: number | undefined;
+    paddingBottom: number | undefined;
+    paddingLeft: number | undefined;
+}
+export declare function convertToPixels(value: PaddingValue): number;
+export declare function parseButtonPadding(style: unknown): ParsedPadding;
+export declare function pixelsToPoints(pixels: number | undefined): number | undefined;
+export declare function pixelStyle(value: number | undefined): string | number | undefined;
+export {};