@talqui-oss/template-builder 0.0.0-stage → 0.1.0-alpha.0

package/dist/index.cjs

@@ -0,0 +1,1855 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TemplateValidationError: () => TemplateValidationError,
+  UnsupportedByProviderError: () => UnsupportedByProviderError,
+  applyEdit: () => applyEdit,
+  changeCategory: () => changeCategory,
+  codes: () => codes,
+  defineAdapter: () => defineAdapter,
+  editorSections: () => editorSections,
+  editorTree: () => editorTree,
+  extractVariables: () => extractVariables,
+  previewTree: () => previewTree,
+  syncVariables: () => syncVariables,
+  toCurl: () => toCurl,
+  toPreviewModel: () => toPreviewModel,
+  toRequests: () => toRequests,
+  validate: () => validate
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/validate/text.ts
+var PLACEHOLDER = /\{\{(.*?)\}\}/g;
+var VARIABLE_NAME = /^[a-z][a-z0-9_]*$/;
+var INVISIBLE = /[\p{Default_Ignorable_Code_Point}\u2800]/gu;
+var THAI_LAO = /[\u0E00-\u0E7F]/g;
+var CJK = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/gu;
+var EMOJI = /\p{Regional_Indicator}{2}|\p{Extended_Pictographic}(?:\uFE0F|\p{Emoji_Modifier})*(?:\u200D\p{Extended_Pictographic}(?:\uFE0F|\p{Emoji_Modifier})*)*/gu;
+var MARKUP = /\*[^*\n]+\*|_[^_\n]+_|~[^~\n]+~|```[^`]+```/;
+function placeholders(text) {
+  return [...text.matchAll(PLACEHOLDER)].map((match) => {
+    const name = match[1] ?? "";
+    return { raw: match[0], name, valid: VARIABLE_NAME.test(name) };
+  });
+}
+var length = (text) => [...text].length;
+var countEmoji = (text) => text.match(EMOJI)?.length ?? 0;
+var hasMarkup = (text) => text.includes("*") || MARKUP.test(text);
+function countWords(text) {
+  const clean = text.replace(INVISIBLE, "");
+  const params = placeholders(clean).length;
+  const thai = clean.match(THAI_LAO)?.length ?? 0;
+  if (thai > 0) return Math.ceil(thai / 7) + params;
+  const cjk = clean.match(CJK)?.length ?? 0;
+  if (cjk > 0) return cjk + params;
+  return clean.match(/\S+/g)?.length ?? 0;
+}
+var EDGE_START = /^[\s*_~`]*\{\{[^}]*\}\}/;
+var EDGE_END = /\{\{[^}]*\}\}[\s*_~`]*!*\.*\?*[\s*_~`]*$/;
+var ADJACENT = /\{\{[^}]*\}\}[\s*_~`]*\{\{[^}]*\}\}/;
+var startsOrEndsWithPlaceholder = (text) => EDGE_START.test(text) || EDGE_END.test(text);
+var hasAdjacentPlaceholders = (text) => ADJACENT.test(text);
+
+// src/variables.ts
+function textFields(template) {
+  if (template.category === "AUTHENTICATION") return [];
+  const fields = [];
+  if (template.header?.type === "TEXT")
+    fields.push({ path: "header.text", text: template.header.text });
+  fields.push({ path: "body.text", text: template.body.text });
+  template.carousel?.cards.forEach((card, index) => {
+    if (card.body)
+      fields.push({
+        path: `carousel.cards.${index}.body.text`,
+        text: card.body.text
+      });
+  });
+  template.buttons?.forEach((button2, index) => {
+    if (button2.type === "URL")
+      fields.push({ path: `buttons.${index}.url`, text: button2.url });
+  });
+  template.carousel?.cards.forEach((card, cardIndex) => {
+    card.buttons?.forEach((button2, index) => {
+      if (button2.type === "URL")
+        fields.push({
+          path: `carousel.cards.${cardIndex}.buttons.${index}.url`,
+          text: button2.url
+        });
+    });
+  });
+  return fields;
+}
+var replacePlaceholders = (text, replace) => text.replace(/\{\{(.*?)\}\}/g, (_, name) => replace(name));
+function extractVariables(template) {
+  const names = textFields(template).flatMap(
+    (field) => placeholders(field.text).map((p) => p.name)
+  );
+  return [...new Set(names)];
+}
+
+// src/validate/authentication.ts
+var ANDROID_PACKAGE = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/;
+var SIGNATURE_HASH = /^[a-zA-Z0-9/+=]{11}$/;
+var URL_LIKE = /(https?:\/\/|www\.)\S+|\b[\w-]+\.[a-z]{2,6}\b/i;
+function validateAuthentication(template, { report }) {
+  const minutes = template.footer?.codeExpirationMinutes;
+  if (minutes !== void 0 && (!Number.isInteger(minutes) || minutes < 1 || minutes > 90)) {
+    report(
+      "OTP_CODE_EXPIRATION_RANGE",
+      "footer.codeExpirationMinutes",
+      "The code expiration must be a whole number of minutes from 1 to 90."
+    );
+  }
+  const { button: button2 } = template;
+  for (const field of ["text", "autofillText"]) {
+    const text = button2[field];
+    if (text === void 0) continue;
+    if (length(text) > 25)
+      report(
+        "OTP_BUTTON_TEXT_TOO_LONG",
+        `button.${field}`,
+        "OTP button text can have at most 25 characters."
+      );
+    if (URL_LIKE.test(text))
+      report(
+        "OTP_BUTTON_TEXT_URL",
+        `button.${field}`,
+        "OTP button text cannot contain a link."
+      );
+  }
+  if (button2.otpType === "COPY_CODE") return;
+  const apps = button2.supportedApps ?? [];
+  if (apps.length === 0)
+    report(
+      "OTP_SUPPORTED_APPS_REQUIRED",
+      "button.supportedApps",
+      `${button2.otpType} buttons need at least one Android app (package name and signature hash).`
+    );
+  if (apps.length > 5)
+    report(
+      "OTP_SUPPORTED_APPS_TOO_MANY",
+      "button.supportedApps",
+      "An OTP button can list at most 5 apps."
+    );
+  const seen = /* @__PURE__ */ new Set();
+  apps.forEach((app, index) => {
+    const at = `button.supportedApps.${index}`;
+    if (!ANDROID_PACKAGE.test(app.packageName) || app.packageName.length > 224) {
+      report(
+        "OTP_PACKAGE_NAME_INVALID",
+        `${at}.packageName`,
+        "Use the Android package name, e.g. com.example.app (at most 224 characters)."
+      );
+    }
+    if (!SIGNATURE_HASH.test(app.signatureHash)) {
+      report(
+        "OTP_SIGNATURE_HASH_INVALID",
+        `${at}.signatureHash`,
+        "The app signature hash has exactly 11 characters (letters, numbers, +, / or =)."
+      );
+    }
+    const key = `${app.packageName}:${app.signatureHash}`;
+    if (seen.has(key))
+      report("OTP_SUPPORTED_APP_DUPLICATED", at, "This app is listed twice.");
+    seen.add(key);
+  });
+  if (button2.otpType === "ZERO_TAP" && button2.zeroTapTermsAccepted !== true) {
+    report(
+      "OTP_ZERO_TAP_TERMS_NOT_ACCEPTED",
+      "button.zeroTapTermsAccepted",
+      "Zero-tap buttons require `zeroTapTermsAccepted: true` to accept Meta's zero-tap terms."
+    );
+  }
+}
+
+// src/validate/codes.ts
+var codes = {
+  SCHEMA_INVALID: "error",
+  NAME_INVALID: "error",
+  NAME_TOO_LONG: "error",
+  LANGUAGE_INVALID: "error",
+  CATEGORY_MISMATCH: "error",
+  TTL_OUT_OF_RANGE: "error",
+  PLACEHOLDER_INVALID: "error",
+  PLACEHOLDER_DUPLICATED: "error",
+  VARIABLE_NOT_DECLARED: "error",
+  VARIABLE_MISSING_EXAMPLE: "error",
+  VARIABLE_UNUSED: "warning",
+  PARAM_RATIO_TOO_HIGH: "error",
+  PARAM_ADJACENT: "error",
+  PARAM_AT_EDGE: "error",
+  HEADER_TEXT_REQUIRED: "error",
+  HEADER_TOO_LONG: "error",
+  HEADER_TOO_MANY_PARAMS: "error",
+  HEADER_NEWLINE: "error",
+  HEADER_EMOJI: "error",
+  HEADER_FORMATTING: "error",
+  HEADER_MEDIA_URL_INVALID: "error",
+  BODY_REQUIRED: "error",
+  BODY_TOO_LONG: "error",
+  BODY_MULTIPLE_NEWLINES: "error",
+  BODY_EMOJI_LIMIT: "error",
+  FOOTER_TOO_LONG: "error",
+  FOOTER_PARAMETER: "error",
+  FOOTER_NEWLINE: "error",
+  FOOTER_EMOJI: "error",
+  COMPONENT_NOT_ALLOWED: "error",
+  FOOTER_OPT_OUT_MISSING: "warning",
+  BUTTONS_TOO_MANY: "error",
+  BUTTONS_TYPE_LIMIT: "error",
+  QUICK_REPLIES_NOT_GROUPED: "error",
+  BUTTONS_PARTLY_HIDDEN: "warning",
+  BUTTONS_DESKTOP_UNSUPPORTED: "warning",
+  BUTTON_LABEL_REQUIRED: "error",
+  BUTTON_LABEL_TOO_LONG: "error",
+  BUTTON_LABEL_PARAMETER: "error",
+  BUTTON_LABEL_FORMATTING: "error",
+  BUTTON_LABEL_DUPLICATED: "error",
+  BUTTON_URL_INVALID: "error",
+  BUTTON_URL_TOO_LONG: "error",
+  BUTTON_URL_PARAM_POSITION: "error",
+  BUTTON_URL_WHATSAPP_DIRECT: "error",
+  BUTTON_URL_SHORTENED: "error",
+  BUTTON_URL_REDIRECT: "error",
+  BUTTON_PHONE_INVALID: "error",
+  BUTTON_COPY_CODE_EXAMPLE_REQUIRED: "error",
+  BUTTON_COPY_CODE_EXAMPLE_TOO_LONG: "error",
+  LTO_TEXT_REQUIRED: "error",
+  LTO_TEXT_TOO_LONG: "error",
+  LTO_URL_BUTTON_REQUIRED: "error",
+  CAROUSEL_CARDS_COUNT: "error",
+  CAROUSEL_CARDS_MISMATCH: "error",
+  CAROUSEL_CARD_MEDIA_URL_INVALID: "error",
+  CAROUSEL_CARD_BODY_REQUIRED: "error",
+  CAROUSEL_CARD_BODY_TOO_LONG: "error",
+  CAROUSEL_CARD_BODY_NEWLINES: "error",
+  CAROUSEL_CARD_BUTTONS_REQUIRED: "error",
+  CAROUSEL_CARD_BUTTONS_TOO_MANY: "error",
+  CALL_PERMISSION_NOT_COMBINABLE: "error",
+  ORDER_DETAILS_MISMATCH: "error",
+  BUTTON_ORDER_DETAILS_TEXT: "error",
+  OTP_CODE_EXPIRATION_RANGE: "error",
+  OTP_BUTTON_TEXT_TOO_LONG: "error",
+  OTP_BUTTON_TEXT_URL: "error",
+  OTP_SUPPORTED_APPS_REQUIRED: "error",
+  OTP_SUPPORTED_APPS_TOO_MANY: "error",
+  OTP_SUPPORTED_APP_DUPLICATED: "error",
+  OTP_PACKAGE_NAME_INVALID: "error",
+  OTP_SIGNATURE_HASH_INVALID: "error",
+  OTP_ZERO_TAP_TERMS_NOT_ACCEPTED: "error"
+};
+
+// src/validate/buttons.ts
+var PER_TYPE_LIMIT = {
+  URL: 2,
+  PHONE_NUMBER: 1,
+  VOICE_CALL: 1,
+  COPY_CODE: 1,
+  FLOW: 1,
+  CATALOG: 1,
+  MPM: 1,
+  SPM: 1,
+  ORDER_DETAILS: 1,
+  PAYMENT_REQUEST: 3
+};
+var WHATSAPP_ALLOWED = [
+  "whatsapp.com/otp",
+  "wa.me/in/bill/reminder",
+  "wa.me/pay"
+];
+var REDIRECT_PARAMS = [
+  "redirect",
+  "url",
+  "q",
+  "goto",
+  "out",
+  "away",
+  "external"
+];
+function validateButtons(buttons, template, path, ctx, inCard = false) {
+  const { report } = ctx;
+  if (!inCard && buttons.length > 10)
+    report(
+      "BUTTONS_TOO_MANY",
+      path,
+      `A template can have at most 10 buttons; this one has ${buttons.length}.`
+    );
+  const counts = /* @__PURE__ */ new Map();
+  for (const button2 of buttons)
+    counts.set(button2.type, (counts.get(button2.type) ?? 0) + 1);
+  for (const [type, count2] of counts) {
+    const limit = PER_TYPE_LIMIT[type];
+    if (limit !== void 0 && count2 > limit)
+      report(
+        "BUTTONS_TYPE_LIMIT",
+        path,
+        `At most ${limit} ${type} button${limit > 1 ? "s" : ""} per template; found ${count2}.`
+      );
+  }
+  const quickReplies = buttons.map((b) => b.type === "QUICK_REPLY");
+  const firstQr = quickReplies.indexOf(true);
+  const lastQr = quickReplies.lastIndexOf(true);
+  if (firstQr >= 0 && quickReplies.slice(firstQr, lastQr + 1).includes(false)) {
+    report(
+      "QUICK_REPLIES_NOT_GROUPED",
+      path,
+      "Quick reply buttons must be next to each other, all before or all after the other buttons."
+    );
+  }
+  if (!inCard && buttons.length > 3)
+    report(
+      "BUTTONS_PARTLY_HIDDEN",
+      path,
+      'With more than 3 buttons, WhatsApp shows 2 and puts the rest behind "See all options".'
+    );
+  if (!inCard && (buttons.length >= 4 || firstQr >= 0 && quickReplies.includes(false))) {
+    report(
+      "BUTTONS_DESKTOP_UNSUPPORTED",
+      path,
+      "Templates with 4 or more buttons, or quick replies mixed with other buttons, are not shown on WhatsApp Desktop."
+    );
+  }
+  if (counts.has("COPY_CODE") && template.category !== "MARKETING") {
+    report(
+      "CATEGORY_MISMATCH",
+      "category",
+      "Templates with a COPY_CODE button must use the MARKETING category."
+    );
+  }
+  const labels = /* @__PURE__ */ new Map();
+  buttons.forEach((button2, index) => {
+    const at = `${path}.${index}`;
+    if ("text" in button2 && button2.text !== void 0) {
+      validateLabel(button2.text, `${at}.text`, ctx);
+      if (button2.text !== "") {
+        if (labels.has(button2.text))
+          report(
+            "BUTTON_LABEL_DUPLICATED",
+            `${at}.text`,
+            `"${button2.text}" is already used by button ${labels.get(button2.text)}. Labels must be unique.`
+          );
+        else labels.set(button2.text, index);
+      }
+    }
+    if (button2.type === "URL")
+      validateUrl(button2.url, `${at}.url`, template, ctx);
+    if (button2.type === "PHONE_NUMBER" && !/^\+[1-9]\d{6,18}$/.test(button2.phoneNumber.replace(/[\s-]/g, ""))) {
+      report(
+        "BUTTON_PHONE_INVALID",
+        `${at}.phoneNumber`,
+        "Use the international format with country code, e.g. +15550100."
+      );
+    }
+    if (button2.type === "COPY_CODE") {
+      if (button2.example.trim() === "")
+        report(
+          "BUTTON_COPY_CODE_EXAMPLE_REQUIRED",
+          `${at}.example`,
+          "Add a sample coupon code."
+        );
+      else if (length(button2.example) > 20)
+        report(
+          "BUTTON_COPY_CODE_EXAMPLE_TOO_LONG",
+          `${at}.example`,
+          "Coupon codes can have at most 20 characters."
+        );
+    }
+  });
+}
+function validateLabel(text, path, { report }) {
+  if (text.trim() === "")
+    return report("BUTTON_LABEL_REQUIRED", path, "Button text is required.");
+  if (length(text) > 25)
+    report(
+      "BUTTON_LABEL_TOO_LONG",
+      path,
+      `Button text can have at most 25 characters; this one has ${length(text)}.`
+    );
+  if (placeholders(text).length > 0)
+    report(
+      "BUTTON_LABEL_PARAMETER",
+      path,
+      "Button text cannot contain variables."
+    );
+  if (hasMarkup(text) || /[_~`]/.test(text))
+    report(
+      "BUTTON_LABEL_FORMATTING",
+      path,
+      "Button text cannot contain *, _, ~ or ` characters."
+    );
+}
+function validateUrl(url, path, template, { report, options }) {
+  const params = placeholders(url);
+  if (params.length > 1 || params.length === 1 && !url.endsWith(params[0].raw)) {
+    report(
+      "BUTTON_URL_PARAM_POSITION",
+      path,
+      "A URL button can have one variable, and only at the very end."
+    );
+  }
+  if (length(url) > 2e3)
+    report(
+      "BUTTON_URL_TOO_LONG",
+      path,
+      "URLs can have at most 2000 characters."
+    );
+  const sample = params.reduce(
+    (text, p) => text.replace(p.raw, template.variables?.[p.name]?.example || "sample"),
+    url
+  );
+  let parsed;
+  try {
+    parsed = new URL(sample);
+  } catch {
+    return report(
+      "BUTTON_URL_INVALID",
+      path,
+      "Enter a full URL starting with https:// or http://."
+    );
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    return report(
+      "BUTTON_URL_INVALID",
+      path,
+      "URL buttons only accept http and https links."
+    );
+  }
+  const host = parsed.hostname.toLowerCase().replace(/^www\./, "");
+  const isWhatsapp = ["whatsapp.com", "wa.me"].some(
+    (domain) => host === domain || host.endsWith(`.${domain}`)
+  );
+  if (isWhatsapp && !WHATSAPP_ALLOWED.some(
+    (allowed) => `${host}${parsed.pathname}`.startsWith(allowed)
+  )) {
+    report(
+      "BUTTON_URL_WHATSAPP_DIRECT",
+      path,
+      "Links that open a WhatsApp chat (wa.me, whatsapp.com) are not allowed in URL buttons."
+    );
+  }
+  if (options.shortenerDomains.some(
+    (domain) => host === domain || host.endsWith(`.${domain}`)
+  )) {
+    report(
+      "BUTTON_URL_SHORTENED",
+      path,
+      `Shortened links (${host}) are rejected. Use the full destination URL.`
+    );
+  }
+  if (REDIRECT_PARAMS.some((param) => parsed.searchParams.has(param)) || /\/link$/.test(parsed.pathname) && parsed.searchParams.has("u")) {
+    report(
+      "BUTTON_URL_REDIRECT",
+      path,
+      "Links that redirect to another site through a query parameter are rejected. Link to the final page."
+    );
+  }
+}
+
+// src/validate/standard.ts
+var EMOJI_LIMIT = { MARKETING: 10, UTILITY: 6 };
+function validateStandard(template, ctx) {
+  const { report } = ctx;
+  const { header: header2, body, footer, buttons, limitedTimeOffer, carousel } = template;
+  if (header2) {
+    if (header2.type === "TEXT") {
+      const text = header2.text;
+      if (text.trim() === "")
+        report(
+          "HEADER_TEXT_REQUIRED",
+          "header.text",
+          "Header text is required, or remove the header."
+        );
+      if (length(text) > 60)
+        report(
+          "HEADER_TOO_LONG",
+          "header.text",
+          `Header text can have at most 60 characters; this one has ${length(text)}.`
+        );
+      if (placeholders(text).length > 1)
+        report(
+          "HEADER_TOO_MANY_PARAMS",
+          "header.text",
+          "A text header can have at most one variable."
+        );
+      if (text.includes("\n"))
+        report(
+          "HEADER_NEWLINE",
+          "header.text",
+          "Header text cannot have line breaks."
+        );
+      if (countEmoji(text) > 0)
+        report(
+          "HEADER_EMOJI",
+          "header.text",
+          "Header text cannot have emojis."
+        );
+      if (hasMarkup(text))
+        report(
+          "HEADER_FORMATTING",
+          "header.text",
+          "Header text cannot use formatting such as *bold* or a literal asterisk."
+        );
+    } else if ("url" in header2 && !isHttpUrl(header2.url)) {
+      report(
+        "HEADER_MEDIA_URL_INVALID",
+        "header.url",
+        "Add a public https:// URL to a sample file."
+      );
+    }
+  }
+  if (body.text.trim() === "") {
+    report("BODY_REQUIRED", "body.text", "Body text is required.");
+  } else {
+    const limit = limitedTimeOffer ? 600 : 1024;
+    if (length(body.text) > limit)
+      report(
+        "BODY_TOO_LONG",
+        "body.text",
+        `Body text can have at most ${limit} characters; this one has ${length(body.text)}.`
+      );
+    if (/\n{3,}/.test(body.text))
+      report(
+        "BODY_MULTIPLE_NEWLINES",
+        "body.text",
+        "Body text cannot have more than one blank line in a row."
+      );
+    const emoji = countEmoji(body.text);
+    const emojiLimit = EMOJI_LIMIT[template.category];
+    if (emoji > emojiLimit)
+      report(
+        "BODY_EMOJI_LIMIT",
+        "body.text",
+        `${template.category} templates can have at most ${emojiLimit} emojis in the body; this one has ${emoji}.`
+      );
+    validateParams(body.text, "body.text", ctx);
+  }
+  if (footer) {
+    if (limitedTimeOffer)
+      report(
+        "COMPONENT_NOT_ALLOWED",
+        "footer",
+        "Limited-time offer templates cannot have a footer."
+      );
+    if (length(footer.text) > 60)
+      report(
+        "FOOTER_TOO_LONG",
+        "footer.text",
+        `Footer text can have at most 60 characters; this one has ${length(footer.text)}.`
+      );
+    if (placeholders(footer.text).length > 0)
+      report(
+        "FOOTER_PARAMETER",
+        "footer.text",
+        "Footer text cannot contain variables."
+      );
+    if (footer.text.includes("\n"))
+      report(
+        "FOOTER_NEWLINE",
+        "footer.text",
+        "Footer text cannot have line breaks."
+      );
+    if (countEmoji(footer.text) > 0)
+      report("FOOTER_EMOJI", "footer.text", "Footer text cannot have emojis.");
+  } else if (template.category === "MARKETING" && !limitedTimeOffer && !carousel) {
+    report(
+      "FOOTER_OPT_OUT_MISSING",
+      "footer",
+      'Marketing templates are less likely to be blocked with an opt-out footer, e.g. "Reply STOP to opt out".'
+    );
+  }
+  if (buttons) validateButtons(buttons, template, "buttons", ctx);
+  if (limitedTimeOffer) {
+    if (template.category !== "MARKETING")
+      report(
+        "CATEGORY_MISMATCH",
+        "category",
+        "Limited-time offer templates must use the MARKETING category."
+      );
+    const text = limitedTimeOffer.text;
+    const limit = ctx.options.limitedTimeOfferTextLimit;
+    if (text.trim() === "")
+      report(
+        "LTO_TEXT_REQUIRED",
+        "limitedTimeOffer.text",
+        "Add the offer headline."
+      );
+    else if (length(text) > limit)
+      report(
+        "LTO_TEXT_TOO_LONG",
+        "limitedTimeOffer.text",
+        `The offer headline can have at most ${limit} characters.`
+      );
+    if (header2 && header2.type !== "IMAGE" && header2.type !== "VIDEO")
+      report(
+        "COMPONENT_NOT_ALLOWED",
+        "header",
+        "Limited-time offer templates only accept an IMAGE or VIDEO header."
+      );
+    if (!buttons?.some((b) => b.type === "URL"))
+      report(
+        "LTO_URL_BUTTON_REQUIRED",
+        "buttons",
+        "Limited-time offer templates need a URL button."
+      );
+  }
+  if (carousel) validateCarousel(carousel.cards, template, ctx);
+  if (template.callPermissionRequest && (buttons?.length || carousel || limitedTimeOffer)) {
+    report(
+      "CALL_PERMISSION_NOT_COMBINABLE",
+      "callPermissionRequest",
+      "Call permission requests cannot be combined with buttons, carousels or limited-time offers."
+    );
+  }
+  const orderButtons = buttons?.filter((b) => b.type === "ORDER_DETAILS").length ?? 0;
+  if (template.displayFormat === "ORDER_DETAILS" !== (orderButtons === 1)) {
+    report(
+      "ORDER_DETAILS_MISMATCH",
+      "displayFormat",
+      'Order details templates need `displayFormat: "ORDER_DETAILS"` and exactly one ORDER_DETAILS button.'
+    );
+  }
+  buttons?.forEach((b, index) => {
+    if (b.type === "ORDER_DETAILS" && b.text !== "Copy Pix code")
+      report(
+        "BUTTON_ORDER_DETAILS_TEXT",
+        `buttons.${index}.text`,
+        'The ORDER_DETAILS button text is fixed by WhatsApp: use "Copy Pix code".'
+      );
+  });
+}
+function validateParams(text, path, { report }) {
+  const params = placeholders(text).length;
+  const words = countWords(text);
+  if (params > 0 && words > 0 && params / words > 0.33333333) {
+    report(
+      "PARAM_RATIO_TOO_HIGH",
+      path,
+      `Too many variables for the amount of text: ${params} variable${params > 1 ? "s" : ""} in ${words} words. Each variable needs at least 3 other words.`
+    );
+  }
+  if (hasAdjacentPlaceholders(text))
+    report(
+      "PARAM_ADJACENT",
+      path,
+      "Two variables cannot be next to each other. Put some text between them."
+    );
+  if (startsOrEndsWithPlaceholder(text))
+    report(
+      "PARAM_AT_EDGE",
+      path,
+      "The body cannot start or end with a variable."
+    );
+}
+function validateCarousel(cards, template, ctx) {
+  const { report, options } = ctx;
+  if (template.category !== "MARKETING")
+    report(
+      "CATEGORY_MISMATCH",
+      "category",
+      "Carousel templates must use the MARKETING category."
+    );
+  if (cards.length < 2 || cards.length > 10)
+    report(
+      "CAROUSEL_CARDS_COUNT",
+      "carousel.cards",
+      `A carousel needs 2 to 10 cards; this one has ${cards.length}.`
+    );
+  for (const field of ["header", "footer", "buttons"]) {
+    if (template[field])
+      report(
+        "COMPONENT_NOT_ALLOWED",
+        field,
+        `Carousel templates cannot have a top-level ${field}; put it in the cards.`
+      );
+  }
+  const shape = (card) => [
+    card.header.type,
+    Boolean(card.body),
+    (card.buttons ?? []).map((b) => b.type).join(",")
+  ].join("|");
+  const first = cards[0] ? shape(cards[0]) : "";
+  cards.forEach((card, index) => {
+    const at = `carousel.cards.${index}`;
+    if (index > 0 && shape(card) !== first)
+      report(
+        "CAROUSEL_CARDS_MISMATCH",
+        at,
+        "Every card needs the same header type, the same parts and the same buttons, in the same order."
+      );
+    if ("url" in card.header && !isHttpUrl(card.header.url))
+      report(
+        "CAROUSEL_CARD_MEDIA_URL_INVALID",
+        `${at}.header.url`,
+        "Add a public https:// URL to a sample image or video."
+      );
+    const text = card.body?.text ?? "";
+    if (text.trim() === "")
+      report(
+        "CAROUSEL_CARD_BODY_REQUIRED",
+        `${at}.body.text`,
+        "Each card needs body text."
+      );
+    if (length(text) > options.carouselCardBodyLimit)
+      report(
+        "CAROUSEL_CARD_BODY_TOO_LONG",
+        `${at}.body.text`,
+        `Card text can have at most ${options.carouselCardBodyLimit} characters.`
+      );
+    if ((text.match(/\n/g)?.length ?? 0) > 2)
+      report(
+        "CAROUSEL_CARD_BODY_NEWLINES",
+        `${at}.body.text`,
+        "Card text can have at most 2 line breaks."
+      );
+    const buttons = card.buttons ?? [];
+    if (buttons.length === 0)
+      report(
+        "CAROUSEL_CARD_BUTTONS_REQUIRED",
+        `${at}.buttons`,
+        "Each card needs at least one button."
+      );
+    if (buttons.length > 2)
+      report(
+        "CAROUSEL_CARD_BUTTONS_TOO_MANY",
+        `${at}.buttons`,
+        "Each card can have at most 2 buttons."
+      );
+    validateButtons(buttons, template, `${at}.buttons`, ctx, true);
+  });
+}
+function isHttpUrl(value) {
+  try {
+    return ["https:", "http:"].includes(new URL(value).protocol);
+  } catch {
+    return false;
+  }
+}
+
+// src/validate/index.ts
+var SHORTENERS = [
+  "bit.ly",
+  "goo.gl",
+  "tinyurl.com",
+  "ow.ly",
+  "short.url",
+  "shorte.st",
+  "short.gs"
+];
+var TTL_RANGE = {
+  AUTHENTICATION: [30, 900],
+  UTILITY: [30, 43200],
+  MARKETING: [43200, 2592e3]
+};
+var CATEGORIES = ["MARKETING", "UTILITY", "AUTHENTICATION"];
+function validate(template, options = {}) {
+  const issues = [];
+  const disabled = new Set(options.disable);
+  const ctx = {
+    report: (code, path, message) => {
+      if (!disabled.has(code))
+        issues.push({ code, path, message, severity: codes[code] });
+    },
+    options: {
+      shortenerDomains: options.shortenerDomains ?? SHORTENERS,
+      limitedTimeOfferTextLimit: options.limitedTimeOfferTextLimit ?? 16,
+      carouselCardBodyLimit: options.carouselCardBodyLimit ?? 160
+    }
+  };
+  const shapeError = checkShape(template);
+  if (shapeError) {
+    ctx.report("SCHEMA_INVALID", shapeError.path, shapeError.message);
+    return { valid: false, issues };
+  }
+  const { report } = ctx;
+  if (!/^[a-z0-9_]+$/.test(template.name))
+    report(
+      "NAME_INVALID",
+      "name",
+      "Use only lowercase letters, numbers and underscores, e.g. order_shipped."
+    );
+  if (template.name.length > 512)
+    report(
+      "NAME_TOO_LONG",
+      "name",
+      "The name can have at most 512 characters."
+    );
+  if (!/^[a-z]{2,3}(_[A-Z]{2})?$/.test(template.language))
+    report(
+      "LANGUAGE_INVALID",
+      "language",
+      'Use a locale code such as "en_US", "pt_BR" or "es".'
+    );
+  const ttl = template.messageSendTtlSeconds;
+  if (ttl !== void 0) {
+    const [min, max] = TTL_RANGE[template.category];
+    if (ttl < min || ttl > max)
+      report(
+        "TTL_OUT_OF_RANGE",
+        "messageSendTtlSeconds",
+        `For ${template.category} templates the TTL must be between ${min} and ${max} seconds.`
+      );
+  }
+  if (template.category === "AUTHENTICATION")
+    validateAuthentication(template, ctx);
+  else {
+    validateVariables(template, ctx);
+    validateStandard(template, ctx);
+  }
+  return { valid: !issues.some((issue) => issue.severity === "error"), issues };
+}
+function validateVariables(template, { report }) {
+  if (template.category === "AUTHENTICATION") return;
+  const declared = template.variables ?? {};
+  const used = /* @__PURE__ */ new Set();
+  for (const field of textFields(template)) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of placeholders(field.text)) {
+      if (!p.valid || p.name.length > 32) {
+        report(
+          "PLACEHOLDER_INVALID",
+          field.path,
+          `"${p.raw}" is not a valid variable. Use a name with lowercase letters, numbers and underscores (up to 32), e.g. {{first_name}}.`
+        );
+        continue;
+      }
+      if (seen.has(p.name))
+        report(
+          "PLACEHOLDER_DUPLICATED",
+          field.path,
+          `"${p.raw}" appears twice in the same text. Use a second variable instead.`
+        );
+      seen.add(p.name);
+      used.add(p.name);
+      if (!(p.name in declared))
+        report(
+          "VARIABLE_NOT_DECLARED",
+          `variables.${p.name}`,
+          `Add an example for "${p.name}" in variables.`
+        );
+    }
+  }
+  for (const [name, variable] of Object.entries(declared)) {
+    if (!variable.example?.trim())
+      report(
+        "VARIABLE_MISSING_EXAMPLE",
+        `variables.${name}.example`,
+        `Add an example value for "${name}".`
+      );
+    if (!used.has(name))
+      report(
+        "VARIABLE_UNUSED",
+        `variables.${name}`,
+        `"${name}" is declared but not used in the template.`
+      );
+  }
+}
+function checkShape(template) {
+  const t = template;
+  if (typeof t !== "object" || t === null)
+    return { path: "", message: "A template must be an object." };
+  for (const field of ["name", "language"]) {
+    if (typeof t[field] !== "string")
+      return { path: field, message: `"${field}" must be a string.` };
+  }
+  if (!CATEGORIES.includes(t.category))
+    return {
+      path: "category",
+      message: "category must be MARKETING, UTILITY or AUTHENTICATION."
+    };
+  if (t.category === "AUTHENTICATION") {
+    const button2 = t.button;
+    if (button2?.type !== "OTP")
+      return {
+        path: "button",
+        message: 'Authentication templates need one button: { type: "OTP", otpType }.'
+      };
+    return void 0;
+  }
+  if (typeof t.body?.text !== "string")
+    return { path: "body.text", message: "body.text must be a string." };
+  const buttons = t.buttons ?? [];
+  if (!Array.isArray(buttons) || buttons.some((b) => typeof b?.type !== "string"))
+    return {
+      path: "buttons",
+      message: "buttons must be an array of objects with a type."
+    };
+  return void 0;
+}
+
+// src/requests.ts
+var TemplateValidationError = class extends Error {
+  constructor(issues) {
+    super(
+      `Template is invalid: ${issues.map((i) => `${i.code} at ${i.path || "template"}`).join(", ")}`
+    );
+    this.issues = issues;
+    this.name = "TemplateValidationError";
+  }
+  issues;
+};
+function toRequests(template, adapter, options) {
+  const { issues } = validate(template, options);
+  const errors = issues.filter((issue) => issue.severity === "error");
+  if (errors.length > 0) throw new TemplateValidationError(errors);
+  return adapter.toRequests(template);
+}
+var doubleQuoted = (value) => `"${value.replace(/["\\`]/g, "\\$&")}"`;
+var singleQuoted = (value) => `'${value.replace(/'/g, "'\\''").replace(/"(\$[A-Z][A-Z0-9_]*)"/g, `"'"$1"'"`)}'`;
+function toCurl(requests) {
+  return [requests].flat().map(
+    (request) => [
+      ...(request.comments ?? []).map((line) => `# ${line}`),
+      [
+        `curl -X ${request.method} ${doubleQuoted(request.url)}`,
+        ...Object.entries(request.headers).map(
+          ([name, value]) => `  -H ${doubleQuoted(`${name}: ${value}`)}`
+        ),
+        `  -d ${singleQuoted(JSON.stringify(request.body, null, 2))}`
+      ].join(" \\\n")
+    ].join("\n")
+  ).join("\n\n");
+}
+
+// src/adapters/types.ts
+function defineAdapter(definition) {
+  return (...[options]) => ({
+    name: definition.name,
+    toRequests: (template) => definition.toRequests(template, options ?? {})
+  });
+}
+var UnsupportedByProviderError = class extends Error {
+  constructor(provider, path, message) {
+    super(`${provider}: ${message} (${path})`);
+    this.provider = provider;
+    this.path = path;
+    this.name = "UnsupportedByProviderError";
+  }
+  provider;
+  path;
+  code = "UNSUPPORTED_BY_PROVIDER";
+};
+
+// src/preview/format.ts
+var MARKERS = [
+  ["```", "mono"],
+  ["*", "bold"],
+  ["_", "italic"],
+  ["~", "strike"],
+  ["`", "code"]
+];
+var TOKEN = 57344;
+var isToken = (char = "") => {
+  const code = char.charCodeAt(0);
+  return code >= TOKEN && code < TOKEN + 4096;
+};
+var isWordChar = (char = "") => /[\p{L}\p{N}]/u.test(char) || isToken(char);
+var isSpace = (char = "") => /\s/.test(char);
+function parseText(text, resolve) {
+  const names = [];
+  const tokenized = text.replace(
+    /\{\{(.*?)\}\}/g,
+    (_, name) => String.fromCharCode(TOKEN + names.push(name) - 1)
+  );
+  const toSpans = (source) => inline(source, {}).flatMap((span2) => expandTokens(span2, names, resolve));
+  const lines2 = [];
+  const rows = tokenized.split("\n");
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    if (row.startsWith("```") && !row.slice(3).includes("```")) {
+      const end = rows.findIndex((r, j) => j > i && r.endsWith("```"));
+      if (end !== -1) {
+        const block = [
+          row.slice(3),
+          ...rows.slice(i + 1, end),
+          rows[end].slice(0, -3)
+        ];
+        lines2.push({
+          kind: "code",
+          text: detokenize(block.join("\n"), names, resolve)
+        });
+        i = end;
+        continue;
+      }
+    }
+    const numbered = /^(\d+)\. (.*)$/.exec(row);
+    if (numbered)
+      lines2.push({
+        kind: "numbered",
+        marker: `${numbered[1]}.`,
+        spans: toSpans(numbered[2])
+      });
+    else if (/^[-*] /.test(row))
+      lines2.push({ kind: "bullet", spans: toSpans(row.slice(2)) });
+    else if (row.startsWith("> "))
+      lines2.push({ kind: "quote", spans: toSpans(row.slice(2)) });
+    else lines2.push({ kind: "paragraph", spans: toSpans(row) });
+  }
+  return lines2;
+}
+function inline(text, marks) {
+  for (let i = 0; i < text.length; i++) {
+    for (const [marker, mark] of MARKERS) {
+      if (!text.startsWith(marker, i) || marks[mark]) continue;
+      const close = findClose(text, i, marker);
+      if (close === -1) continue;
+      const inner = text.slice(i + marker.length, close);
+      const content = mark === "mono" || mark === "code" ? [{ text: inner, ...marks, [mark]: true }] : inline(inner, { ...marks, [mark]: true });
+      return [
+        ...plain(text.slice(0, i), marks),
+        ...content,
+        ...inline(text.slice(close + marker.length), marks)
+      ];
+    }
+  }
+  return plain(text, marks);
+}
+function findClose(text, open, marker) {
+  const before = text[open - 1];
+  const first = text[open + marker.length];
+  if (isWordChar(before) || first === void 0 || isSpace(first)) return -1;
+  for (let j = open + marker.length + 1; j <= text.length - marker.length; j++) {
+    if (!text.startsWith(marker, j)) continue;
+    if (!isSpace(text[j - 1]) && !isWordChar(text[j + marker.length])) return j;
+  }
+  return -1;
+}
+var plain = (text, marks) => text ? [{ text, ...marks }] : [];
+function expandTokens(span2, names, resolve) {
+  return [...span2.text.split(/([\uE000-\uEFFF])/u)].filter(Boolean).map((part) => {
+    if (!isToken(part)) return { ...span2, text: part };
+    const name = names[part.charCodeAt(0) - TOKEN];
+    return { ...span2, text: resolve(name), variable: name };
+  });
+}
+var detokenize = (text, names, resolve) => text.replace(
+  /[\uE000-\uEFFF]/gu,
+  (char) => resolve(names[char.charCodeAt(0) - TOKEN])
+);
+
+// src/preview/locale.ts
+var LOCALES = {
+  en: {
+    authenticationBody: "*{code}* is your verification code.",
+    securityRecommendation: "For your security, do not share this code.",
+    codeExpiration: "This code expires in {minutes} minutes.",
+    copyCode: "Copy code",
+    copyOfferCode: "Copy offer code",
+    seeAllOptions: "See all options"
+  },
+  // Checked against messages received on an iPhone.
+  pt: {
+    authenticationBody: "Seu c\xF3digo de verifica\xE7\xE3o \xE9 *{code}*.",
+    securityRecommendation: "Para sua seguran\xE7a, n\xE3o o compartilhe.",
+    codeExpiration: "Expira em {minutes} minutos.",
+    copyCode: "Copiar c\xF3digo",
+    copyOfferCode: "Copiar c\xF3digo da oferta",
+    seeAllOptions: "Ver todas as op\xE7\xF5es"
+  }
+};
+var localeFor = (language) => LOCALES[language.split("_")[0].toLowerCase()] ?? LOCALES.en;
+
+// src/preview/model.ts
+var MAX_VISIBLE_BUTTONS = 3;
+var SAMPLE_CODE = "123456";
+function toPreviewModel(template, { values = {}, deviceLanguage = "en" } = {}) {
+  const locale = localeFor(template.language);
+  const { seeAllOptions } = localeFor(deviceLanguage);
+  const { issues } = validate(template);
+  if (template.category === "AUTHENTICATION") {
+    const body = locale.authenticationBody.replace("{code}", SAMPLE_CODE);
+    const security = template.body?.addSecurityRecommendation ? ` ${locale.securityRecommendation}` : "";
+    const minutes = template.footer?.codeExpirationMinutes;
+    return {
+      body: parseText(body + security, String),
+      footer: minutes === void 0 ? void 0 : parseText(
+        locale.codeExpiration.replace("{minutes}", String(minutes)),
+        String
+      ),
+      ...groupButtons(
+        [{ label: template.button.text ?? locale.copyCode, icon: "copy" }],
+        seeAllOptions
+      ),
+      issues
+    };
+  }
+  const resolve = (name) => values[name] ?? template.variables?.[name]?.example ?? `{{${name}}}`;
+  const toButtons = (buttons = []) => buttons.map((button2) => toButton(button2, locale.copyOfferCode));
+  return {
+    header: template.header && toHeader(template.header, resolve),
+    linkPreview: template.header ? void 0 : linkPreview(template, resolve),
+    limitedTimeOffer: template.limitedTimeOffer && {
+      text: template.limitedTimeOffer.text,
+      hasExpiration: template.limitedTimeOffer.hasExpiration ?? false
+    },
+    body: parseText(template.body.text, resolve),
+    footer: template.footer && parseText(template.footer.text, resolve),
+    ...groupButtons(toButtons(template.buttons), seeAllOptions),
+    carousel: template.carousel?.cards.map(
+      (card) => ({
+        header: toHeader(card.header, resolve),
+        body: card.body ? parseText(card.body.text, resolve) : [],
+        buttons: toButtons(card.buttons)
+      })
+    ),
+    issues
+  };
+}
+function toHeader(header2, resolve) {
+  switch (header2.type) {
+    case "TEXT":
+      return { type: "TEXT", lines: parseText(header2.text, resolve) };
+    case "DOCUMENT":
+      return {
+        type: "DOCUMENT",
+        url: header2.url,
+        filename: header2.filename ?? header2.url.split("/").pop() ?? "document.pdf"
+      };
+    case "IMAGE":
+    case "VIDEO":
+    case "GIF":
+      return { type: header2.type, url: header2.url };
+    default:
+      return { type: header2.type };
+  }
+}
+function toButton(button2, copyOfferCode) {
+  switch (button2.type) {
+    case "URL":
+      return { label: button2.text, icon: "link" };
+    case "PHONE_NUMBER":
+    case "VOICE_CALL":
+      return { label: button2.text, icon: "phone" };
+    case "COPY_CODE":
+      return { label: copyOfferCode, icon: "copy" };
+    case "CATALOG":
+    case "MPM":
+    case "SPM":
+    case "ORDER_DETAILS":
+      return { label: button2.text, icon: "list" };
+    case "PAYMENT_REQUEST":
+      return { label: button2.text ?? "", icon: "cart" };
+    case "FLOW":
+      return { label: button2.text, icon: "list" };
+    default:
+      return { label: button2.text, icon: "reply" };
+  }
+}
+function linkPreview(template, resolve) {
+  const button2 = template.buttons?.find(
+    (b) => b.type === "URL"
+  );
+  if (!button2) return void 0;
+  try {
+    const url = new URL(replacePlaceholders(button2.url, resolve));
+    return { domain: url.hostname.replace(/^www\./, "") };
+  } catch {
+    return void 0;
+  }
+}
+function groupButtons(buttons, seeAllOptions) {
+  if (buttons.length <= MAX_VISIBLE_BUTTONS) return { buttons, overflow: [] };
+  return {
+    buttons: [
+      ...buttons.slice(0, 2),
+      { label: seeAllOptions, icon: "list" }
+    ],
+    overflow: buttons.slice(2)
+  };
+}
+
+// src/preview/tree.ts
+var node = (tag, className, children = [], attrs) => ({ tag, class: className, attrs, children });
+function previewTree(model, { platform = "ios", time = "10:24" } = {}) {
+  const content = node("div", "tb-bubble__content", [
+    ...model.linkPreview ? [linkPreview2(model.linkPreview.domain)] : [],
+    ...model.header ? [header(model.header)] : [],
+    ...model.limitedTimeOffer ? [node("div", "tb-offer", [model.limitedTimeOffer.text])] : [],
+    node("div", "tb-bubble__body", lines(model.body)),
+    // The time sits on the footer row, or on its own row when there is no footer.
+    node("div", "tb-bubble__meta", [
+      node("div", "tb-bubble__footer", model.footer ? lines(model.footer) : []),
+      node("time", "tb-bubble__time", [time])
+    ])
+  ]);
+  return node(
+    "div",
+    "tb-preview",
+    [
+      node("div", "tb-bubble", [
+        content,
+        ...model.buttons.map(button),
+        node(
+          "svg",
+          "tb-bubble__tail",
+          [node("path", void 0, [], { d: TAIL })],
+          {
+            viewBox: "0 0 12.4 10.33",
+            "aria-hidden": "true"
+          }
+        )
+      ]),
+      ...(model.carousel ?? []).map(
+        (card) => node("div", "tb-card", [
+          header(card.header),
+          node("div", "tb-bubble__body", lines(card.body)),
+          ...card.buttons.map(button)
+        ])
+      )
+    ],
+    { "data-platform": platform }
+  );
+}
+var linkPreview2 = (domain) => node("div", "tb-link", [
+  node(
+    "svg",
+    "tb-link__icon",
+    [node("path", void 0, [], { d: LINK_ICON })],
+    {
+      viewBox: "0 0 9 9.33",
+      "aria-hidden": "true"
+    }
+  ),
+  node("span", void 0, [domain])
+]);
+function header(h) {
+  switch (h.type) {
+    case "TEXT":
+      return node("div", "tb-header tb-header--text", lines(h.lines));
+    case "IMAGE":
+    case "GIF":
+      return node("img", "tb-header tb-header--media", [], {
+        src: h.url,
+        alt: ""
+      });
+    case "VIDEO":
+      return node("video", "tb-header tb-header--media", [], {
+        src: h.url,
+        muted: ""
+      });
+    case "DOCUMENT":
+      return node("div", "tb-header tb-header--document", [h.filename]);
+    default:
+      return node("div", `tb-header tb-header--${h.type.toLowerCase()}`);
+  }
+}
+var lines = (list) => list.map(
+  (line) => line.kind === "code" ? node("pre", "tb-line tb-line--code", [line.text]) : node(
+    "div",
+    `tb-line tb-line--${line.kind}`,
+    line.spans.length ? line.spans.map(span) : ["\xA0"],
+    line.kind === "numbered" ? { "data-marker": line.marker } : void 0
+  )
+);
+function span(s) {
+  const classes = [
+    s.bold && "tb-bold",
+    s.italic && "tb-italic",
+    s.strike && "tb-strike",
+    s.mono && "tb-mono",
+    s.code && "tb-code"
+  ].filter(Boolean);
+  if (!classes.length && !s.variable) return s.text;
+  return node(
+    "span",
+    classes.join(" ") || void 0,
+    [s.text],
+    s.variable ? { "data-variable": s.variable } : void 0
+  );
+}
+var button = (b) => node("div", "tb-button", [icon(b.icon), node("span", void 0, [b.label])]);
+var icon = (name) => {
+  const { width, height, paths } = ICONS[name];
+  return node(
+    "svg",
+    "tb-button__icon",
+    paths.map((d) => node("path", void 0, [], { d })),
+    {
+      viewBox: `0 0 ${width} ${height}`,
+      width: String(width),
+      height: String(height),
+      "aria-hidden": "true"
+    }
+  );
+};
+var TAIL = "M6.2 0C6.2 4.83 3.6 8.63 0 10.33H2Q6.7 9.83 9.8 7.33L12.2 0Z";
+var LINK_ICON = "M3.9 5.4a2 2 0 0 0 2.9.1l1.4-1.4a2 2 0 0 0-2.9-2.9l-.8.8M5.1 3.9a2 2 0 0 0-2.9-.1L.8 5.2a2 2 0 0 0 2.9 2.9l.8-.8";
+var ICONS = {
+  reply: {
+    width: 17.67,
+    height: 15,
+    paths: [
+      "M7.2 .9.9 6.6l6.3 5.5V8.9c4.4-.2 7.7 1.5 9.8 5.3-.4-5.4-3.7-9.6-9.8-9.9Z"
+    ]
+  },
+  link: {
+    width: 15,
+    height: 15,
+    paths: [
+      "M3.6.6h7.8a3 3 0 0 1 3 3v7.8a3 3 0 0 1-3 3H3.6a3 3 0 0 1-3-3V3.6a3 3 0 0 1 3-3Z",
+      "M5 10l5.2-5.2M6 4.8h4.2V9"
+    ]
+  },
+  phone: {
+    width: 15.67,
+    height: 15.67,
+    paths: [
+      "M3.4.9C2.2 1.4 1 2.6.9 3.9c-.2 4.5 6.5 11.3 11.2 11.2 1.3-.1 2.5-1.3 3-2.5.2-.5 0-1-.4-1.3l-2.4-1.7c-.4-.3-1-.2-1.3.1l-1.1 1.2C8 9.9 6.1 8 5.1 6.1L6.3 5c.3-.3.4-.9.1-1.3L4.7 1.3c-.3-.4-.8-.6-1.3-.4Z"
+    ]
+  },
+  copy: {
+    width: 16.67,
+    height: 20.33,
+    paths: [
+      "M1.6 4.8h6.6l3.9 3.9v10.1a1 1 0 0 1-1 1H1.6a1 1 0 0 1-1-1V5.8a1 1 0 0 1 1-1Z",
+      "M8.2 4.8v3.9h3.9",
+      "M4.6 4.8V1.6a1 1 0 0 1 1-1h6.6l3.9 3.9v10.1a1 1 0 0 1-1 1h-3",
+      "M12.2.6v3.9h3.9"
+    ]
+  },
+  list: {
+    width: 15,
+    height: 15,
+    paths: [
+      "M4.5 2.5h10M4.5 7.5h10M4.5 12.5h10M.6 2.5h.1M.6 7.5h.1M.6 12.5h.1"
+    ]
+  },
+  cart: {
+    width: 16,
+    height: 15,
+    paths: ["M.6 1h2.3l1.9 9.3h8.6L15.4 3.8H3.8", "M6 14h.1M13 14h.1"]
+  }
+};
+
+// src/editor/model.ts
+var LANGUAGES = [
+  { value: "en_US", label: "English (US)" },
+  { value: "pt_BR", label: "Portuguese (BR)" },
+  { value: "es", label: "Spanish" }
+];
+var CATEGORIES2 = [
+  { value: "UTILITY", label: "Utility" },
+  { value: "MARKETING", label: "Marketing" },
+  { value: "AUTHENTICATION", label: "Authentication" }
+];
+var HEADER_KINDS = [
+  { value: "NONE", label: "None" },
+  { value: "TEXT", label: "Text" },
+  { value: "IMAGE", label: "Image" },
+  { value: "VIDEO", label: "Video" },
+  { value: "DOCUMENT", label: "Document" }
+];
+var BUTTON_TYPES = [
+  { value: "QUICK_REPLY", label: "Quick reply" },
+  { value: "URL", label: "Link" },
+  { value: "PHONE_NUMBER", label: "Phone" },
+  { value: "COPY_CODE", label: "Copy code" }
+];
+var MAX_BUTTONS = 10;
+var count = (text, max) => `${[...text].length}/${max}`;
+function editorSections(template, options = {}) {
+  const basics = {
+    id: "basics",
+    title: "Basics",
+    rows: [
+      {
+        fields: [
+          {
+            kind: "text",
+            id: "name",
+            label: "Name",
+            hint: "lowercase, numbers and _",
+            value: template.name,
+            mono: true
+          }
+        ]
+      },
+      {
+        fields: [
+          {
+            kind: "select",
+            id: "language",
+            label: "Language",
+            value: template.language,
+            options: options.languages ?? LANGUAGES
+          },
+          {
+            kind: "segment",
+            id: "category",
+            label: "Category",
+            value: template.category,
+            options: CATEGORIES2
+          }
+        ]
+      }
+    ]
+  };
+  if (template.category === "AUTHENTICATION")
+    return [basics, codeSection(template)];
+  return [
+    basics,
+    contentSection(template),
+    buttonsSection(template),
+    variablesSection(template)
+  ];
+}
+function contentSection(template) {
+  const header2 = template.header;
+  const kind = HEADER_KINDS.some((option) => option.value === header2?.type) ? header2.type : "NONE";
+  const headerRow = [
+    {
+      kind: "select",
+      id: "header.kind",
+      label: "Header",
+      value: kind,
+      options: HEADER_KINDS
+    }
+  ];
+  if (header2?.type === "TEXT")
+    headerRow.push({
+      kind: "text",
+      id: "header.text",
+      label: "Header text",
+      hint: count(header2.text, 60),
+      value: header2.text
+    });
+  if (header2 && "url" in header2)
+    headerRow.push({
+      kind: "text",
+      id: "header.url",
+      label: "Sample file URL",
+      value: header2.url,
+      mono: true
+    });
+  return {
+    id: "content",
+    title: "Content",
+    rows: [
+      { fields: headerRow },
+      {
+        fields: [
+          {
+            kind: "textarea",
+            id: "body",
+            label: "Body",
+            hint: count(template.body.text, 1024),
+            value: template.body.text
+          }
+        ]
+      },
+      {
+        fields: [
+          {
+            kind: "text",
+            id: "footer",
+            label: "Footer",
+            hint: count(template.footer?.text ?? "", 60),
+            value: template.footer?.text ?? ""
+          }
+        ]
+      }
+    ],
+    note: "Use {{name}} for variables and *bold*, _italic_, ~strike~ for formatting."
+  };
+}
+function buttonsSection(template) {
+  const buttons = template.buttons ?? [];
+  const rows = buttons.map((button2, index) => {
+    const at = `buttons.${index}`;
+    const type = BUTTON_TYPES.some((option) => option.value === button2.type) ? button2.type : "QUICK_REPLY";
+    const fields = [
+      {
+        kind: "select",
+        id: `${at}.type`,
+        label: "Type",
+        value: type,
+        options: BUTTON_TYPES
+      }
+    ];
+    if ("text" in button2 && button2.text !== void 0)
+      fields.push({
+        kind: "text",
+        id: `${at}.text`,
+        label: "Button text",
+        hint: count(button2.text, 25),
+        value: button2.text
+      });
+    if (button2.type === "URL")
+      fields.push({
+        kind: "text",
+        id: `${at}.url`,
+        label: "URL",
+        value: button2.url,
+        mono: true
+      });
+    if (button2.type === "PHONE_NUMBER")
+      fields.push({
+        kind: "text",
+        id: `${at}.phoneNumber`,
+        label: "Phone number",
+        value: button2.phoneNumber,
+        mono: true
+      });
+    if (button2.type === "COPY_CODE")
+      fields.push({
+        kind: "text",
+        id: `${at}.example`,
+        label: "Sample code",
+        value: button2.example,
+        mono: true
+      });
+    fields.push({
+      kind: "action",
+      id: `${at}.remove`,
+      label: "Remove button",
+      icon: "remove"
+    });
+    return { fields, list: true };
+  });
+  rows.push({
+    fields: [
+      {
+        kind: "action",
+        id: "buttons.add",
+        label: "Add button",
+        icon: "add",
+        disabled: buttons.length >= MAX_BUTTONS
+      }
+    ]
+  });
+  return {
+    id: "buttons",
+    title: `Buttons ${buttons.length}/${MAX_BUTTONS}`,
+    rows
+  };
+}
+function variablesSection(template) {
+  const variables = Object.entries(template.variables ?? {});
+  return {
+    id: "variables",
+    title: "Variables",
+    rows: variables.map(([name, variable], index) => ({
+      fields: [
+        {
+          kind: "text",
+          id: `variables.${name}`,
+          label: `{{${name}}}`,
+          hint: `position ${index + 1}`,
+          value: variable.example,
+          placeholder: "Example value"
+        }
+      ]
+    })),
+    note: variables.length ? void 0 : "Type a placeholder such as {{first_name}} in the text to add one."
+  };
+}
+function codeSection(template) {
+  const minutes = template.footer?.codeExpirationMinutes;
+  return {
+    id: "code",
+    title: "Code message",
+    rows: [
+      {
+        fields: [
+          {
+            kind: "checkbox",
+            id: "body.addSecurityRecommendation",
+            label: "Add \u201Cdo not share this code\u201D",
+            checked: template.body?.addSecurityRecommendation ?? false
+          }
+        ]
+      },
+      {
+        fields: [
+          {
+            kind: "text",
+            id: "footer.codeExpirationMinutes",
+            label: "Expires after",
+            hint: "minutes, 1 to 90",
+            value: minutes === void 0 ? "" : String(minutes),
+            mono: true
+          },
+          {
+            kind: "text",
+            id: "button.text",
+            label: "Button text",
+            hint: "optional",
+            value: template.button.text ?? "",
+            placeholder: "Copy code"
+          }
+        ]
+      }
+    ]
+  };
+}
+function applyEdit(template, id, value, remembered = {}) {
+  const text = typeof value === "string" ? value : "";
+  if (id === "name") return { ...template, name: text };
+  if (id === "language") return { ...template, language: text };
+  if (id === "category") return changeCategory(template, text);
+  if (template.category === "AUTHENTICATION") {
+    if (id === "body.addSecurityRecommendation")
+      return {
+        ...template,
+        body: { addSecurityRecommendation: value === true }
+      };
+    if (id === "footer.codeExpirationMinutes") {
+      const digits = text.replace(/\D/g, "");
+      return {
+        ...template,
+        footer: digits ? { codeExpirationMinutes: Number(digits) } : void 0
+      };
+    }
+    if (id === "button.text")
+      return {
+        ...template,
+        button: { ...template.button, text: text || void 0 }
+      };
+    return template;
+  }
+  if (id.startsWith("variables."))
+    return {
+      ...template,
+      variables: {
+        ...template.variables,
+        [id.slice("variables.".length)]: { example: text }
+      }
+    };
+  return syncVariables(editStandard(template, id, text), remembered);
+}
+function editStandard(template, id, text) {
+  if (id === "header.kind") return { ...template, header: newHeader(text) };
+  if (id === "header.text")
+    return { ...template, header: { type: "TEXT", text } };
+  if (id === "header.url" && template.header && "url" in template.header)
+    return { ...template, header: { ...template.header, url: text } };
+  if (id === "body") return { ...template, body: { text } };
+  if (id === "footer")
+    return { ...template, footer: text ? { text } : void 0 };
+  const buttons = template.buttons ?? [];
+  const withButtons = (next2) => ({
+    ...template,
+    buttons: next2.length ? next2 : void 0
+  });
+  if (id === "buttons.add")
+    return buttons.length >= MAX_BUTTONS ? template : withButtons([...buttons, newButton("QUICK_REPLY")]);
+  const match = /^buttons\.(\d+)\.(\w+)$/.exec(id);
+  if (!match) return template;
+  const index = Number(match[1]);
+  const field = match[2];
+  const button2 = buttons[index];
+  if (!button2) return template;
+  if (field === "remove")
+    return withButtons(buttons.filter((_, i) => i !== index));
+  const next = field === "type" ? newButton(
+    text,
+    "text" in button2 ? button2.text ?? "" : ""
+  ) : { ...button2, [field]: text };
+  return withButtons(
+    buttons.map((current, i) => i === index ? next : current)
+  );
+}
+function changeCategory(template, category) {
+  const { name, language } = template;
+  if (category === "AUTHENTICATION")
+    return {
+      name,
+      language,
+      category,
+      body: { addSecurityRecommendation: true },
+      footer: { codeExpirationMinutes: 10 },
+      button: { type: "OTP", otpType: "COPY_CODE" }
+    };
+  if (template.category === "AUTHENTICATION")
+    return { name, language, category, body: { text: "" } };
+  return { ...template, category };
+}
+function syncVariables(template, remembered = {}) {
+  const current = template.variables ?? {};
+  const variables = Object.fromEntries(
+    extractVariables(template).map((name) => [
+      name,
+      current[name] ?? remembered[name] ?? { example: "" }
+    ])
+  );
+  return {
+    ...template,
+    variables: Object.keys(variables).length ? variables : void 0
+  };
+}
+function newHeader(kind) {
+  if (kind === "TEXT") return { type: "TEXT", text: "" };
+  if (kind === "IMAGE" || kind === "VIDEO" || kind === "DOCUMENT")
+    return { type: kind, url: "https://" };
+  return void 0;
+}
+function newButton(type, label = "") {
+  if (type === "URL")
+    return { type, text: label || "Open link", url: "https://" };
+  if (type === "PHONE_NUMBER")
+    return { type, text: label || "Call us", phoneNumber: "+" };
+  if (type === "COPY_CODE") return { type, example: "CODE10" };
+  return { type: "QUICK_REPLY", text: label || "Reply" };
+}
+
+// src/editor/tree.ts
+function editorTree(template, options = {}) {
+  const prefix = options.idPrefix ?? "tb";
+  const sections = editorSections(template, options);
+  return node2(
+    "div",
+    "tb-editor",
+    {},
+    sections.map(
+      (section, index) => node2("section", "tb-editor__section", { "data-section": section.id }, [
+        node2("h3", "tb-editor__title", {}, [
+          node2("span", "tb-editor__index", {}, [
+            String(index + 1).padStart(2, "0")
+          ]),
+          section.title
+        ]),
+        node2("div", "tb-editor__body", {}, [
+          ...section.rows.map(
+            (row) => node2(
+              "div",
+              row.list ? "tb-editor__row tb-editor__row--list" : "tb-editor__row",
+              {},
+              row.fields.map(
+                (field) => fieldNode(field, `${prefix}-${field.id.replace(/\W/g, "-")}`)
+              )
+            )
+          ),
+          ...section.note ? [node2("p", "tb-editor__note", {}, [section.note])] : []
+        ])
+      ])
+    )
+  );
+}
+function fieldNode(field, id) {
+  const edit = { "data-edit": field.id };
+  if (field.kind === "action")
+    return node2(
+      "button",
+      `tb-editor__action tb-editor__action--${field.icon}`,
+      {
+        ...edit,
+        type: "button",
+        "aria-label": field.label,
+        ...field.disabled && { disabled: "" }
+      },
+      [field.icon === "remove" ? "\xD7" : `+ ${field.label}`]
+    );
+  if (field.kind === "checkbox")
+    return node2("label", "tb-editor__check", {}, [
+      node2("input", void 0, {
+        ...edit,
+        id,
+        type: "checkbox",
+        ...field.checked && { checked: "" }
+      }),
+      field.label
+    ]);
+  const head = node2("div", "tb-editor__head", {}, [
+    field.kind === "segment" ? node2("span", "tb-editor__label", { id: `${id}-label` }, [field.label]) : node2("label", "tb-editor__label", { for: id }, [field.label]),
+    ...field.hint ? [node2("span", "tb-editor__hint", {}, [field.hint])] : []
+  ]);
+  let control;
+  if (field.kind === "segment")
+    control = node2(
+      "div",
+      "tb-editor__segment",
+      { role: "radiogroup", "aria-labelledby": `${id}-label` },
+      field.options.map((option) => {
+        const selected = option.value === field.value;
+        return node2(
+          "button",
+          "tb-editor__segment-item",
+          {
+            ...edit,
+            "data-value": option.value,
+            type: "button",
+            role: "radio",
+            "aria-checked": String(selected),
+            tabindex: selected ? "0" : "-1"
+          },
+          [option.label]
+        );
+      })
+    );
+  else if (field.kind === "select")
+    control = node2(
+      "select",
+      "tb-editor__input tb-editor__input--select",
+      // The selected option carries the value, as it does in plain HTML.
+      { ...edit, id },
+      field.options.map(
+        (option) => node2(
+          "option",
+          void 0,
+          {
+            value: option.value,
+            ...option.value === field.value && { selected: "" }
+          },
+          [option.label]
+        )
+      )
+    );
+  else
+    control = node2(
+      field.kind === "textarea" ? "textarea" : "input",
+      [
+        "tb-editor__input",
+        field.mono && "tb-editor__input--mono",
+        field.kind === "textarea" && "tb-editor__input--area"
+      ].filter(Boolean).join(" "),
+      {
+        ...edit,
+        id,
+        value: field.value,
+        ...field.kind === "text" && { type: "text" },
+        ...field.kind === "textarea" && { rows: "7" },
+        ...field.placeholder && { placeholder: field.placeholder }
+      }
+    );
+  return node2("div", "tb-editor__field", {}, [head, control]);
+}
+function node2(tag, className, attrs, children = []) {
+  return { tag, ...className && { class: className }, attrs, children };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TemplateValidationError,
+  UnsupportedByProviderError,
+  applyEdit,
+  changeCategory,
+  codes,
+  defineAdapter,
+  editorSections,
+  editorTree,
+  extractVariables,
+  previewTree,
+  syncVariables,
+  toCurl,
+  toPreviewModel,
+  toRequests,
+  validate
+});