@lupinum/nuxt-email 0.1.0

package/dist/runtime/dev-preview/render.get.d.ts

@@ -0,0 +1,3 @@
+export declare const PREVIEW_RENDER_CSP: string;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/dev-preview/render.get.js

@@ -0,0 +1,123 @@
+import { emailTemplates, renderEmail } from "#nuxt-email/registry";
+import {
+  defineEventHandler,
+  getQuery,
+  setHeaders,
+  setResponseStatus
+} from "h3";
+export const PREVIEW_RENDER_CSP = [
+  "default-src 'none'",
+  "script-src 'none'",
+  "style-src 'unsafe-inline'",
+  "img-src data: https: http:",
+  "font-src data: https: http:",
+  "frame-ancestors 'self'",
+  "base-uri 'none'",
+  "object-src 'none'",
+  "form-action 'none'"
+].join("; ");
+class PreviewRequestError extends Error {
+  statusCode;
+  constructor(statusCode, message) {
+    super(message);
+    this.name = "PreviewRequestError";
+    this.statusCode = statusCode;
+  }
+}
+function serializeError(error, seen = /* @__PURE__ */ new Set()) {
+  if (!(error instanceof Error)) {
+    return {
+      name: typeof error,
+      message: String(error)
+    };
+  }
+  if (seen.has(error)) {
+    return {
+      name: error.name,
+      message: "[circular error cause]"
+    };
+  }
+  seen.add(error);
+  const serialized = {
+    name: error.name,
+    message: error.message
+  };
+  if (error.stack) {
+    serialized.stack = error.stack;
+  }
+  if ("componentName" in error && typeof error.componentName === "string") {
+    serialized.componentName = error.componentName;
+  }
+  if ("requestedName" in error && typeof error.requestedName === "string") {
+    serialized.requestedName = error.requestedName;
+  }
+  if ("knownNames" in error && Array.isArray(error.knownNames)) {
+    serialized.knownNames = error.knownNames.filter((name) => typeof name === "string");
+  }
+  if ("cause" in error && error.cause !== void 0) {
+    serialized.cause = serializeError(error.cause, seen);
+  }
+  return serialized;
+}
+function requiredString(value, parameter) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new PreviewRequestError(400, `Query parameter "${parameter}" must be one non-empty string`);
+  }
+  return value;
+}
+function fixtureProps(value, name) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`Preview fixture ${name}.fixtures.ts must default-export a props object`);
+  }
+  return value;
+}
+export default defineEventHandler(async (event) => {
+  setHeaders(event, {
+    "cache-control": "no-store",
+    "referrer-policy": "no-referrer",
+    "x-content-type-options": "nosniff"
+  });
+  const query = getQuery(event);
+  const requestedName = typeof query.name === "string" ? query.name : void 0;
+  try {
+    const name = requiredString(query.name, "name");
+    const format = query.format === void 0 ? "html" : requiredString(query.format, "format");
+    if (format !== "html" && format !== "json") {
+      throw new PreviewRequestError(400, 'Query parameter "format" must be "html" or "json"');
+    }
+    const template = Object.hasOwn(emailTemplates, name) ? emailTemplates[name] : void 0;
+    if (template === void 0) {
+      throw new PreviewRequestError(
+        404,
+        `Unknown email template "${name}"; known templates: ${Object.keys(emailTemplates).join(", ")}`
+      );
+    }
+    if (!template.fixture) {
+      throw new PreviewRequestError(404, `Email template "${name}" has no colocated ${name}.fixtures.ts file`);
+    }
+    const fixtureModule = await template.fixture();
+    const output = await renderEmail(name, fixtureProps(fixtureModule.default, name));
+    if (format === "json") {
+      setHeaders(event, { "content-type": "application/json; charset=utf-8" });
+      return { name, ...output, bytes: Buffer.byteLength(output.html, "utf8") };
+    }
+    setHeaders(event, {
+      "content-security-policy": PREVIEW_RENDER_CSP,
+      "content-type": "text/html; charset=utf-8"
+    });
+    return output.html;
+  } catch (error) {
+    const statusCode = error instanceof PreviewRequestError ? error.statusCode : 500;
+    const serializedError = serializeError(error);
+    setResponseStatus(event, statusCode);
+    setHeaders(event, { "content-type": "application/json; charset=utf-8" });
+    return {
+      statusCode,
+      statusMessage: serializedError.message,
+      data: {
+        templateName: requestedName,
+        error: serializedError
+      }
+    };
+  }
+});

package/dist/runtime/dev-preview/templates.get.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, {
+    templates: {
+        name: string;
+        hasFixture: boolean;
+    }[];
+}>;
+export default _default;

package/dist/runtime/dev-preview/templates.get.js

@@ -0,0 +1,14 @@
+import { emailTemplates } from "#nuxt-email/registry";
+import { defineEventHandler, setHeaders } from "h3";
+export default defineEventHandler((event) => {
+  setHeaders(event, {
+    "cache-control": "no-store",
+    "content-type": "application/json; charset=utf-8"
+  });
+  return {
+    templates: Object.entries(emailTemplates).map(([name, template]) => ({
+      name,
+      hasFixture: template.fixture !== void 0
+    })).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)
+  };
+});

package/dist/runtime/errors.d.ts

@@ -0,0 +1,4 @@
+export { DefineEmailOutsideRenderError, DuplicateEmailDefinitionError, } from './render/define-email.js';
+export { EmailRenderError } from './render/errors.js';
+export { UnknownEmailTemplateError } from './template-registry/errors.js';
+export { TailwindMissingHeadError } from './tailwind/errors.js';

package/dist/runtime/errors.js

@@ -0,0 +1,7 @@
+export {
+  DefineEmailOutsideRenderError,
+  DuplicateEmailDefinitionError
+} from "./render/define-email.js";
+export { EmailRenderError } from "./render/errors.js";
+export { UnknownEmailTemplateError } from "./template-registry/errors.js";
+export { TailwindMissingHeadError } from "./tailwind/errors.js";

package/dist/runtime/render/define-email.d.ts

@@ -0,0 +1,56 @@
+import type { TailwindRegion } from '../tailwind/nested.js';
+/**
+ * Options declared by an email template via {@link defineEmail}.
+ *
+ * `subject` is a zero-argument closure over the template's real `defineProps()`
+ * value and returns the computed subject line.
+ */
+export interface DefineEmailOptions {
+    subject: () => string;
+}
+declare const EMAIL_RENDER_BRAND: unique symbol;
+/**
+ * Per-render registry created by the renderer. A fresh instance is created for
+ * every render, so concurrent renders never share mutable state. `defineEmail`
+ * reaches it through the async-local render scope.
+ */
+export interface EmailRenderContext {
+    readonly [EMAIL_RENDER_BRAND]: true;
+    subject?: () => string;
+    /**
+     * Tailwind regions registered by `<ETailwind>` boundaries during render, in
+     * registration order. Consumed by the post-render pass to complete each head
+     * `<style>` and inline nested plain elements. Absent when no boundary rendered.
+     */
+    tailwindRegions?: TailwindRegion[];
+}
+export declare class DefineEmailOutsideRenderError extends Error {
+    constructor();
+}
+export declare class DuplicateEmailDefinitionError extends Error {
+    constructor();
+}
+export declare function createEmailRenderContext(): EmailRenderContext;
+/**
+ * The active email render context, or `undefined` outside a render. Used by
+ * `<ETailwind>` to register its region on the same context `renderComponentToHtml`
+ * reads back after render.
+ */
+export declare function getEmailRenderContext(): EmailRenderContext | undefined;
+/**
+ * Run `fn` (the render) with `context` as the active email render context so any
+ * `defineEmail()` call inside the rendered template — sync or after an await —
+ * resolves to it.
+ */
+export declare function runWithEmailRenderContext<T>(context: EmailRenderContext, fn: () => T): T;
+/**
+ * Declare email metadata (currently the subject) from an email template's
+ * `<script setup>`. The zero-argument subject closure captures the template's
+ * real `defineProps()` value, so there is no separate generic that can lie about
+ * the template contract. The computed value surfaces as `subject`.
+ *
+ * Must run during an email render; calling it elsewhere throws
+ * {@link DefineEmailOutsideRenderError}.
+ */
+export declare function defineEmail(options: DefineEmailOptions): void;
+export {};

package/dist/runtime/render/define-email.js

@@ -0,0 +1,40 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const EMAIL_RENDER_BRAND = /* @__PURE__ */ Symbol("nuxt-email:render-context");
+const renderContextStorage = new AsyncLocalStorage();
+export class DefineEmailOutsideRenderError extends Error {
+  constructor() {
+    super("defineEmail() must be called during an email render, from an email template rendered by renderEmail().");
+    this.name = "DefineEmailOutsideRenderError";
+  }
+}
+export class DuplicateEmailDefinitionError extends Error {
+  constructor() {
+    super("defineEmail() may only be called once during one email render.");
+    this.name = "DuplicateEmailDefinitionError";
+  }
+}
+export function createEmailRenderContext() {
+  return { [EMAIL_RENDER_BRAND]: true };
+}
+export function getEmailRenderContext() {
+  return renderContextStorage.getStore();
+}
+export function runWithEmailRenderContext(context, fn) {
+  return renderContextStorage.run(context, fn);
+}
+function isEmailRenderContext(value) {
+  return typeof value === "object" && value !== null && value[EMAIL_RENDER_BRAND] === true;
+}
+export function defineEmail(options) {
+  const context = renderContextStorage.getStore();
+  if (!isEmailRenderContext(context)) {
+    throw new DefineEmailOutsideRenderError();
+  }
+  if (context.subject !== void 0) {
+    throw new DuplicateEmailDefinitionError();
+  }
+  if (!options || typeof options.subject !== "function") {
+    throw new TypeError("defineEmail() subject must be a function returning a string.");
+  }
+  context.subject = options.subject;
+}

package/dist/runtime/render/document.d.ts

@@ -0,0 +1,4 @@
+export declare const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
+export declare function assembleEmailDocument(renderedHtml: string): string;
+export declare function assertNoUnresolvedEmailComponents(renderedHtml: string): void;
+export declare function assertCompleteEmailDocument(html: string): void;

package/dist/runtime/render/document.js

@@ -0,0 +1,75 @@
+import { Parser } from "htmlparser2";
+export const EMAIL_DOCTYPE = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">';
+const LEADING_DOCTYPE = /^\s*<!doctype[^>]*>/i;
+const EMAIL_COMPONENT_TAG = /^E[A-Za-z0-9]+$/;
+export function assembleEmailDocument(renderedHtml) {
+  return `${EMAIL_DOCTYPE}${renderedHtml.replace(LEADING_DOCTYPE, "")}`;
+}
+export function assertNoUnresolvedEmailComponents(renderedHtml) {
+  let unresolvedComponent;
+  const parser = new Parser({
+    onopentag(name) {
+      if (unresolvedComponent === void 0 && EMAIL_COMPONENT_TAG.test(name)) {
+        unresolvedComponent = name;
+      }
+    }
+  }, { xmlMode: true });
+  parser.end(renderedHtml);
+  if (unresolvedComponent !== void 0) {
+    throw new TypeError(
+      `Unknown email component <${unresolvedComponent}>. Configure it or use a registered E* component.`
+    );
+  }
+}
+export function assertCompleteEmailDocument(html) {
+  const document = html.startsWith(EMAIL_DOCTYPE) ? html.slice(EMAIL_DOCTYPE.length) : html;
+  const stack = [];
+  let bodyCount = 0;
+  let bodyClosed = false;
+  let headCount = 0;
+  let htmlCount = 0;
+  let htmlClosed = false;
+  let invalid = false;
+  const parser = new Parser({
+    onopentag(name) {
+      const parent = stack.at(-1);
+      if (name === "html") {
+        htmlCount++;
+        if (stack.length > 0 || htmlClosed) invalid = true;
+      } else if (name === "head") {
+        headCount++;
+        if (parent !== "html" || bodyCount > 0) invalid = true;
+      } else if (name === "body") {
+        bodyCount++;
+        if (parent !== "html" || bodyClosed) invalid = true;
+      } else if (!stack.includes("head") && !stack.includes("body")) {
+        invalid = true;
+      }
+      stack.push(name);
+    },
+    ontext(value) {
+      if (value.trim() !== "" && !stack.includes("head") && !stack.includes("body")) {
+        invalid = true;
+      }
+    },
+    onclosetag(name, isImplied) {
+      const index = stack.lastIndexOf(name);
+      if (index === -1) {
+        invalid = true;
+        return;
+      }
+      if ((name === "html" || name === "head" || name === "body") && isImplied) {
+        invalid = true;
+      }
+      stack.splice(index);
+      if (name === "body") bodyClosed = true;
+      if (name === "html") htmlClosed = true;
+    }
+  });
+  parser.end(document);
+  if (invalid || stack.length > 0 || htmlCount !== 1 || !htmlClosed || headCount > 1 || bodyCount !== 1 || !bodyClosed) {
+    throw new TypeError(
+      "Email templates must render exactly one <html> root containing exactly one <body>; wrap the template in EHtml and EBody"
+    );
+  }
+}

package/dist/runtime/render/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class EmailRenderError extends Error {
+    readonly componentName: string;
+    constructor(componentName: string, cause: unknown);
+}

package/dist/runtime/render/errors.js

@@ -0,0 +1,8 @@
+export class EmailRenderError extends Error {
+  componentName;
+  constructor(componentName, cause) {
+    super(`Failed to render email component ${componentName}`, { cause });
+    this.name = "EmailRenderError";
+    this.componentName = componentName;
+  }
+}

package/dist/runtime/render/plain-text.d.ts

@@ -0,0 +1 @@
+export declare function renderPlainText(html: string): string;

package/dist/runtime/render/plain-text.js

@@ -0,0 +1,15 @@
+import { convert } from "html-to-text";
+export function renderPlainText(html) {
+  return convert(html, {
+    wordwrap: false,
+    selectors: [
+      { selector: "img", format: "skip" },
+      { selector: "[data-skip-in-text=true]", format: "skip" },
+      {
+        selector: "a",
+        options: { linkBrackets: false, hideLinkHrefIfSameAsText: true }
+      },
+      { selector: '[data-text-format="dataTable"]', format: "dataTable" }
+    ]
+  });
+}

package/dist/runtime/render/render-component.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from 'vue';
+import type { EmailRenderContext } from './define-email.js';
+export type EmailComponentRegistry = Readonly<Record<string, Component>>;
+export declare function renderComponentToHtml(component: Component, props?: Record<string, unknown>, context?: EmailRenderContext, componentRegistry?: EmailComponentRegistry): Promise<string>;

package/dist/runtime/render/render-component.js

@@ -0,0 +1,46 @@
+import { createSSRApp } from "vue";
+import { renderToString } from "vue/server-renderer";
+import { emailComponentRegistry } from "../components/email-component-registry.js";
+import { applyTailwindPostRender } from "../tailwind/post-render.js";
+import { createEmailRenderContext, runWithEmailRenderContext } from "./define-email.js";
+import { assembleEmailDocument, assertNoUnresolvedEmailComponents } from "./document.js";
+function assertKnownProps(component, props) {
+  const declaration = component.props;
+  if (typeof component === "function" && declaration === void 0) {
+    return;
+  }
+  const knownProps = new Set(Array.isArray(declaration) ? declaration : Object.keys(declaration ?? {}));
+  const unknownProps = Object.keys(props).filter((name) => !knownProps.has(name)).sort();
+  if (unknownProps.length > 0) {
+    throw new TypeError(`Unknown email component prop${unknownProps.length === 1 ? "" : "s"}: ${unknownProps.join(", ")}`);
+  }
+  if (Array.isArray(declaration) || declaration === void 0) {
+    return;
+  }
+  const missingProps = Object.entries(declaration).filter(([name, option]) => {
+    return typeof option === "object" && option !== null && "required" in option && option.required === true && !Object.hasOwn(props, name);
+  }).map(([name]) => name).sort();
+  if (missingProps.length > 0) {
+    throw new TypeError(`Missing required email component prop${missingProps.length === 1 ? "" : "s"}: ${missingProps.join(", ")}`);
+  }
+}
+export async function renderComponentToHtml(component, props = {}, context = createEmailRenderContext(), componentRegistry = emailComponentRegistry) {
+  assertKnownProps(component, props);
+  const app = createSSRApp(component, props);
+  for (const [name, emailComponent] of Object.entries(componentRegistry)) {
+    app.component(name, emailComponent);
+  }
+  let renderFailure;
+  app.config.errorHandler = (error) => {
+    renderFailure ??= { cause: error };
+  };
+  const renderedHtml = await runWithEmailRenderContext(context, () => renderToString(app, context));
+  if (renderFailure !== void 0) {
+    throw renderFailure.cause;
+  }
+  assertNoUnresolvedEmailComponents(renderedHtml);
+  const document = assembleEmailDocument(
+    renderedHtml.replaceAll("<!--[-->", "").replaceAll("<!--]-->", "").replaceAll("<!---->", "")
+  );
+  return applyTailwindPostRender(document, context.tailwindRegions);
+}

package/dist/runtime/render/render-email-component.d.ts

@@ -0,0 +1,16 @@
+import type { Component, FunctionalComponent, PublicProps } from 'vue';
+import type { EmailComponentRegistry } from './render-component.js';
+import type { RenderedEmail } from './types.js';
+type DeclaredComponentProps<ComponentType extends Component> = ComponentType extends abstract new (...args: infer _Arguments) => infer Instance ? Instance extends {
+    $props: infer Props;
+} ? Omit<Props, keyof PublicProps> : Record<string, unknown> : ComponentType extends FunctionalComponent<infer Props> ? Props : Record<string, unknown>;
+type RequiredPropKeys<Props> = {
+    [Key in keyof Props]-?: Record<never, never> extends Pick<Props, Key> ? never : Key;
+}[keyof Props];
+type RenderEmailComponentArguments<ComponentType extends Component> = keyof DeclaredComponentProps<ComponentType> extends never ? [props?: Record<string, never>] : RequiredPropKeys<DeclaredComponentProps<ComponentType>> extends never ? [props?: DeclaredComponentProps<ComponentType>] : [props: DeclaredComponentProps<ComponentType>];
+export interface RenderEmailComponent {
+    <ComponentType extends Component>(component: ComponentType, ...args: RenderEmailComponentArguments<ComponentType>): Promise<RenderedEmail>;
+}
+export declare function createRenderEmailComponent(componentRegistry: EmailComponentRegistry): RenderEmailComponent;
+export declare const renderEmailComponent: RenderEmailComponent;
+export {};

package/dist/runtime/render/render-email-component.js

@@ -0,0 +1,46 @@
+import { emailComponentRegistry } from "../components/email-component-registry.js";
+import { createEmailRenderContext } from "./define-email.js";
+import { assertCompleteEmailDocument } from "./document.js";
+import { EmailRenderError } from "./errors.js";
+import { renderPlainText } from "./plain-text.js";
+import { renderComponentToHtml } from "./render-component.js";
+function componentName(component) {
+  if (typeof component === "object" && component !== null || typeof component === "function") {
+    if ("name" in component && typeof component.name === "string" && component.name.length > 0) {
+      return component.name;
+    }
+    if ("__name" in component && typeof component.__name === "string" && component.__name.length > 0) {
+      return component.__name;
+    }
+  }
+  return "AnonymousEmail";
+}
+export function createRenderEmailComponent(componentRegistry) {
+  return async (component, ...args) => {
+    const props = args[0] ?? {};
+    try {
+      const context = createEmailRenderContext();
+      const html = await renderComponentToHtml(component, props, context, componentRegistry);
+      assertCompleteEmailDocument(html);
+      const subjectFactory = context.subject;
+      if (subjectFactory === void 0) {
+        return {
+          html,
+          text: renderPlainText(html)
+        };
+      }
+      const subject = subjectFactory();
+      if (typeof subject !== "string") {
+        throw new TypeError(`defineEmail() subject must return a string; received ${typeof subject}`);
+      }
+      return {
+        html,
+        text: renderPlainText(html),
+        subject
+      };
+    } catch (error) {
+      throw new EmailRenderError(componentName(component), error);
+    }
+  };
+}
+export const renderEmailComponent = createRenderEmailComponent(emailComponentRegistry);

package/dist/runtime/render/types.d.ts

@@ -0,0 +1,9 @@
+export interface RenderedEmail {
+    html: string;
+    text: string;
+    /**
+     * Subject line declared by the template via `defineEmail`. Absent when the
+     * template does not call `defineEmail`.
+     */
+    subject?: string;
+}

package/dist/runtime/tailwind/engine/compatibility/escape-class-name.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Escapes all characters that may not be accepted on
+ * CSS selectors by using the regex "[^a-zA-Z0-9\-_]".
+ *
+ * Also does a bit more trickery to avoid escaping already
+ * escaped characters.
+ */
+export declare function escapeClassName(className: string): string;

package/dist/runtime/tailwind/engine/compatibility/escape-class-name.js

@@ -0,0 +1,10 @@
+export function escapeClassName(className) {
+  return className.replace(
+    /*      we need this look ahead capturing group to avoid using negative look behinds */
+    /([^\\]|^)(?=([^\w-]))/g,
+    (match, prefixCharacter, characterToEscape) => {
+      if (prefixCharacter === "" && characterToEscape === "\\") return match;
+      return `${prefixCharacter}\\`;
+    }
+  );
+}

package/dist/runtime/tailwind/engine/compatibility/sanitize-class-name.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Replaces special characters to avoid problems on email clients.
+ *
+ * @param className - This should not come with any escaped characters, it should come the same
+ * as is on the `class` attribute of the element.
+ */
+export declare function sanitizeClassName(className: string): string;

package/dist/runtime/tailwind/engine/compatibility/sanitize-class-name.js

@@ -0,0 +1,17 @@
+const digitToNameMap = {
+  0: "zero",
+  1: "one",
+  2: "two",
+  3: "three",
+  4: "four",
+  5: "five",
+  6: "six",
+  7: "seven",
+  8: "eight",
+  9: "nine"
+};
+export function sanitizeClassName(className) {
+  return className.replaceAll("+", "plus").replaceAll("[", "").replaceAll("%", "pc").replaceAll("]", "").replaceAll("(", "").replaceAll(")", "").replaceAll("!", "imprtnt").replaceAll(">", "gt").replaceAll("<", "lt").replaceAll("=", "eq").replace(/^\d/, (digit) => {
+    return digitToNameMap[digit];
+  }).replace(/[^\w-]/g, "_");
+}

package/dist/runtime/tailwind/engine/compatibility/unescape-class.d.ts

@@ -0,0 +1 @@
+export declare function unescapeClass(singleClass: string): string;

package/dist/runtime/tailwind/engine/compatibility/unescape-class.js

@@ -0,0 +1,3 @@
+export function unescapeClass(singleClass) {
+  return singleClass.replaceAll(/\\\d|\\/g, "");
+}

package/dist/runtime/tailwind/engine/css/downlevel-for-email-clients.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Downlevels modern CSS features that email clients don't support,
+ * operating on a css-tree StyleSheet AST.
+ *
+ * 1. CSS Nesting: unnests @media rules from inside selectors
+ *    `.sm_p-4{@media (min-width:40rem){padding:1rem!important}}`
+ *    → `@media (min-width:40rem){.sm_p-4{padding:1rem!important}}`
+ *
+ * 2. Media Queries Level 4 range syntax → legacy min-width/max-width
+ *    `(width>=40rem)` → `(min-width:40rem)`
+ *
+ * Gmail, Outlook, Yahoo, and most email clients don't support either feature.
+ * See: https://www.caniemail.com/features/css-at-media/
+ *      https://www.caniemail.com/features/css-nesting/
+ */
+import { type StyleSheet } from 'css-tree';
+/**
+ * css-tree 3.x introduced new AST node types for query-related at-rules that
+ * `@types/css-tree` (still on 2.x at the time of writing) doesn't expose.
+ * Augmenting the module here lets the rest of this file work with strong
+ * types instead of scattering `as` casts everywhere.
+ *
+ * - `FeatureRange` is what the parser emits for Media Queries Level 4 range
+ *   syntax: `(width >= 40rem)`.
+ * - `Feature` is the legacy form (`(min-width: 40rem)`) we construct as the
+ *   downleveled output.
+ *
+ * Note: we cannot extend the `CssNode` union itself (it's a `type` alias, not
+ * an interface), so two narrow casts remain in this file:
+ *   1. Widening `node` inside `walk()` so we can narrow against
+ *      `FeatureRange.type` (`CssNode` doesn't list `'FeatureRange'`).
+ *   2. Assigning a constructed `Feature` back to `ListItem<CssNode>.data`.
+ *
+ * Both are flagged inline and reference back to this block.
+ *
+ * See:
+ *   https://github.com/csstree/csstree/blob/master/lib/syntax/node/FeatureRange.js
+ *   https://github.com/csstree/csstree/blob/master/lib/syntax/node/Feature.js
+ */
+declare module 'css-tree' {
+    interface FeatureRange extends CssNodeCommon {
+        type: 'FeatureRange';
+        kind: string;
+        left: CssNode;
+        leftComparison: string;
+        middle: CssNode;
+        rightComparison: string | null;
+        right: CssNode | null;
+    }
+    interface Feature extends CssNodeCommon {
+        type: 'Feature';
+        kind: string;
+        name: string;
+        value: CssNode | null;
+    }
+}
+/**
+ * Unnest @media at-rules from inside regular rules, and downlevel
+ * range media query syntax to legacy min-width/max-width.
+ *
+ * Mutates the stylesheet in place.
+ */
+export declare function downlevelForEmailClients(styleSheet: StyleSheet): void;