@react-email/render 0.0.17-canary.1 → 0.0.18-canary.0

package/dist/index.mjs

@@ -0,0 +1,853 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/render.ts
+import { ConcurrentRoot } from "react-reconciler/constants";
+import { convert } from "html-to-text";
+
+// src/renderer/index.ts
+import createReconciler from "react-reconciler";
+import { DefaultEventPriority } from "react-reconciler/constants.js";
+
+// src/renderer/dom-property.ts
+var RESERVED = 0;
+var STRING = 1;
+var BOOLEANISH_STRING = 2;
+var BOOLEAN = 3;
+var OVERLOADED_BOOLEAN = 4;
+var NUMERIC = 5;
+var POSITIVE_NUMERIC = 6;
+var ATTRIBUTE_NAME_START_CHAR = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
+var ATTRIBUTE_NAME_CHAR = `${ATTRIBUTE_NAME_START_CHAR}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040`;
+var VALID_ATTRIBUTE_NAME_REGEX = new RegExp(
+  `^[${ATTRIBUTE_NAME_START_CHAR}][${ATTRIBUTE_NAME_CHAR}]*$`
+);
+function shouldIgnoreAttribute(name, propertyInfo) {
+  if (propertyInfo !== null) {
+    return propertyInfo.type === RESERVED;
+  }
+  if (name.length > 2 && (name.startsWith("o") || name.startsWith("O")) && (name[1] === "n" || name[1] === "N")) {
+    return true;
+  }
+  return false;
+}
+function getPropertyInfo(name) {
+  return Object.hasOwn(properties, name) ? properties[name] : null;
+}
+var PropertyInfoRecord = class {
+  constructor(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL, removeEmptyString) {
+    this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN;
+    this.attributeName = attributeName;
+    this.attributeNamespace = attributeNamespace;
+    this.mustUseProperty = mustUseProperty;
+    this.propertyName = name;
+    this.type = type;
+    this.sanitizeURL = sanitizeURL;
+    this.removeEmptyString = removeEmptyString;
+  }
+};
+var properties = {};
+var reservedProps = [
+  "children",
+  "dangerouslySetInnerHTML",
+  // TODO: This prevents the assignment of defaultValue to regular
+  // elements (not just inputs). Now that ReactDOMInput assigns to the
+  // defaultValue property -- do we need this?
+  "defaultValue",
+  "defaultChecked",
+  "innerHTML",
+  "suppressContentEditableWarning",
+  "suppressHydrationWarning"
+];
+reservedProps.forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    RESERVED,
+    false,
+    // mustUseProperty
+    name,
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  ["acceptCharset", "accept-charset"],
+  ["className", "class"],
+  ["htmlFor", "for"],
+  ["httpEquiv", "http-equiv"]
+].forEach(([name, attributeName]) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    STRING,
+    false,
+    // mustUseProperty
+    attributeName,
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+["contentEditable", "draggable", "spellCheck", "value"].forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    BOOLEANISH_STRING,
+    false,
+    // mustUseProperty
+    name.toLowerCase(),
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  "autoReverse",
+  "externalResourcesRequired",
+  "focusable",
+  "preserveAlpha"
+].forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    BOOLEANISH_STRING,
+    false,
+    // mustUseProperty
+    name,
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  "allowFullScreen",
+  "async",
+  // Note: there is a special case that prevents it from being written to the DOM
+  // on the client side because the browsers are inconsistent. Instead we call focus().
+  "autoFocus",
+  "autoPlay",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "disablePictureInPicture",
+  "disableRemotePlayback",
+  "formNoValidate",
+  "hidden",
+  "loop",
+  "noModule",
+  "noValidate",
+  "open",
+  "playsInline",
+  "readOnly",
+  "required",
+  "reversed",
+  "scoped",
+  "seamless",
+  // Microdata
+  "itemScope"
+].forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    BOOLEAN,
+    false,
+    // mustUseProperty
+    name.toLowerCase(),
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  "checked",
+  // Note: `option.selected` is not updated if `select.multiple` is
+  // disabled with `removeAttribute`. We have special logic for handling this.
+  "multiple",
+  "muted",
+  "selected"
+  // NOTE: if you add a camelCased prop to this list,
+  // you'll need to set attributeName to name.toLowerCase()
+  // instead in the assignment below.
+].forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    BOOLEAN,
+    true,
+    // mustUseProperty
+    name,
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  "capture",
+  "download"
+  // NOTE: if you add a camelCased prop to this list,
+  // you'll need to set attributeName to name.toLowerCase()
+  // instead in the assignment below.
+].forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    OVERLOADED_BOOLEAN,
+    false,
+    // mustUseProperty
+    name,
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  "cols",
+  "rows",
+  "size",
+  "span"
+  // NOTE: if you add a camelCased prop to this list,
+  // you'll need to set attributeName to name.toLowerCase()
+  // instead in the assignment below.
+].forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    POSITIVE_NUMERIC,
+    false,
+    // mustUseProperty
+    name,
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+["rowSpan", "start"].forEach((name) => {
+  properties[name] = new PropertyInfoRecord(
+    name,
+    NUMERIC,
+    false,
+    // mustUseProperty
+    name.toLowerCase(),
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+var CAMELIZE = /[-:]([a-z])/g;
+var capitalize = (token) => token[1].toUpperCase();
+[
+  "accent-height",
+  "alignment-baseline",
+  "arabic-form",
+  "baseline-shift",
+  "cap-height",
+  "clip-path",
+  "clip-rule",
+  "color-interpolation",
+  "color-interpolation-filters",
+  "color-profile",
+  "color-rendering",
+  "dominant-baseline",
+  "enable-background",
+  "fill-opacity",
+  "fill-rule",
+  "flood-color",
+  "flood-opacity",
+  "font-family",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-variant",
+  "font-weight",
+  "glyph-name",
+  "glyph-orientation-horizontal",
+  "glyph-orientation-vertical",
+  "horiz-adv-x",
+  "horiz-origin-x",
+  "image-rendering",
+  "letter-spacing",
+  "lighting-color",
+  "marker-end",
+  "marker-mid",
+  "marker-start",
+  "overline-position",
+  "overline-thickness",
+  "paint-order",
+  "panose-1",
+  "pointer-events",
+  "rendering-intent",
+  "shape-rendering",
+  "stop-color",
+  "stop-opacity",
+  "strikethrough-position",
+  "strikethrough-thickness",
+  "stroke-dasharray",
+  "stroke-dashoffset",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-miterlimit",
+  "stroke-opacity",
+  "stroke-width",
+  "text-anchor",
+  "text-decoration",
+  "text-rendering",
+  "underline-position",
+  "underline-thickness",
+  "unicode-bidi",
+  "unicode-range",
+  "units-per-em",
+  "v-alphabetic",
+  "v-hanging",
+  "v-ideographic",
+  "v-mathematical",
+  "vector-effect",
+  "vert-adv-y",
+  "vert-origin-x",
+  "vert-origin-y",
+  "word-spacing",
+  "writing-mode",
+  "xmlns:xlink",
+  "x-height"
+  // NOTE: if you add a camelCased prop to this list,
+  // you'll need to set attributeName to name.toLowerCase()
+  // instead in the assignment below.
+].forEach((attributeName) => {
+  const name = attributeName.replace(CAMELIZE, capitalize);
+  properties[name] = new PropertyInfoRecord(
+    name,
+    STRING,
+    false,
+    // mustUseProperty
+    attributeName,
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  "xlink:actuate",
+  "xlink:arcrole",
+  "xlink:role",
+  "xlink:show",
+  "xlink:title",
+  "xlink:type"
+  // NOTE: if you add a camelCased prop to this list,
+  // you'll need to set attributeName to name.toLowerCase()
+  // instead in the assignment below.
+].forEach((attributeName) => {
+  const name = attributeName.replace(CAMELIZE, capitalize);
+  properties[name] = new PropertyInfoRecord(
+    name,
+    STRING,
+    false,
+    // mustUseProperty
+    attributeName,
+    "http://www.w3.org/1999/xlink",
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+[
+  "xml:base",
+  "xml:lang",
+  "xml:space"
+  // NOTE: if you add a camelCased prop to this list,
+  // you'll need to set attributeName to name.toLowerCase()
+  // instead in the assignment below.
+].forEach((attributeName) => {
+  const name = attributeName.replace(CAMELIZE, capitalize);
+  properties[name] = new PropertyInfoRecord(
+    name,
+    STRING,
+    false,
+    // mustUseProperty
+    attributeName,
+    "http://www.w3.org/XML/1998/namespace",
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+["tabIndex", "crossOrigin"].forEach((attributeName) => {
+  properties[attributeName] = new PropertyInfoRecord(
+    attributeName,
+    STRING,
+    false,
+    // mustUseProperty
+    attributeName.toLowerCase(),
+    // attributeName
+    null,
+    // attributeNamespace
+    false,
+    // sanitizeURL
+    false
+    // removeEmptyString
+  );
+});
+var xlinkHref = "xlinkHref";
+properties[xlinkHref] = new PropertyInfoRecord(
+  "xlinkHref",
+  STRING,
+  false,
+  // mustUseProperty
+  "xlink:href",
+  "http://www.w3.org/1999/xlink",
+  true,
+  // sanitizeURL
+  false
+  // removeEmptyString
+);
+["src", "href", "action", "formAction"].forEach((attributeName) => {
+  properties[attributeName] = new PropertyInfoRecord(
+    attributeName,
+    STRING,
+    false,
+    // mustUseProperty
+    attributeName.toLowerCase(),
+    // attributeName
+    null,
+    // attributeNamespace
+    true,
+    // sanitizeURL
+    true
+    // removeEmptyString
+  );
+});
+
+// src/renderer/unitless-css-properties.ts
+var isPropWithUnitlessNumber = {
+  animationIterationCount: true,
+  aspectRatio: true,
+  borderImageOutset: true,
+  borderImageSlice: true,
+  borderImageWidth: true,
+  boxFlex: true,
+  boxFlexGroup: true,
+  boxOrdinalGroup: true,
+  columnCount: true,
+  columns: true,
+  flex: true,
+  flexGrow: true,
+  flexPositive: true,
+  flexShrink: true,
+  flexNegative: true,
+  flexOrder: true,
+  gridArea: true,
+  gridRow: true,
+  gridRowEnd: true,
+  gridRowSpan: true,
+  gridRowStart: true,
+  gridColumn: true,
+  gridColumnEnd: true,
+  gridColumnSpan: true,
+  gridColumnStart: true,
+  fontWeight: true,
+  lineClamp: true,
+  lineHeight: true,
+  opacity: true,
+  order: true,
+  orphans: true,
+  tabSize: true,
+  widows: true,
+  zIndex: true,
+  zoom: true,
+  // SVG-related properties
+  fillOpacity: true,
+  floodOpacity: true,
+  stopOpacity: true,
+  strokeDasharray: true,
+  strokeDashoffset: true,
+  strokeMiterlimit: true,
+  strokeOpacity: true,
+  strokeWidth: true
+};
+function propWithPrefix(prefix, prop) {
+  return prefix + prop.charAt(0).toUpperCase() + prop.substring(1);
+}
+var prefixes = ["Webkit", "ms", "Moz", "O"];
+for (const key in isPropWithUnitlessNumber) {
+  const prop = key;
+  for (const prefix of prefixes) {
+    isPropWithUnitlessNumber[propWithPrefix(prefix, prop)] = isPropWithUnitlessNumber[prop];
+  }
+}
+
+// src/renderer/property-mapping.ts
+function convertPropsIntoAttributes(props) {
+  return Object.keys(props).filter((key) => !key.startsWith("on") && key !== "children").map((originalKey) => {
+    const propertyInfo = getPropertyInfo(originalKey);
+    if (shouldIgnoreAttribute(originalKey, propertyInfo)) {
+      return void 0;
+    }
+    const value = props[originalKey];
+    if (value === void 0 || value === null)
+      return "";
+    const propertyName = propertyInfo ? propertyInfo.attributeName : originalKey;
+    if (typeof value === "string") {
+      return `${propertyName}="${value}"`;
+    }
+    if (propertyName === "style" && typeof value === "object") {
+      return convertStyleIntoAttribute(value);
+    }
+    if (typeof value === "object") {
+      return `${propertyName}="${JSON.stringify(value)}"`;
+    }
+    return `${propertyName}="${value}"`;
+  }).filter(Boolean).join(" ");
+}
+function convertStyleIntoAttribute(style) {
+  const inlineStyles = Object.entries(style).map(([key, value]) => {
+    let valueToUse = `${value}`;
+    if (typeof value === "number" && value !== 0 && !isPropWithUnitlessNumber[key]) {
+      valueToUse = `${value}px`;
+    }
+    valueToUse = valueToUse.trim();
+    valueToUse = valueToUse.replaceAll('"', "'");
+    if (key.startsWith("ms")) {
+      return `${fromCamelCaseToSnakeCase(key)}:${valueToUse}`;
+    }
+    return `${fromCamelCaseToSnakeCase(key)}:${valueToUse}`;
+  }).join(";");
+  return `style="${inlineStyles}"`;
+}
+function fromCamelCaseToSnakeCase(camelCasedText) {
+  return camelCasedText.replaceAll(
+    /([a-z])([A-Z])/g,
+    (_match, lowerCaseLetter, upperCaseLetter) => {
+      return `${lowerCaseLetter}-${upperCaseLetter.toLowerCase()}`;
+    }
+  );
+}
+
+// src/renderer/nodes/node.ts
+var ParentNode = class {
+  constructor(id, internalChildren) {
+    this.id = id;
+    this.internalChildren = internalChildren;
+  }
+  removeChild(child) {
+    child.parent = void 0;
+    this.internalChildren = this.internalChildren.filter(
+      (otherChild) => otherChild.id !== child.id
+    );
+  }
+  insertBefore(toInsert, nodeToInsertBeforeOf) {
+    const index = this.internalChildren.findIndex(
+      (node) => node.id === nodeToInsertBeforeOf.id
+    );
+    if (index > -1) {
+      toInsert.parent = this;
+      this.internalChildren.splice(index, 0, toInsert);
+    }
+  }
+  appendChild(child) {
+    child.parent = this;
+    this.internalChildren.push(child);
+  }
+  get children() {
+    return this.internalChildren;
+  }
+};
+
+// src/renderer/nodes/element-node.ts
+var ElementNode = class extends ParentNode {
+  constructor(tag, props) {
+    super(Symbol("ElementNode"), []);
+    this.hidden = false;
+    this.internalTag = tag;
+    this.props = props;
+  }
+  get tag() {
+    return this.internalTag;
+  }
+  get html() {
+    if (this.hidden)
+      return "";
+    const attributes = convertPropsIntoAttributes(this.props);
+    const attributePortion = attributes.trim().length > 0 ? ` ${attributes}` : "";
+    if (/^(AREA|BASE|BR|COL|COMMAND|EMBED|HR|IMG|INPUT|KEYGEN|LINK|META|PARAM|SOURCE|TRACK|WBR)$/.test(
+      this.internalTag.toUpperCase()
+    )) {
+      return `<${this.internalTag}${attributePortion}/>`;
+    }
+    let childrenPortion;
+    if ("dangerouslySetInnerHTML" in this.props && typeof this.props.dangerouslySetInnerHTML === "object" && this.props.dangerouslySetInnerHTML !== null && "__html" in this.props.dangerouslySetInnerHTML && typeof this.props.dangerouslySetInnerHTML.__html === "string") {
+      childrenPortion = this.props.dangerouslySetInnerHTML.__html;
+    } else {
+      childrenPortion = this.internalChildren.map((child) => child.html).join("");
+    }
+    return `<${this.internalTag}${attributePortion}>${childrenPortion}</${this.internalTag}>`;
+  }
+  get children() {
+    return this.internalChildren;
+  }
+};
+
+// src/renderer/nodes/text-node.ts
+var TextNode = class {
+  constructor(text) {
+    this.id = Symbol("TextNode");
+    this.hidden = false;
+    this.text = text;
+  }
+  get html() {
+    if (this.hidden)
+      return "";
+    return this.text;
+  }
+};
+
+// src/renderer/index.ts
+var renderer = createReconciler({
+  isPrimaryRenderer: true,
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: true,
+  supportsMicrotasks: true,
+  scheduleMicrotask: queueMicrotask,
+  scheduleTimeout: setTimeout,
+  cancelTimeout: clearTimeout,
+  noTimeout: -1,
+  appendChildToContainer(container, child) {
+    container.appendChild(child);
+  },
+  insertInContainerBefore(container, child, beforeChild) {
+    container.insertBefore(child, beforeChild);
+  },
+  appendInitialChild(parent, child) {
+    parent.appendChild(child);
+  },
+  insertBefore(parent, child, beforeChild) {
+    parent.insertBefore(child, beforeChild);
+  },
+  appendChild(parent, child) {
+    parent.appendChild(child);
+  },
+  removeChild(node, removeNode) {
+    node.removeChild(removeNode);
+  },
+  removeChildFromContainer(container, node) {
+    container.removeChild(node);
+  },
+  clearContainer: (container) => {
+    for (const child of container.children) {
+      container.removeChild(child);
+    }
+  },
+  getRootHostContext: () => ({}),
+  createInstance(type, props) {
+    return new ElementNode(type, props);
+  },
+  createTextInstance(text) {
+    return new TextNode(text);
+  },
+  prepareForCommit: () => null,
+  preparePortalMount: () => null,
+  commitTextUpdate(node, _oldText, newText) {
+    node.text = newText;
+  },
+  resetAfterCommit() {
+  },
+  getChildHostContext(parentHostContext) {
+    return parentHostContext;
+  },
+  shouldSetTextContent: () => false,
+  resetTextContent() {
+  },
+  hideTextInstance(node) {
+    node.hidden = true;
+  },
+  unhideTextInstance(node) {
+    node.hidden = false;
+  },
+  getPublicInstance: (instance) => instance,
+  hideInstance(node) {
+    node.hidden = true;
+  },
+  unhideInstance(node) {
+    node.hidden = false;
+  },
+  finalizeInitialChildren: () => false,
+  getCurrentEventPriority: () => DefaultEventPriority,
+  beforeActiveInstanceBlur() {
+  },
+  afterActiveInstanceBlur() {
+  },
+  detachDeletedInstance() {
+  },
+  getInstanceFromNode: () => null,
+  prepareScopeUpdate() {
+  },
+  getInstanceFromScope: () => null,
+  prepareUpdate() {
+    return null;
+  },
+  commitUpdate() {
+  }
+});
+
+// src/renderer/nodes/root.ts
+var Root = class extends ParentNode {
+  constructor() {
+    super(Symbol("RootNode"), []);
+  }
+  get html() {
+    return this.internalChildren.map((child) => child.html).join("");
+  }
+};
+
+// src/plain-text-selectors.ts
+var plainTextSelectors = [
+  { selector: "img", format: "skip" },
+  { selector: "#__react-email-preview", format: "skip" },
+  {
+    selector: "a",
+    options: { linkBrackets: false }
+  }
+];
+
+// src/utils/pretty.ts
+import jsBeautify from "js-beautify";
+var defaults = {
+  unformatted: ["code", "pre", "em", "strong", "span"],
+  indent_inner_html: true,
+  indent_char: " ",
+  indent_size: 2,
+  sep: "\n"
+};
+var pretty = (str, options = {}) => {
+  return jsBeautify.html(str, __spreadValues(__spreadValues({}, defaults), options));
+};
+
+// src/render.ts
+function checkIfAllSuspensesAreDone(fiber) {
+  if (fiber.tag === 13 && fiber.memoizedState !== null) {
+    return false;
+  }
+  let child = fiber.child;
+  while (child !== null) {
+    if (!checkIfAllSuspensesAreDone(child)) {
+      return false;
+    }
+    child = child.sibling;
+  }
+  return true;
+}
+var renderToMarkup = (element) => {
+  return new Promise((resolve, reject) => {
+    const root = new Root();
+    const container = renderer.createContainer(
+      root,
+      ConcurrentRoot,
+      {},
+      false,
+      true,
+      "",
+      (err) => {
+        reject(err);
+      },
+      {}
+    );
+    renderer.updateContainer(element, container, null, () => {
+      function checkCompletion() {
+        if (checkIfAllSuspensesAreDone(container.current)) {
+          resolve(root.html);
+        } else {
+          setTimeout(checkCompletion, 0);
+        }
+      }
+      checkCompletion();
+    });
+  });
+};
+var doctype = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">';
+var render = (element, options) => __async(void 0, null, function* () {
+  const markup = yield renderToMarkup(element);
+  const document = `${doctype}${markup}`;
+  if (options == null ? void 0 : options.plainText) {
+    return convert(document, __spreadValues({
+      selectors: plainTextSelectors
+    }, options.htmlToTextOptions));
+  }
+  if (options == null ? void 0 : options.pretty) {
+    return pretty(document);
+  }
+  return document;
+});
+export {
+  doctype,
+  plainTextSelectors,
+  render
+};