@tradik/xslt-processor 1.1.1 → 1.3.0

package/src/xslt/serializer/htmlEntities.js

@@ -0,0 +1,77 @@
+/**
+ * HTML 4.01 Character Entity References
+ *
+ * The html output method writes a character the output encoding cannot
+ * represent as an entity reference when HTML 4.01 defines one (`€` in
+ * ISO-8859-1 output) and as a numeric character reference otherwise, as
+ * libxslt does (XSLT 1.0 section 16.2).
+ *
+ * @module xslt/serializer/htmlEntities
+ */
+
+import { characterReference } from "./encoding.js";
+
+/** Entity names of U+00A0 to U+00FF, in code point order. */
+const LATIN1_NAMES =
+  "nbsp iexcl cent pound curren yen brvbar sect uml copy ordf laquo not shy " +
+  "reg macr deg plusmn sup2 sup3 acute micro para middot cedil sup1 ordm " +
+  "raquo frac14 frac12 frac34 iquest Agrave Aacute Acirc Atilde Auml Aring " +
+  "AElig Ccedil Egrave Eacute Ecirc Euml Igrave Iacute Icirc Iuml ETH Ntilde " +
+  "Ograve Oacute Ocirc Otilde Ouml times Oslash Ugrave Uacute Ucirc Uuml " +
+  "Yacute THORN szlig agrave aacute acirc atilde auml aring aelig ccedil " +
+  "egrave eacute ecirc euml igrave iacute icirc iuml eth ntilde ograve " +
+  "oacute ocirc otilde ouml divide oslash ugrave uacute ucirc uuml yacute " +
+  "thorn yuml";
+
+/** The other entities, as `name codePoint` pairs. */
+const OTHER_ENTITIES =
+  "OElig 338 oelig 339 Scaron 352 scaron 353 Yuml 376 fnof 402 circ 710 " +
+  "tilde 732 Alpha 913 Beta 914 Gamma 915 Delta 916 Epsilon 917 Zeta 918 " +
+  "Eta 919 Theta 920 Iota 921 Kappa 922 Lambda 923 Mu 924 Nu 925 Xi 926 " +
+  "Omicron 927 Pi 928 Rho 929 Sigma 931 Tau 932 Upsilon 933 Phi 934 Chi 935 " +
+  "Psi 936 Omega 937 alpha 945 beta 946 gamma 947 delta 948 epsilon 949 " +
+  "zeta 950 eta 951 theta 952 iota 953 kappa 954 lambda 955 mu 956 nu 957 " +
+  "xi 958 omicron 959 pi 960 rho 961 sigmaf 962 sigma 963 tau 964 " +
+  "upsilon 965 phi 966 chi 967 psi 968 omega 969 thetasym 977 upsih 978 " +
+  "piv 982 ensp 8194 emsp 8195 thinsp 8201 zwnj 8204 zwj 8205 lrm 8206 " +
+  "rlm 8207 ndash 8211 mdash 8212 lsquo 8216 rsquo 8217 sbquo 8218 " +
+  "ldquo 8220 rdquo 8221 bdquo 8222 dagger 8224 Dagger 8225 bull 8226 " +
+  "hellip 8230 permil 8240 prime 8242 Prime 8243 lsaquo 8249 rsaquo 8250 " +
+  "oline 8254 frasl 8260 euro 8364 image 8465 weierp 8472 real 8476 " +
+  "trade 8482 alefsym 8501 larr 8592 uarr 8593 rarr 8594 darr 8595 " +
+  "harr 8596 crarr 8629 lArr 8656 uArr 8657 rArr 8658 dArr 8659 hArr 8660 " +
+  "forall 8704 part 8706 exist 8707 empty 8709 nabla 8711 isin 8712 " +
+  "notin 8713 ni 8715 prod 8719 sum 8721 minus 8722 lowast 8727 radic 8730 " +
+  "prop 8733 infin 8734 ang 8736 and 8743 or 8744 cap 8745 cup 8746 " +
+  "int 8747 there4 8756 sim 8764 cong 8773 asymp 8776 ne 8800 equiv 8801 " +
+  "le 8804 ge 8805 sub 8834 sup 8835 nsub 8836 sube 8838 supe 8839 " +
+  "oplus 8853 otimes 8855 perp 8869 sdot 8901 lceil 8968 rceil 8969 " +
+  "lfloor 8970 rfloor 8971 lang 9001 rang 9002 loz 9674 spades 9824 " +
+  "clubs 9827 hearts 9829 diams 9830";
+
+/**
+ * Entity name by code point.
+ * @type {Map<number, string>}
+ */
+const ENTITY_NAMES = new Map(
+  LATIN1_NAMES.split(" ").map((name, index) => [0xa0 + index, name]),
+);
+const otherParts = OTHER_ENTITIES.split(" ");
+for (let i = 0; i < otherParts.length; i += 2) {
+  ENTITY_NAMES.set(Number(otherParts[i + 1]), otherParts[i]);
+}
+
+/**
+ * Reference to a character the output encoding cannot represent: the HTML
+ * 4.01 entity reference when there is one, a numeric reference otherwise.
+ *
+ * @param {number} codePoint - The code point
+ * @returns {string} `&name;` or `&#N;`
+ *
+ * @example
+ * htmlCharacterReference(0x20ac); // "&euro;"
+ */
+export function htmlCharacterReference(codePoint) {
+  const name = ENTITY_NAMES.get(codePoint);
+  return name ? `&${name};` : characterReference(codePoint);
+}

package/src/xslt/serializer/htmlSerializer.js

@@ -2,19 +2,79 @@
  * HTML Output Serializer
  *
  * Implements the `html` output method of XSLT 1.0 section 16.2 on top of the
- * XML writer: no XML declaration, no namespace declarations, void elements
- * without a closing slash, minimized boolean attributes and unescaped
- * script/style content.
+ * XML writer: no XML declaration, void elements without a closing slash,
+ * minimized boolean attributes and unescaped script/style content. Like
+ * libxml2 (and so Chrome), namespace declarations of the result tree are
+ * written, and an element in a namespace other than XHTML is not an HTML
+ * element (`<s:img></s:img>`). Unlike libxml2, XHTML elements keep the HTML
+ * rules, so `<br/>` in the XHTML namespace is not written as `<br></br>`
+ * (which HTML parsers read as two line breaks).
  */
 
 import {
+  NODE_TYPE,
   PRESERVE_SPACE_ELEMENTS,
   RAW_TEXT_ELEMENTS,
   TEXT_MODE,
+  URI_ATTRIBUTES,
+  URI_ATTRIBUTES_OF_A,
+  XHTML_NAMESPACE,
 } from "./constants.js";
-import { escapeHtmlAttribute, escapeHtmlText } from "./escape.js";
+import {
+  escapeHtmlAttribute,
+  escapeHtmlText,
+  escapeUriAttribute,
+} from "./escape.js";
+import { htmlCharacterReference } from "./htmlEntities.js";
+import { htmlDoctypeMarkup } from "./htmlDoctype.js";
 import { XmlWriter } from "./xmlSerializer.js";
 
+/**
+ * Whether a `head` element already declares the content type or character
+ * set: a `meta` child with `http-equiv="Content-Type"` or a `charset`
+ * attribute (names and the http-equiv value compared case-insensitively).
+ *
+ * @param {Element} head - The head element
+ * @returns {boolean} True when no meta element has to be added
+ */
+function hasContentTypeMeta(head) {
+  for (const child of head.childNodes) {
+    if (
+      child.nodeType !== NODE_TYPE.ELEMENT ||
+      child.localName.toLowerCase() !== "meta"
+    ) {
+      continue;
+    }
+    for (const { name, value } of child.attributes) {
+      const lower = name.toLowerCase();
+      if (lower === "charset") return true;
+      if (lower === "http-equiv" && value.toLowerCase() === "content-type") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Whether the html output method %-escapes an attribute, as libxml2 does:
+ * `href`, `action` and `src`, and `name` on `a` (names compared
+ * case-insensitively), when neither the attribute nor its element is in a
+ * namespace.
+ *
+ * @param {Attr} attribute - Attribute being written
+ * @returns {boolean} True for URI attributes
+ */
+function isUriAttribute(attribute) {
+  const element = attribute.ownerElement;
+  if (attribute.namespaceURI || element.namespaceURI) return false;
+  const name = attribute.localName.toLowerCase();
+  return (
+    URI_ATTRIBUTES.has(name) ||
+    (URI_ATTRIBUTES_OF_A.has(name) && element.localName.toLowerCase() === "a")
+  );
+}
+
 export class HtmlWriter extends XmlWriter {
   /**
    * The html output method never writes an XML declaration.
@@ -25,10 +85,18 @@ export class HtmlWriter extends XmlWriter {
   }
 
   /**
-   * The html output method never writes namespace declarations.
+   * No line breaks are added between the top-level nodes of html output.
+   * @returns {boolean} Always false
+   */
+  get topLevelLineBreaks() {
+    return false;
+  }
+
+  /**
+   * HTML output is never an XHTML document.
    * @returns {boolean} Always false
    */
-  get emitsNamespaces() {
+  get isXhtmlDocument() {
     return false;
   }
 
@@ -49,25 +117,17 @@ export class HtmlWriter extends XmlWriter {
   }
 
   /**
-   * Build the document type declaration for the html output method.
+   * Build the document type declaration for the html output method (see
+   * htmlDoctype.js: declared identifiers, else derived from `version`).
    *
    * @param {Element|null} rootElement - Result document element
    * @returns {string} Doctype markup, or an empty string when not applicable
    */
   doctypeMarkup(rootElement) {
-    const { doctypePublic, doctypeSystem } = this.settings;
-    if (!doctypePublic && !doctypeSystem) {
-      return "";
-    }
-
-    const name = rootElement ? rootElement.nodeName : "html";
-    if (doctypePublic && doctypeSystem) {
-      return `<!DOCTYPE ${name} PUBLIC "${doctypePublic}" "${doctypeSystem}">`;
-    }
-    if (doctypePublic) {
-      return `<!DOCTYPE ${name} PUBLIC "${doctypePublic}">`;
-    }
-    return `<!DOCTYPE ${name} SYSTEM "${doctypeSystem}">`;
+    return htmlDoctypeMarkup(
+      this.settings,
+      rootElement ? rootElement.nodeName : "html",
+    );
   }
 
   /**
@@ -102,11 +162,14 @@ export class HtmlWriter extends XmlWriter {
    * @returns {string} Markup terminating the start tag
    */
   emptyElementMarkup(element, name) {
-    return this.isVoidElement(element) ? ">" : `></${name}>`;
+    const namespace = element.namespaceURI;
+    const isHtml = !namespace || namespace === XHTML_NAMESPACE;
+    return isHtml && this.isVoidElement(element) ? ">" : `></${name}>`;
   }
 
   /**
-   * Boolean attributes are minimized to their name alone.
+   * Boolean attributes are minimized to their name alone; URI attributes
+   * are %-escaped (see isUriAttribute).
    *
    * @param {Attr} attribute - Attribute to write
    * @returns {string} Attribute markup, starting with a space
@@ -116,7 +179,31 @@ export class HtmlWriter extends XmlWriter {
     if (String(value).toLowerCase() === name.toLowerCase()) {
       return ` ${name}`;
     }
-    return ` ${name}="${this.escapeAttribute(value)}"`;
+    const written = isUriAttribute(attribute)
+      ? escapeUriAttribute(value)
+      : value;
+    return ` ${name}="${this.escapeAttribute(written)}"`;
+  }
+
+  /**
+   * The content type `meta` element libxslt (and so Chrome) writes as the
+   * first child of an HTML `head` element that does not already have one
+   * (XSLT 1.0 section 16.2 recommends it). Firefox does not add it.
+   *
+   * @param {Element} element - Element being written
+   * @returns {string} The meta element markup, or an empty string
+   */
+  leadingChildMarkup(element) {
+    // libxml2 finds the head element by name, whatever its namespace
+    if (
+      element.localName.toLowerCase() !== "head" ||
+      hasContentTypeMeta(element)
+    ) {
+      return "";
+    }
+    const { mediaType, encoding } = this.settings;
+    const content = `${mediaType || "text/html"}; charset=${encoding}`;
+    return `<meta http-equiv="Content-Type" content="${this.escapeAttribute(content)}">`;
   }
 
   /**
@@ -126,7 +213,7 @@ export class HtmlWriter extends XmlWriter {
    * @returns {string} Escaped text
    */
   escapeText(value) {
-    return escapeHtmlText(value);
+    return this.encodeReferences(escapeHtmlText(value));
   }
 
   /**
@@ -136,6 +223,17 @@ export class HtmlWriter extends XmlWriter {
    * @returns {string} Escaped value
    */
   escapeAttribute(value) {
-    return escapeHtmlAttribute(value);
+    return this.encodeReferences(escapeHtmlAttribute(value));
+  }
+
+  /**
+   * Reference to a character the output encoding cannot represent: an HTML
+   * entity reference where HTML 4.01 has one, as libxslt writes.
+   *
+   * @param {number} codePoint - The code point
+   * @returns {string} An entity or numeric character reference
+   */
+  characterReference(codePoint) {
+    return htmlCharacterReference(codePoint);
   }
 }

package/src/xslt/serializer/settings.js

@@ -18,19 +18,63 @@ function isYes(value) {
 }
 
 /**
- * Convert a `cdata-section-elements` value into a lookup set.
+ * Lookup key of an expanded name, in Clark notation: `{uri}local`, or the
+ * bare local name for a name in no namespace.
  *
- * @param {string|string[]|undefined} value - Whitespace separated names or array
- * @returns {Set<string>} Element names requiring CDATA sections
+ * @param {string|null|undefined} namespaceUri - Namespace URI, empty for none
+ * @param {string} localName - Local name
+ * @returns {string} The key
+ *
+ * @example
+ * expandedNameKey("urn:p", "c"); // "{urn:p}c"
+ * expandedNameKey(null, "c");    // "c"
  */
-function toNameSet(value) {
-  if (Array.isArray(value)) {
-    return new Set(value);
-  }
-  if (typeof value === "string") {
-    return new Set(value.split(/\s+/).filter(Boolean));
+export function expandedNameKey(namespaceUri, localName) {
+  return namespaceUri ? `{${namespaceUri}}${localName}` : localName;
+}
+
+/**
+ * @typedef {Object} CdataNames
+ * @property {Set<string>} expanded - Expanded name keys ({@link expandedNameKey})
+ * @property {Array<{prefix: string, localName: string}>} qnames - Prefixed
+ *   names whose prefix is resolved against the result element
+ */
+
+/**
+ * Normalize a `cdata-section-elements` value.
+ *
+ * Entries resolved by the engine, `{namespaceUri, localName}`, are exact
+ * expanded names. A plain string QName carries no namespace bindings: an
+ * unprefixed name is taken to be in no namespace, and a prefixed one is kept
+ * aside to be resolved with the in-scope namespaces of each result element.
+ *
+ * @param {string|Array<string|{namespaceUri: ?string, localName: string}>|undefined} value -
+ *   Whitespace separated QNames, or an array of QNames and expanded names
+ * @returns {CdataNames} The names
+ */
+function toCdataNames(value) {
+  const entries =
+    typeof value === "string" ? value.split(/\s+/) : [value ?? []].flat();
+  const expanded = new Set();
+  const qnames = [];
+
+  for (const entry of entries) {
+    if (typeof entry !== "string") {
+      expanded.add(expandedNameKey(entry.namespaceUri, entry.localName));
+      continue;
+    }
+    const colon = entry.indexOf(":");
+    if (colon === -1) {
+      if (entry) expanded.add(entry);
+    } else {
+      qnames.push({
+        prefix: entry.slice(0, colon),
+        localName: entry.slice(colon + 1),
+      });
+    }
   }
-  return new Set();
+
+  return { expanded, qnames };
 }
 
 /**
@@ -54,11 +98,35 @@ export function findRootElement(node) {
   return null;
 }
 
+/** Text made only of XML whitespace (#x20 #x9 #xD #xA). */
+const XML_WHITESPACE_ONLY = /^[ \t\r\n]*$/;
+
+/**
+ * Whether text other than XML whitespace precedes the first element child.
+ *
+ * @param {Node} node - Document or fragment that has an element child
+ * @returns {boolean} True when a non-whitespace text node comes first
+ */
+function hasLeadingText(node) {
+  for (
+    let child = node.firstChild;
+    child.nodeType !== NODE_TYPE.ELEMENT;
+    child = child.nextSibling
+  ) {
+    const isText =
+      child.nodeType === NODE_TYPE.TEXT ||
+      child.nodeType === NODE_TYPE.CDATA_SECTION;
+    if (isText && !XML_WHITESPACE_ONLY.test(child.nodeValue)) return true;
+  }
+  return false;
+}
+
 /**
  * Derive the default output method from the result tree.
  *
  * XSLT 1.0 section 16 defaults to `html` when the document element is `html`
- * in no namespace, and to `xml` otherwise.
+ * in no namespace and no text other than whitespace precedes it, and to
+ * `xml` otherwise.
  *
  * @param {Node|null} node - Result tree root
  * @returns {string} Either "html" or "xml"
@@ -66,7 +134,10 @@ export function findRootElement(node) {
 export function detectOutputMethod(node) {
   const root = findRootElement(node);
   const isHtmlRoot =
-    root && !root.namespaceURI && root.localName.toLowerCase() === "html";
+    root &&
+    !root.namespaceURI &&
+    root.localName.toLowerCase() === "html" &&
+    (root === node || !hasLeadingText(node));
   return isHtmlRoot ? "html" : "xml";
 }
 
@@ -87,6 +158,7 @@ export function resolveOutputSettings(outputSettings, node) {
     declared && declared !== "auto"
       ? declared.toLowerCase()
       : detectOutputMethod(node);
+  const cdata = toCdataNames(raw.cdataSectionElements);
 
   return {
     method,
@@ -94,10 +166,14 @@ export function resolveOutputSettings(outputSettings, node) {
     encoding: raw.encoding || "UTF-8",
     standalone: raw.standalone || null,
     indent: isYes(raw.indent),
+    // libxslt writes a line break after a top-level comment followed by
+    // another node unless indent="no" is declared (xsltSaveResultTo)
+    topLevelLineBreaks: raw.indent == null || isYes(raw.indent),
     omitXmlDeclaration: isYes(raw.omitXmlDeclaration),
     doctypePublic: raw.doctypePublic || null,
     doctypeSystem: raw.doctypeSystem || null,
     mediaType: raw.mediaType || null,
-    cdataSectionElements: toNameSet(raw.cdataSectionElements),
+    cdataSectionElements: cdata.expanded,
+    cdataSectionQNames: cdata.qnames,
   };
 }

package/src/xslt/serializer/textSerializer.js

@@ -6,24 +6,72 @@
  */
 
 import { NODE_TYPE } from "./constants.js";
+import { ChunkBuffer } from "./chunks.js";
 
 /**
- * Serialize a result tree with the text output method.
+ * Whether a node is character data (text or CDATA section).
  *
- * @param {Node} node - Document, fragment, element or character data node
- * @returns {string} Concatenated character data
+ * @param {Node} node - Node to test
+ * @returns {boolean} True for character data
  */
-export function serializeText(node) {
-  if (
+function isCharacterData(node) {
+  return (
     node.nodeType === NODE_TYPE.TEXT ||
     node.nodeType === NODE_TYPE.CDATA_SECTION
-  ) {
-    return node.nodeValue || "";
+  );
+}
+
+/**
+ * The character data nodes under `root` in document order, found without
+ * recursion (firstChild/nextSibling walk), so deep trees cannot overflow the
+ * stack.
+ *
+ * @param {Node} root - Document, fragment, element or character data node
+ * @yields {Node} Character data nodes
+ * @returns {Generator<Node, void, void>} The nodes
+ */
+function* characterDataNodes(root) {
+  let node = root;
+  while (node) {
+    if (isCharacterData(node)) yield node;
+    if (node.firstChild) {
+      node = node.firstChild;
+      continue;
+    }
+    while (node !== root && !node.nextSibling) node = node.parentNode;
+    node = node === root ? null : node.nextSibling;
   }
+}
 
-  let text = "";
-  for (const child of node.childNodes || []) {
-    text += serializeText(child);
+/**
+ * Serialize a result tree with the text output method, in chunks.
+ *
+ * @param {Node} node - Document, fragment, element or character data node
+ * @param {number} [chunkSize] - Chunk size in UTF-16 code units; Infinity
+ *   yields the whole text as one chunk
+ * @yields {string} Non-empty chunks of at most `chunkSize` code units
+ * @returns {Generator<string, void, void>} The chunks, in order
+ *
+ * @example
+ * [...textChunks(fragment, 16384)].join("");
+ */
+export function* textChunks(node, chunkSize) {
+  const buffer = new ChunkBuffer(chunkSize);
+  for (const text of characterDataNodes(node)) {
+    buffer.write(text.nodeValue || "");
+    if (buffer.full) yield* buffer.take();
   }
+  yield* buffer.take(true);
+}
+
+/**
+ * Serialize a result tree with the text output method.
+ *
+ * @param {Node} node - Document, fragment, element or character data node
+ * @returns {string} Concatenated character data
+ */
+export function serializeText(node) {
+  let text = "";
+  for (const chunk of textChunks(node, Infinity)) text += chunk;
   return text;
 }

package/src/xslt/serializer/xhtmlDocument.js

@@ -0,0 +1,103 @@
+/**
+ * XHTML 1.0 documents in xml output, as libxml2 (and so Chrome's
+ * XSLTProcessor) writes them.
+ *
+ * When the xml output declares one of the XHTML 1.0 document types
+ * (`doctype-public` or `doctype-system` of XHTML 1.0 Strict, Transitional
+ * or Frameset), libxml2 switches to its XHTML serializer, which follows the
+ * compatibility guidelines of XHTML 1.0 appendix C:
+ * - an `html` element in no namespace without namespace declarations gets
+ *   `xmlns="http://www.w3.org/1999/xhtml"` (A.3.1.1);
+ * - a `head` child of the `html` document element without a Content-Type
+ *   `meta` gets `<meta http-equiv="Content-Type" content="text/html;
+ *   charset=..." />` as its first child (C.9);
+ * - elements in no namespace follow the empty element rules of XHTML
+ *   elements (C.2, C.3).
+ *
+ * @module xslt/serializer/xhtmlDocument
+ */
+
+import { NODE_TYPE, XHTML_NAMESPACE } from "./constants.js";
+
+/** Public identifiers of the XHTML 1.0 document types. */
+const XHTML1_PUBLIC_IDS = new Set([
+  "-//W3C//DTD XHTML 1.0 Strict//EN",
+  "-//W3C//DTD XHTML 1.0 Transitional//EN",
+  "-//W3C//DTD XHTML 1.0 Frameset//EN",
+]);
+
+/** System identifiers of the XHTML 1.0 document types. */
+const XHTML1_SYSTEM_IDS = new Set([
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd",
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd",
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd",
+]);
+
+/**
+ * Whether the output settings declare an XHTML 1.0 document type.
+ *
+ * @param {{doctypePublic?: string|null, doctypeSystem?: string|null}} settings -
+ *   Normalized output settings
+ * @returns {boolean} True for the XHTML 1.0 public or system identifiers
+ *
+ * @example
+ * isXhtml1Doctype({ doctypePublic: "-//W3C//DTD XHTML 1.0 Strict//EN" }); // true
+ */
+export function isXhtml1Doctype(settings) {
+  return (
+    XHTML1_PUBLIC_IDS.has(settings.doctypePublic) ||
+    XHTML1_SYSTEM_IDS.has(settings.doctypeSystem)
+  );
+}
+
+/**
+ * The namespace declaration libxml2 adds to an `html` element in no
+ * namespace that declares no namespace itself.
+ *
+ * @param {Element} element - Element being written
+ * @param {Array<object>} declarations - Declarations written on it
+ * @returns {string} ` xmlns="http://www.w3.org/1999/xhtml"`, or ""
+ */
+export function xhtmlRootNamespace(element, declarations) {
+  const needed =
+    element.localName === "html" &&
+    !element.namespaceURI &&
+    declarations.length === 0;
+  return needed ? ` xmlns="${XHTML_NAMESPACE}"` : "";
+}
+
+/**
+ * Whether a `head` element has a `meta` child with
+ * `http-equiv="Content-Type"` (compared case-insensitively).
+ *
+ * @param {Element} head - The head element
+ * @returns {boolean} True when libxml2 adds no meta element
+ */
+function hasContentTypeMeta(head) {
+  for (const child of head.childNodes) {
+    if (child.nodeType !== NODE_TYPE.ELEMENT || child.localName !== "meta") {
+      continue;
+    }
+    const value = child.getAttribute("http-equiv");
+    if (value?.toLowerCase() === "content-type") return true;
+  }
+  return false;
+}
+
+/**
+ * The Content-Type `meta` element libxml2 writes as the first child of the
+ * `head` child of an `html` document element.
+ *
+ * @param {Element} element - Element being written
+ * @param {string} encoding - The output encoding, as declared
+ * @returns {string} The meta element markup, or ""
+ */
+export function xhtmlHeadMeta(element, encoding) {
+  const parent = element.parentNode;
+  const isHead =
+    element.localName === "head" &&
+    parent?.localName === "html" &&
+    parent.parentNode?.nodeType !== NODE_TYPE.ELEMENT;
+  if (!isHead || hasContentTypeMeta(element)) return "";
+  return `<meta http-equiv="Content-Type" content="text/html; charset=${encoding}" />`;
+}