@flightdev/seo 0.2.0

package/dist/index.js

@@ -0,0 +1,1239 @@
+// src/head.ts
+var TAG_ORDER = {
+  base: 0,
+  charset: 1,
+  "http-equiv": 2,
+  viewport: 3,
+  title: 4,
+  meta: 5,
+  link: 6,
+  script: 7
+};
+var VOID_TAGS = /* @__PURE__ */ new Set(["meta", "link", "base"]);
+var BOOLEAN_ATTRS = /* @__PURE__ */ new Set(["async", "defer", "nomodule", "crossorigin"]);
+function generateTagKey(tag) {
+  if (tag.key) {
+    return tag.key;
+  }
+  const attrs = tag.attrs || {};
+  switch (tag.tag) {
+    case "title":
+      return "title";
+    case "base":
+      return "base";
+    case "meta": {
+      if (attrs.charset) return "meta:charset";
+      if (attrs.name) return `meta:name:${attrs.name}`;
+      if (attrs.property) return `meta:property:${attrs.property}`;
+      if (attrs["http-equiv"]) return `meta:http-equiv:${attrs["http-equiv"]}`;
+      return `meta:${JSON.stringify(attrs)}`;
+    }
+    case "link": {
+      if (attrs.rel === "canonical") return "link:canonical";
+      if (attrs.rel === "manifest") return "link:manifest";
+      if (attrs.rel && attrs.href) return `link:${attrs.rel}:${attrs.href}`;
+      if (attrs.rel && attrs.hreflang) return `link:${attrs.rel}:${attrs.hreflang}`;
+      return `link:${JSON.stringify(attrs)}`;
+    }
+    case "script": {
+      if (attrs.type === "application/ld+json" && attrs.id) {
+        return `script:json-ld:${attrs.id}`;
+      }
+      if (attrs.src) return `script:${attrs.src}`;
+      return `script:${JSON.stringify(attrs)}`;
+    }
+    default:
+      return `${tag.tag}:${JSON.stringify(attrs)}`;
+  }
+}
+function getTagOrder(tag) {
+  const attrs = tag.attrs || {};
+  if (tag.tag === "meta") {
+    if (attrs.charset) return TAG_ORDER.charset;
+    if (attrs["http-equiv"]) return TAG_ORDER["http-equiv"];
+    if (attrs.name === "viewport") return TAG_ORDER.viewport;
+  }
+  return TAG_ORDER[tag.tag] ?? 99;
+}
+var HeadManager = class {
+  tags = /* @__PURE__ */ new Map();
+  frozen = false;
+  /**
+   * Add a tag to the head
+   */
+  addTag(tag) {
+    if (this.frozen) {
+      throw new Error("HeadManager is frozen and cannot be modified");
+    }
+    const key = generateTagKey(tag);
+    this.tags.set(key, { ...tag, key });
+    return this;
+  }
+  /**
+   * Add multiple tags
+   */
+  addTags(tags) {
+    for (const tag of tags) {
+      this.addTag(tag);
+    }
+    return this;
+  }
+  /**
+   * Remove a tag by key
+   */
+  removeTag(key) {
+    if (this.frozen) {
+      throw new Error("HeadManager is frozen and cannot be modified");
+    }
+    this.tags.delete(key);
+    return this;
+  }
+  /**
+   * Check if a tag exists
+   */
+  hasTag(key) {
+    return this.tags.has(key);
+  }
+  /**
+   * Get a tag by key
+   */
+  getTag(key) {
+    return this.tags.get(key);
+  }
+  /**
+   * Get all tags
+   */
+  getTags() {
+    return Array.from(this.tags.values());
+  }
+  /**
+   * Clear all tags
+   */
+  clear() {
+    if (this.frozen) {
+      throw new Error("HeadManager is frozen and cannot be modified");
+    }
+    this.tags.clear();
+    return this;
+  }
+  /**
+   * Freeze the manager (no more modifications)
+   */
+  freeze() {
+    this.frozen = true;
+    return this;
+  }
+  /**
+   * Check if frozen
+   */
+  isFrozen() {
+    return this.frozen;
+  }
+  /**
+   * Render all tags to HTML
+   */
+  render() {
+    const tags = this.getTags();
+    tags.sort((a, b) => getTagOrder(a) - getTagOrder(b));
+    const html = tags.map((tag) => renderTag(tag)).join("\n");
+    return { tags, html };
+  }
+};
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function escapeAttr(str) {
+  return str.replace(/"/g, "&quot;");
+}
+function renderTag(tag) {
+  const parts = [`<${tag.tag}`];
+  if (tag.attrs) {
+    for (const [key, value] of Object.entries(tag.attrs)) {
+      if (value === void 0 || value === false) {
+        continue;
+      }
+      if (value === true) {
+        parts.push(` ${key}`);
+      } else if (BOOLEAN_ATTRS.has(key) && value === "") {
+        parts.push(` ${key}`);
+      } else {
+        parts.push(` ${key}="${escapeAttr(String(value))}"`);
+      }
+    }
+  }
+  if (VOID_TAGS.has(tag.tag)) {
+    parts.push(" />");
+  } else if (tag.content !== void 0) {
+    const isJsonLd = tag.tag === "script" && tag.attrs?.type === "application/ld+json";
+    const content = isJsonLd ? tag.content : escapeHtml(tag.content);
+    parts.push(`>${content}</${tag.tag}>`);
+  } else {
+    parts.push(`></${tag.tag}>`);
+  }
+  return parts.join("");
+}
+function renderTags(tags) {
+  return tags.map((tag) => renderTag(tag)).join("\n");
+}
+function createHeadManager() {
+  return new HeadManager();
+}
+var currentHeadContext = null;
+function setHeadContext(context) {
+  currentHeadContext = context;
+}
+function getHeadContext() {
+  return currentHeadContext;
+}
+function clearHeadContext() {
+  currentHeadContext = null;
+}
+function withHeadContext(context, fn) {
+  const previous = currentHeadContext;
+  currentHeadContext = context;
+  try {
+    return fn();
+  } finally {
+    currentHeadContext = previous;
+  }
+}
+
+// src/meta.ts
+function generateTitleTag(title, template, defaultTitle) {
+  let resolvedTitle = title || defaultTitle;
+  if (!resolvedTitle) {
+    return null;
+  }
+  if (template && title) {
+    resolvedTitle = template.replace("%s", title);
+  }
+  return {
+    tag: "title",
+    content: resolvedTitle,
+    key: "title"
+  };
+}
+function generateCharsetTag(charset = "utf-8") {
+  return {
+    tag: "meta",
+    attrs: { charset },
+    key: "meta:charset"
+  };
+}
+function generateViewportTag(viewport) {
+  if (!viewport) {
+    return null;
+  }
+  let content;
+  if (typeof viewport === "string") {
+    content = viewport;
+  } else {
+    const parts = [];
+    if (viewport.width !== void 0) {
+      parts.push(`width=${viewport.width}`);
+    }
+    if (viewport.height !== void 0) {
+      parts.push(`height=${viewport.height}`);
+    }
+    if (viewport.initialScale !== void 0) {
+      parts.push(`initial-scale=${viewport.initialScale}`);
+    }
+    if (viewport.minimumScale !== void 0) {
+      parts.push(`minimum-scale=${viewport.minimumScale}`);
+    }
+    if (viewport.maximumScale !== void 0) {
+      parts.push(`maximum-scale=${viewport.maximumScale}`);
+    }
+    if (viewport.userScalable !== void 0) {
+      parts.push(`user-scalable=${viewport.userScalable ? "yes" : "no"}`);
+    }
+    if (viewport.viewportFit !== void 0) {
+      parts.push(`viewport-fit=${viewport.viewportFit}`);
+    }
+    content = parts.join(", ");
+  }
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "viewport", content },
+    key: "meta:name:viewport"
+  };
+}
+function generateDescriptionTag(description) {
+  if (!description) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "description", content: description },
+    key: "meta:name:description"
+  };
+}
+function generateKeywordsTag(keywords) {
+  if (!keywords) {
+    return null;
+  }
+  const content = Array.isArray(keywords) ? keywords.join(", ") : keywords;
+  return {
+    tag: "meta",
+    attrs: { name: "keywords", content },
+    key: "meta:name:keywords"
+  };
+}
+function generateAuthorTag(author) {
+  if (!author) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "author", content: author },
+    key: "meta:name:author"
+  };
+}
+function generateGeneratorTag(generator) {
+  if (!generator) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "generator", content: generator },
+    key: "meta:name:generator"
+  };
+}
+function generateApplicationNameTag(name) {
+  if (!name) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "application-name", content: name },
+    key: "meta:name:application-name"
+  };
+}
+function generateReferrerTag(referrer) {
+  if (!referrer) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "referrer", content: referrer },
+    key: "meta:name:referrer"
+  };
+}
+function generateThemeColorTags(themeColor) {
+  if (!themeColor) {
+    return [];
+  }
+  if (typeof themeColor === "string") {
+    return [
+      {
+        tag: "meta",
+        attrs: { name: "theme-color", content: themeColor },
+        key: "meta:name:theme-color"
+      }
+    ];
+  }
+  return themeColor.map((tc, index) => ({
+    tag: "meta",
+    attrs: {
+      name: "theme-color",
+      content: tc.color,
+      media: tc.media
+    },
+    key: `meta:name:theme-color:${index}`
+  }));
+}
+function generateColorSchemeTag(colorScheme) {
+  if (!colorScheme) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "color-scheme", content: colorScheme },
+    key: "meta:name:color-scheme"
+  };
+}
+function robotsMetaToString(robots) {
+  const directives = [];
+  if (robots.index === false) {
+    directives.push("noindex");
+  } else if (robots.index === true) {
+    directives.push("index");
+  }
+  if (robots.follow === false) {
+    directives.push("nofollow");
+  } else if (robots.follow === true) {
+    directives.push("follow");
+  }
+  if (robots.noarchive) {
+    directives.push("noarchive");
+  }
+  if (robots.nosnippet) {
+    directives.push("nosnippet");
+  }
+  if (robots.notranslate) {
+    directives.push("notranslate");
+  }
+  if (robots.maxSnippet !== void 0) {
+    directives.push(`max-snippet:${robots.maxSnippet}`);
+  }
+  if (robots.maxImagePreview !== void 0) {
+    directives.push(`max-image-preview:${robots.maxImagePreview}`);
+  }
+  if (robots.maxVideoPreview !== void 0) {
+    directives.push(`max-video-preview:${robots.maxVideoPreview}`);
+  }
+  if (robots.unavailableAfter) {
+    directives.push(`unavailable_after:${robots.unavailableAfter}`);
+  }
+  return directives.join(", ");
+}
+function generateRobotsTag(robots) {
+  if (!robots) {
+    return null;
+  }
+  const content = typeof robots === "string" ? robots : robotsMetaToString(robots);
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "robots", content },
+    key: "meta:name:robots"
+  };
+}
+function generateGooglebotTag(googleBot) {
+  if (!googleBot) {
+    return null;
+  }
+  const content = typeof googleBot === "string" ? googleBot : robotsMetaToString(googleBot);
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: "googlebot", content },
+    key: "meta:name:googlebot"
+  };
+}
+function generateVerificationTags(verification) {
+  if (!verification) {
+    return [];
+  }
+  const tags = [];
+  if (verification.google) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "google-site-verification", content: verification.google },
+      key: "meta:name:google-site-verification"
+    });
+  }
+  if (verification.bing) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "msvalidate.01", content: verification.bing },
+      key: "meta:name:msvalidate.01"
+    });
+  }
+  if (verification.yandex) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "yandex-verification", content: verification.yandex },
+      key: "meta:name:yandex-verification"
+    });
+  }
+  if (verification.pinterest) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "p:domain_verify", content: verification.pinterest },
+      key: "meta:name:p:domain_verify"
+    });
+  }
+  if (verification.norton) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "norton-safeweb-site-verification", content: verification.norton },
+      key: "meta:name:norton-safeweb-site-verification"
+    });
+  }
+  return tags;
+}
+function generateCanonicalTag(canonical) {
+  if (!canonical) {
+    return null;
+  }
+  return {
+    tag: "link",
+    attrs: { rel: "canonical", href: canonical },
+    key: "link:canonical"
+  };
+}
+function generateBaseTag(base) {
+  if (!base) {
+    return null;
+  }
+  return {
+    tag: "base",
+    attrs: { href: base },
+    key: "base"
+  };
+}
+function generateAlternateTags(alternates) {
+  if (!alternates || alternates.length === 0) {
+    return [];
+  }
+  return alternates.map((alt, index) => {
+    const attrs = {
+      rel: "alternate",
+      href: alt.href
+    };
+    if (alt.hreflang) {
+      attrs.hreflang = alt.hreflang;
+    }
+    if (alt.media) {
+      attrs.media = alt.media;
+    }
+    if (alt.type) {
+      attrs.type = alt.type;
+    }
+    if (alt.title) {
+      attrs.title = alt.title;
+    }
+    return {
+      tag: "link",
+      attrs,
+      key: `link:alternate:${alt.hreflang || index}`
+    };
+  });
+}
+function generateManifestTag(manifest) {
+  if (!manifest) {
+    return null;
+  }
+  return {
+    tag: "link",
+    attrs: { rel: "manifest", href: manifest },
+    key: "link:manifest"
+  };
+}
+function generateMetaTags(metadata, options) {
+  const tags = [];
+  tags.push(generateCharsetTag(metadata.charset));
+  const base = generateBaseTag(metadata.base);
+  if (base) tags.push(base);
+  const viewport = generateViewportTag(metadata.viewport);
+  if (viewport) tags.push(viewport);
+  const title = generateTitleTag(
+    metadata.title,
+    metadata.titleTemplate || options?.titleTemplate,
+    metadata.defaultTitle || options?.defaultTitle
+  );
+  if (title) tags.push(title);
+  const description = generateDescriptionTag(metadata.description);
+  if (description) tags.push(description);
+  const keywords = generateKeywordsTag(metadata.keywords);
+  if (keywords) tags.push(keywords);
+  const author = generateAuthorTag(metadata.author);
+  if (author) tags.push(author);
+  const generator = generateGeneratorTag(metadata.generator);
+  if (generator) tags.push(generator);
+  const appName = generateApplicationNameTag(metadata.applicationName);
+  if (appName) tags.push(appName);
+  const referrer = generateReferrerTag(metadata.referrer);
+  if (referrer) tags.push(referrer);
+  tags.push(...generateThemeColorTags(metadata.themeColor));
+  const colorScheme = generateColorSchemeTag(metadata.colorScheme);
+  if (colorScheme) tags.push(colorScheme);
+  const robots = generateRobotsTag(metadata.robots);
+  if (robots) tags.push(robots);
+  const googleBot = generateGooglebotTag(metadata.googleBot);
+  if (googleBot) tags.push(googleBot);
+  tags.push(...generateVerificationTags(metadata.verification));
+  const canonical = generateCanonicalTag(metadata.canonical);
+  if (canonical) tags.push(canonical);
+  tags.push(...generateAlternateTags(metadata.alternates));
+  const manifest = generateManifestTag(metadata.manifest);
+  if (manifest) tags.push(manifest);
+  if (metadata.other) {
+    for (const [name, content] of Object.entries(metadata.other)) {
+      tags.push({
+        tag: "meta",
+        attrs: { name, content },
+        key: `meta:name:${name}`
+      });
+    }
+  }
+  return tags;
+}
+
+// src/opengraph.ts
+function ogTag(property, content) {
+  if (content === void 0 || content === null || content === "") {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `og:${property}`, content: String(content) },
+    key: `meta:property:og:${property}`
+  };
+}
+function articleTag(property, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `article:${property}`, content },
+    key: `meta:property:article:${property}`
+  };
+}
+function profileTag(property, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `profile:${property}`, content },
+    key: `meta:property:profile:${property}`
+  };
+}
+function bookTag(property, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `book:${property}`, content },
+    key: `meta:property:book:${property}`
+  };
+}
+function productTag(property, content) {
+  if (content === void 0 || content === null || content === "") {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { property: `product:${property}`, content: String(content) },
+    key: `meta:property:product:${property}`
+  };
+}
+function generateImageTags(images) {
+  if (!images || images.length === 0) {
+    return [];
+  }
+  const tags = [];
+  images.forEach((image, index) => {
+    const suffix = index > 0 ? `:${index}` : "";
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:image", content: image.url },
+      key: `meta:property:og:image${suffix}`
+    });
+    if (image.secureUrl) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:secure_url", content: image.secureUrl },
+        key: `meta:property:og:image:secure_url${suffix}`
+      });
+    }
+    if (image.type) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:type", content: image.type },
+        key: `meta:property:og:image:type${suffix}`
+      });
+    }
+    if (image.width) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:width", content: String(image.width) },
+        key: `meta:property:og:image:width${suffix}`
+      });
+    }
+    if (image.height) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:height", content: String(image.height) },
+        key: `meta:property:og:image:height${suffix}`
+      });
+    }
+    if (image.alt) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:image:alt", content: image.alt },
+        key: `meta:property:og:image:alt${suffix}`
+      });
+    }
+  });
+  return tags;
+}
+function generateVideoTags(videos) {
+  if (!videos || videos.length === 0) {
+    return [];
+  }
+  const tags = [];
+  videos.forEach((video, index) => {
+    const suffix = index > 0 ? `:${index}` : "";
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:video", content: video.url },
+      key: `meta:property:og:video${suffix}`
+    });
+    if (video.secureUrl) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:secure_url", content: video.secureUrl },
+        key: `meta:property:og:video:secure_url${suffix}`
+      });
+    }
+    if (video.type) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:type", content: video.type },
+        key: `meta:property:og:video:type${suffix}`
+      });
+    }
+    if (video.width) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:width", content: String(video.width) },
+        key: `meta:property:og:video:width${suffix}`
+      });
+    }
+    if (video.height) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:video:height", content: String(video.height) },
+        key: `meta:property:og:video:height${suffix}`
+      });
+    }
+  });
+  return tags;
+}
+function generateAudioTags(audio) {
+  if (!audio || audio.length === 0) {
+    return [];
+  }
+  const tags = [];
+  audio.forEach((a, index) => {
+    const suffix = index > 0 ? `:${index}` : "";
+    tags.push({
+      tag: "meta",
+      attrs: { property: "og:audio", content: a.url },
+      key: `meta:property:og:audio${suffix}`
+    });
+    if (a.secureUrl) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:audio:secure_url", content: a.secureUrl },
+        key: `meta:property:og:audio:secure_url${suffix}`
+      });
+    }
+    if (a.type) {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:audio:type", content: a.type },
+        key: `meta:property:og:audio:type${suffix}`
+      });
+    }
+  });
+  return tags;
+}
+function generateArticleTags(article) {
+  if (!article) {
+    return [];
+  }
+  const tags = [];
+  const publishedTime = articleTag("published_time", article.publishedTime);
+  if (publishedTime) tags.push(publishedTime);
+  const modifiedTime = articleTag("modified_time", article.modifiedTime);
+  if (modifiedTime) tags.push(modifiedTime);
+  const expirationTime = articleTag("expiration_time", article.expirationTime);
+  if (expirationTime) tags.push(expirationTime);
+  const section = articleTag("section", article.section);
+  if (section) tags.push(section);
+  if (article.authors) {
+    article.authors.forEach((author, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "article:author", content: author },
+        key: `meta:property:article:author:${index}`
+      });
+    });
+  }
+  if (article.tags) {
+    article.tags.forEach((tag, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "article:tag", content: tag },
+        key: `meta:property:article:tag:${index}`
+      });
+    });
+  }
+  return tags;
+}
+function generateProfileTags(profile) {
+  if (!profile) {
+    return [];
+  }
+  const tags = [];
+  const firstName = profileTag("first_name", profile.firstName);
+  if (firstName) tags.push(firstName);
+  const lastName = profileTag("last_name", profile.lastName);
+  if (lastName) tags.push(lastName);
+  const username = profileTag("username", profile.username);
+  if (username) tags.push(username);
+  const gender = profileTag("gender", profile.gender);
+  if (gender) tags.push(gender);
+  return tags;
+}
+function generateBookTags(book) {
+  if (!book) {
+    return [];
+  }
+  const tags = [];
+  if (book.authors) {
+    book.authors.forEach((author, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "book:author", content: author },
+        key: `meta:property:book:author:${index}`
+      });
+    });
+  }
+  const isbn = bookTag("isbn", book.isbn);
+  if (isbn) tags.push(isbn);
+  const releaseDate = bookTag("release_date", book.releaseDate);
+  if (releaseDate) tags.push(releaseDate);
+  if (book.tags) {
+    book.tags.forEach((tag, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "book:tag", content: tag },
+        key: `meta:property:book:tag:${index}`
+      });
+    });
+  }
+  return tags;
+}
+function generateProductTags(product) {
+  if (!product) {
+    return [];
+  }
+  const tags = [];
+  const price = productTag("price:amount", product.priceAmount);
+  if (price) tags.push(price);
+  const currency = productTag("price:currency", product.priceCurrency);
+  if (currency) tags.push(currency);
+  const availability = productTag("availability", product.availability);
+  if (availability) tags.push(availability);
+  const condition = productTag("condition", product.condition);
+  if (condition) tags.push(condition);
+  const retailerId = productTag("retailer_item_id", product.retailerItemId);
+  if (retailerId) tags.push(retailerId);
+  return tags;
+}
+function generateOpenGraphTags(og) {
+  if (!og) {
+    return [];
+  }
+  const tags = [];
+  const type = ogTag("type", og.type || "website");
+  if (type) tags.push(type);
+  const title = ogTag("title", og.title);
+  if (title) tags.push(title);
+  const description = ogTag("description", og.description);
+  if (description) tags.push(description);
+  const url = ogTag("url", og.url);
+  if (url) tags.push(url);
+  const siteName = ogTag("site_name", og.siteName);
+  if (siteName) tags.push(siteName);
+  const locale = ogTag("locale", og.locale);
+  if (locale) tags.push(locale);
+  if (og.alternateLocales) {
+    og.alternateLocales.forEach((alternateLocale, index) => {
+      tags.push({
+        tag: "meta",
+        attrs: { property: "og:locale:alternate", content: alternateLocale },
+        key: `meta:property:og:locale:alternate:${index}`
+      });
+    });
+  }
+  const determiner = ogTag("determiner", og.determiner);
+  if (determiner) tags.push(determiner);
+  tags.push(...generateImageTags(og.images));
+  tags.push(...generateVideoTags(og.videos));
+  tags.push(...generateAudioTags(og.audio));
+  tags.push(...generateArticleTags(og.article));
+  tags.push(...generateProfileTags(og.profile));
+  tags.push(...generateBookTags(og.book));
+  tags.push(...generateProductTags(og.product));
+  return tags;
+}
+function generateOpenGraphFallback(title, description, url) {
+  const tags = [];
+  const typeTag = ogTag("type", "website");
+  if (typeTag) tags.push(typeTag);
+  const titleTag = ogTag("title", title);
+  if (titleTag) tags.push(titleTag);
+  const descTag = ogTag("description", description);
+  if (descTag) tags.push(descTag);
+  const urlTag = ogTag("url", url);
+  if (urlTag) tags.push(urlTag);
+  return tags;
+}
+
+// src/twitter.ts
+function twitterTag(name, content) {
+  if (!content) {
+    return null;
+  }
+  return {
+    tag: "meta",
+    attrs: { name: `twitter:${name}`, content },
+    key: `meta:name:twitter:${name}`
+  };
+}
+function normalizeImage(image) {
+  if (!image) {
+    return void 0;
+  }
+  if (typeof image === "string") {
+    return { url: image };
+  }
+  return image;
+}
+function generateTwitterTags(twitter) {
+  if (!twitter) {
+    return [];
+  }
+  const tags = [];
+  const card = twitterTag("card", twitter.card || "summary");
+  if (card) tags.push(card);
+  const title = twitterTag("title", twitter.title);
+  if (title) tags.push(title);
+  const description = twitterTag("description", twitter.description);
+  if (description) tags.push(description);
+  const site = twitterTag("site", twitter.site);
+  if (site) tags.push(site);
+  const siteId = twitterTag("site:id", twitter.siteId);
+  if (siteId) tags.push(siteId);
+  const creator = twitterTag("creator", twitter.creator);
+  if (creator) tags.push(creator);
+  const creatorId = twitterTag("creator:id", twitter.creatorId);
+  if (creatorId) tags.push(creatorId);
+  const image = normalizeImage(twitter.image);
+  if (image) {
+    const imageTag = twitterTag("image", image.url);
+    if (imageTag) tags.push(imageTag);
+    if (image.alt) {
+      const imageAlt = twitterTag("image:alt", image.alt);
+      if (imageAlt) tags.push(imageAlt);
+    }
+  }
+  if (twitter.images && twitter.images.length > 0) {
+    twitter.images.forEach((img, index) => {
+      if (index >= 4) return;
+      const normalizedImg = typeof img === "string" ? { url: img } : img;
+      tags.push({
+        tag: "meta",
+        attrs: { name: `twitter:image${index}`, content: normalizedImg.url },
+        key: `meta:name:twitter:image${index}`
+      });
+      if (normalizedImg.alt) {
+        tags.push({
+          tag: "meta",
+          attrs: { name: `twitter:image${index}:alt`, content: normalizedImg.alt },
+          key: `meta:name:twitter:image${index}:alt`
+        });
+      }
+    });
+  }
+  if (twitter.player) {
+    const playerUrl = twitterTag("player", twitter.player.url);
+    if (playerUrl) tags.push(playerUrl);
+    const playerWidth = twitterTag("player:width", String(twitter.player.width));
+    if (playerWidth) tags.push(playerWidth);
+    const playerHeight = twitterTag("player:height", String(twitter.player.height));
+    if (playerHeight) tags.push(playerHeight);
+    if (twitter.player.stream) {
+      const stream = twitterTag("player:stream", twitter.player.stream);
+      if (stream) tags.push(stream);
+    }
+  }
+  if (twitter.app) {
+    const appName = twitterTag("app:name:iphone", twitter.app.name);
+    if (appName) tags.push(appName);
+    tags.push({
+      tag: "meta",
+      attrs: { name: "twitter:app:name:ipad", content: twitter.app.name },
+      key: "meta:name:twitter:app:name:ipad"
+    });
+    tags.push({
+      tag: "meta",
+      attrs: { name: "twitter:app:name:googleplay", content: twitter.app.name },
+      key: "meta:name:twitter:app:name:googleplay"
+    });
+    if (twitter.app.id.iphone) {
+      const iphoneId = twitterTag("app:id:iphone", twitter.app.id.iphone);
+      if (iphoneId) tags.push(iphoneId);
+    }
+    if (twitter.app.id.ipad) {
+      const ipadId = twitterTag("app:id:ipad", twitter.app.id.ipad);
+      if (ipadId) tags.push(ipadId);
+    }
+    if (twitter.app.id.googleplay) {
+      const googleId = twitterTag("app:id:googleplay", twitter.app.id.googleplay);
+      if (googleId) tags.push(googleId);
+    }
+    if (twitter.app.url) {
+      if (twitter.app.url.iphone) {
+        const iphoneUrl = twitterTag("app:url:iphone", twitter.app.url.iphone);
+        if (iphoneUrl) tags.push(iphoneUrl);
+      }
+      if (twitter.app.url.ipad) {
+        const ipadUrl = twitterTag("app:url:ipad", twitter.app.url.ipad);
+        if (ipadUrl) tags.push(ipadUrl);
+      }
+      if (twitter.app.url.googleplay) {
+        const googleUrl = twitterTag("app:url:googleplay", twitter.app.url.googleplay);
+        if (googleUrl) tags.push(googleUrl);
+      }
+    }
+  }
+  if (twitter.label1) {
+    const label1 = twitterTag("label1", twitter.label1);
+    if (label1) tags.push(label1);
+  }
+  if (twitter.data1) {
+    const data1 = twitterTag("data1", twitter.data1);
+    if (data1) tags.push(data1);
+  }
+  if (twitter.label2) {
+    const label2 = twitterTag("label2", twitter.label2);
+    if (label2) tags.push(label2);
+  }
+  if (twitter.data2) {
+    const data2 = twitterTag("data2", twitter.data2);
+    if (data2) tags.push(data2);
+  }
+  return tags;
+}
+function generateTwitterFallback(title, description, image, cardType = "summary") {
+  const tags = [];
+  const card = twitterTag("card", cardType);
+  if (card) tags.push(card);
+  const titleTag = twitterTag("title", title);
+  if (titleTag) tags.push(titleTag);
+  const descTag = twitterTag("description", description);
+  if (descTag) tags.push(descTag);
+  const imageTag = twitterTag("image", image);
+  if (imageTag) tags.push(imageTag);
+  return tags;
+}
+
+// src/index.ts
+function createSEO(config = {}) {
+  const fullConfig = {
+    baseUrl: config.baseUrl || "",
+    titleTemplate: config.titleTemplate,
+    defaultTitle: config.defaultTitle,
+    defaultOpenGraph: config.defaultOpenGraph,
+    defaultTwitter: config.defaultTwitter,
+    features: {
+      openGraph: config.features?.openGraph ?? true,
+      twitter: config.features?.twitter ?? true,
+      robots: config.features?.robots ?? true
+    }
+  };
+  return {
+    config: fullConfig,
+    render(metadata) {
+      const tags = generateAllTags(metadata, fullConfig);
+      const html = renderTags(tags);
+      return { tags, html };
+    },
+    merge(parent, child) {
+      return mergeMetadata(parent, child);
+    },
+    resolveTitle(metadata) {
+      return resolveTitleWithTemplate(
+        metadata.title,
+        metadata.titleTemplate || fullConfig.titleTemplate,
+        metadata.defaultTitle || fullConfig.defaultTitle
+      );
+    },
+    canonical(path) {
+      if (!fullConfig.baseUrl) {
+        return path;
+      }
+      const base = fullConfig.baseUrl.endsWith("/") ? fullConfig.baseUrl.slice(0, -1) : fullConfig.baseUrl;
+      const normalizedPath = path.startsWith("/") ? path : "/" + path;
+      return base + normalizedPath;
+    }
+  };
+}
+function defineMeta(metadata) {
+  return metadata;
+}
+function mergeMetadata(parent, child) {
+  return {
+    ...parent,
+    ...child,
+    // Merge Open Graph
+    openGraph: child.openGraph ? { ...parent.openGraph, ...child.openGraph } : parent.openGraph,
+    // Merge Twitter
+    twitter: child.twitter ? { ...parent.twitter, ...child.twitter } : parent.twitter,
+    // Merge Apple
+    apple: child.apple ? { ...parent.apple, ...child.apple } : parent.apple,
+    // Merge Icons
+    icons: child.icons ? { ...parent.icons, ...child.icons } : parent.icons,
+    // Merge verification
+    verification: child.verification ? { ...parent.verification, ...child.verification } : parent.verification,
+    // Merge other
+    other: child.other ? { ...parent.other, ...child.other } : parent.other
+  };
+}
+function resolveTitleWithTemplate(title, template, defaultTitle) {
+  const resolvedTitle = title || defaultTitle || "";
+  if (!resolvedTitle) {
+    return "";
+  }
+  if (template && title) {
+    return template.replace("%s", title);
+  }
+  return resolvedTitle;
+}
+function generateAllTags(metadata, config) {
+  const tags = [];
+  tags.push(...generateMetaTags(metadata, {
+    titleTemplate: config.titleTemplate,
+    defaultTitle: config.defaultTitle
+  }));
+  if (config.features?.openGraph !== false) {
+    if (metadata.openGraph) {
+      const og = { ...config.defaultOpenGraph, ...metadata.openGraph };
+      tags.push(...generateOpenGraphTags(og));
+    } else if (metadata.title || metadata.description) {
+      tags.push(...generateOpenGraphFallback(
+        metadata.title,
+        metadata.description,
+        metadata.canonical
+      ));
+    }
+  }
+  if (config.features?.twitter !== false) {
+    if (metadata.twitter) {
+      const twitter = { ...config.defaultTwitter, ...metadata.twitter };
+      tags.push(...generateTwitterTags(twitter));
+    } else if (metadata.title || metadata.description) {
+      const ogImage = metadata.openGraph?.images?.[0];
+      const imageUrl = typeof ogImage === "string" ? ogImage : ogImage?.url;
+      tags.push(...generateTwitterFallback(
+        metadata.title,
+        metadata.description,
+        imageUrl
+      ));
+    }
+  }
+  if (metadata.icons) {
+    tags.push(...generateIconTags(metadata.icons));
+  }
+  if (metadata.apple) {
+    tags.push(...generateAppleTags(metadata.apple));
+  }
+  return tags;
+}
+function generateIconTags(icons) {
+  if (!icons) return [];
+  const tags = [];
+  if (icons.icon) {
+    const iconList = Array.isArray(icons.icon) ? icons.icon : [icons.icon];
+    iconList.forEach((icon, index) => {
+      const iconData = typeof icon === "string" ? { url: icon } : icon;
+      tags.push({
+        tag: "link",
+        attrs: {
+          rel: "icon",
+          href: iconData.url,
+          type: iconData.type,
+          sizes: iconData.sizes
+        },
+        key: `link:icon:${index}`
+      });
+    });
+  }
+  if (icons.shortcut) {
+    const shortcut = typeof icons.shortcut === "string" ? { url: icons.shortcut } : icons.shortcut;
+    tags.push({
+      tag: "link",
+      attrs: {
+        rel: "shortcut icon",
+        href: shortcut.url,
+        type: shortcut.type
+      },
+      key: "link:shortcut-icon"
+    });
+  }
+  if (icons.apple) {
+    const appleList = Array.isArray(icons.apple) ? icons.apple : [icons.apple];
+    appleList.forEach((icon, index) => {
+      const iconData = typeof icon === "string" ? { url: icon } : icon;
+      tags.push({
+        tag: "link",
+        attrs: {
+          rel: "apple-touch-icon",
+          href: iconData.url,
+          sizes: iconData.sizes
+        },
+        key: `link:apple-touch-icon:${index}`
+      });
+    });
+  }
+  return tags;
+}
+function generateAppleTags(apple) {
+  if (!apple) return [];
+  const tags = [];
+  if (apple.mobileWebAppCapable) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "apple-mobile-web-app-capable", content: "yes" },
+      key: "meta:name:apple-mobile-web-app-capable"
+    });
+  }
+  if (apple.statusBarStyle) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "apple-mobile-web-app-status-bar-style", content: apple.statusBarStyle },
+      key: "meta:name:apple-mobile-web-app-status-bar-style"
+    });
+  }
+  if (apple.title) {
+    tags.push({
+      tag: "meta",
+      attrs: { name: "apple-mobile-web-app-title", content: apple.title },
+      key: "meta:name:apple-mobile-web-app-title"
+    });
+  }
+  if (apple.touchIcon) {
+    const touchIcon = typeof apple.touchIcon === "string" ? { url: apple.touchIcon } : apple.touchIcon;
+    tags.push({
+      tag: "link",
+      attrs: {
+        rel: "apple-touch-icon",
+        href: touchIcon.url,
+        sizes: touchIcon.sizes
+      },
+      key: "link:apple-touch-icon-from-apple"
+    });
+  }
+  return tags;
+}
+var VERSION = "0.1.0";
+
+export { HeadManager, VERSION, clearHeadContext, createHeadManager, createSEO, defineMeta, generateAlternateTags, generateAuthorTag, generateCanonicalTag, generateCharsetTag, generateDescriptionTag, generateGooglebotTag, generateKeywordsTag, generateMetaTags, generateOpenGraphFallback, generateOpenGraphTags, generateRobotsTag, generateThemeColorTags, generateTitleTag, generateTwitterFallback, generateTwitterTags, generateVerificationTags, generateViewportTag, getHeadContext, mergeMetadata, renderTag, renderTags, setHeadContext, withHeadContext };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map