@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/serializer/settings.js

@@ -0,0 +1,179 @@
+/**
+ * Output Settings Resolution
+ *
+ * Normalizes the `xsl:output` settings collected by the XSLT engine into the
+ * shape the serializers consume (XSLT 1.0 section 16).
+ */
+
+import { NODE_TYPE } from "./constants.js";
+
+/**
+ * Test whether an `xsl:output` yes/no attribute is enabled.
+ *
+ * @param {string|boolean|undefined} value - Raw attribute value
+ * @returns {boolean} True when the value means "yes"
+ */
+function isYes(value) {
+  return value === true || String(value).toLowerCase() === "yes";
+}
+
+/**
+ * Lookup key of an expanded name, in Clark notation: `{uri}local`, or the
+ * bare local name for a name in no namespace.
+ *
+ * @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"
+ */
+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 { expanded, qnames };
+}
+
+/**
+ * Find the first element node of a result tree.
+ *
+ * @param {Node|null} node - Document, fragment or element
+ * @returns {Element|null} The result document element, when there is one
+ */
+export function findRootElement(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.nodeType === NODE_TYPE.ELEMENT) {
+    return node;
+  }
+  for (const child of node.childNodes || []) {
+    if (child.nodeType === NODE_TYPE.ELEMENT) {
+      return child;
+    }
+  }
+  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 no text other than whitespace precedes it, and to
+ * `xml` otherwise.
+ *
+ * @param {Node|null} node - Result tree root
+ * @returns {string} Either "html" or "xml"
+ */
+export function detectOutputMethod(node) {
+  const root = findRootElement(node);
+  const isHtmlRoot =
+    root &&
+    !root.namespaceURI &&
+    root.localName.toLowerCase() === "html" &&
+    (root === node || !hasLeadingText(node));
+  return isHtmlRoot ? "html" : "xml";
+}
+
+/**
+ * Normalize an `xsl:output` settings object.
+ *
+ * An absent, empty or "auto" method triggers the XSLT 1.0 default method
+ * detection based on the result tree.
+ *
+ * @param {object|null} outputSettings - Raw settings from the XSLT engine
+ * @param {Node|null} node - Result tree used for default method detection
+ * @returns {object} Normalized settings consumed by the serializers
+ */
+export function resolveOutputSettings(outputSettings, node) {
+  const raw = outputSettings || {};
+  const declared = typeof raw.method === "string" ? raw.method.trim() : "";
+  const method =
+    declared && declared !== "auto"
+      ? declared.toLowerCase()
+      : detectOutputMethod(node);
+  const cdata = toCdataNames(raw.cdataSectionElements);
+
+  return {
+    method,
+    version: raw.version || "1.0",
+    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: cdata.expanded,
+    cdataSectionQNames: cdata.qnames,
+  };
+}

package/src/xslt/serializer/textSerializer.js

@@ -0,0 +1,77 @@
+/**
+ * Text Output Serializer
+ *
+ * Implements the `text` output method of XSLT 1.0 section 16.3: the result is
+ * the concatenation of every descendant character data node, unescaped.
+ */
+
+import { NODE_TYPE } from "./constants.js";
+import { ChunkBuffer } from "./chunks.js";
+
+/**
+ * Whether a node is character data (text or CDATA section).
+ *
+ * @param {Node} node - Node to test
+ * @returns {boolean} True for character data
+ */
+function isCharacterData(node) {
+  return (
+    node.nodeType === NODE_TYPE.TEXT ||
+    node.nodeType === NODE_TYPE.CDATA_SECTION
+  );
+}
+
+/**
+ * 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;
+  }
+}
+
+/**
+ * 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}" />`;
+}

package/src/xslt/serializer/xmlSerializer.js

@@ -0,0 +1,227 @@
+/**
+ * XML Output Serializer
+ *
+ * Implements the `xml` output method of XSLT 1.0 section 16.1 and, with the
+ * `xhtml` option, the XHTML empty element convention. It is also the base of
+ * the html serializer, which overrides the dialect hooks defined here.
+ */
+
+import { TEXT_MODE, VOID_ELEMENTS, XHTML_NAMESPACE } from "./constants.js";
+import { escapeXmlAttribute, escapeXmlText } from "./escape.js";
+import { characterReference } from "./encoding.js";
+import { BaseWriter } from "./baseWriter.js";
+import { expandedNameKey } from "./settings.js";
+import {
+  isXhtml1Doctype,
+  xhtmlHeadMeta,
+  xhtmlRootNamespace,
+} from "./xhtmlDocument.js";
+
+export class XmlWriter extends BaseWriter {
+  /**
+   * Whether an XML declaration has to be written.
+   * @returns {boolean} True when the declaration is not omitted
+   */
+  get emitsXmlDeclaration() {
+    return !this.settings.omitXmlDeclaration;
+  }
+
+  /**
+   * Whether the output is an XHTML 1.0 document (see xhtmlDocument.js).
+   * @returns {boolean} True when an XHTML 1.0 doctype is declared
+   */
+  get isXhtmlDocument() {
+    return isXhtml1Doctype(this.settings);
+  }
+
+  /**
+   * Namespace declarations of an element, plus the XHTML namespace libxml2
+   * adds to an `html` element in no namespace of an XHTML 1.0 document.
+   *
+   * @param {Array<{prefix: string, uri: string}>} declarations - Declarations
+   * @param {Element} element - The element they are written on
+   * @returns {string} Attribute markup, starting with a space when non-empty
+   */
+  namespaceMarkup(declarations, element) {
+    const markup = super.namespaceMarkup(declarations);
+    return this.isXhtmlDocument
+      ? markup + xhtmlRootNamespace(element, declarations)
+      : markup;
+  }
+
+  /**
+   * Terminator of a processing instruction.
+   * @returns {string} The XML processing instruction terminator
+   */
+  get piTerminator() {
+    return "?>";
+  }
+
+  /**
+   * How a source CDATA section node has to be written.
+   * @returns {string} A {@link TEXT_MODE} value
+   */
+  get cdataNodeMode() {
+    return TEXT_MODE.CDATA;
+  }
+
+  /**
+   * Whether a line break follows a top-level comment that another node
+   * follows, as libxslt (xsltSaveResultTo) writes unless `indent="no"` is
+   * declared.
+   * @returns {boolean} True for xml output without `indent="no"`
+   */
+  get topLevelLineBreaks() {
+    return this.settings.topLevelLineBreaks === true;
+  }
+
+  /**
+   * Build the document type declaration for the xml output method.
+   *
+   * @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 (!rootElement || !doctypeSystem) {
+      return "";
+    }
+
+    const name = rootElement.nodeName;
+    return doctypePublic
+      ? `<!DOCTYPE ${name} PUBLIC "${doctypePublic}" "${doctypeSystem}">`
+      : `<!DOCTYPE ${name} SYSTEM "${doctypeSystem}">`;
+  }
+
+  /**
+   * Determine how the character data children of an element are written:
+   * as CDATA sections when the expanded name of the element is listed in
+   * `cdata-section-elements` (XSLT 1.0 section 16.1).
+   *
+   * @param {Element} element - Parent element
+   * @returns {string} A {@link TEXT_MODE} value
+   */
+  childTextMode(element) {
+    return this.isCdataSectionElement(element)
+      ? TEXT_MODE.CDATA
+      : TEXT_MODE.ESCAPE;
+  }
+
+  /**
+   * Whether an element is listed in `cdata-section-elements`. Prefixed names
+   * the engine passed unresolved are resolved with the element's in-scope
+   * namespaces.
+   *
+   * @param {Element} element - Element to test
+   * @returns {boolean} True when its text is written as CDATA sections
+   */
+  isCdataSectionElement(element) {
+    const { cdataSectionElements, cdataSectionQNames = [] } = this.settings;
+    const namespaceUri = element.namespaceURI || null;
+    const { localName } = element;
+    if (cdataSectionElements.has(expandedNameKey(namespaceUri, localName))) {
+      return true;
+    }
+    return cdataSectionQNames.some(
+      (qname) =>
+        qname.localName === localName &&
+        namespaceUri !== null &&
+        element.lookupNamespaceURI(qname.prefix) === namespaceUri,
+    );
+  }
+
+  /**
+   * Markup the serializer itself adds as the first child of an element: the
+   * Content-Type meta of an XHTML 1.0 document head, as libxml2 writes it.
+   *
+   * @param {Element} element - Element being written
+   * @returns {string} The meta element, or an empty string
+   */
+  leadingChildMarkup(element) {
+    return this.isXhtmlDocument
+      ? xhtmlHeadMeta(element, this.settings.encoding)
+      : "";
+  }
+
+  /**
+   * Whether the content of an element may be re-indented.
+   *
+   * @param {Element} _element - Element being inspected
+   * @returns {boolean} Always true for XML output
+   */
+  allowsIndentInside(_element) {
+    return true;
+  }
+
+  /**
+   * Build the markup closing an element that has no children.
+   *
+   * XHTML elements follow the XHTML compatibility guidelines, as libxml2
+   * (Chrome) and the DOM serializer (Firefox) do: void elements become
+   * `<br />` and every other empty element gets an explicit end tag, because
+   * `<script/>` or `<div/>` break when XHTML reaches an HTML parser. Other
+   * elements use the XML empty-element tag.
+   *
+   * @param {Element} element - Empty element
+   * @param {string} name - Element name as written
+   * @returns {string} Markup terminating the start tag
+   */
+  emptyElementMarkup(element, name) {
+    if (!this.followsXhtmlConventions(element)) return "/>";
+    return this.isVoidElement(element) ? " />" : `></${name}>`;
+  }
+
+  /**
+   * Whether an element is written with the XHTML empty-element conventions:
+   * elements in the XHTML namespace, and namespace-less elements when the
+   * output method is `xhtml` or the document type is XHTML 1.0.
+   *
+   * @param {Element} element - Element to test
+   * @returns {boolean} True for XHTML elements
+   */
+  followsXhtmlConventions(element) {
+    const namespace = element.namespaceURI || null;
+    if (namespace === XHTML_NAMESPACE) return true;
+    return namespace === null && (this.xhtml || this.isXhtmlDocument);
+  }
+
+  /**
+   * Test whether an element is an HTML void element.
+   *
+   * @param {Element} element - Element to test
+   * @returns {boolean} True for void elements such as `br`
+   */
+  isVoidElement(element) {
+    return VOID_ELEMENTS.has(String(element.localName).toLowerCase());
+  }
+
+  /**
+   * Escape character data.
+   *
+   * @param {string} value - Text content
+   * @returns {string} Escaped text
+   */
+  escapeText(value) {
+    return this.encodeReferences(escapeXmlText(value));
+  }
+
+  /**
+   * Escape an attribute value.
+   *
+   * @param {string} value - Attribute value
+   * @returns {string} Escaped value
+   */
+  escapeAttribute(value) {
+    return this.encodeReferences(escapeXmlAttribute(value));
+  }
+
+  /**
+   * Reference to a character the output encoding cannot represent.
+   *
+   * @param {number} codePoint - The code point
+   * @returns {string} A numeric character reference
+   */
+  characterReference(codePoint) {
+    return characterReference(codePoint);
+  }
+}

package/src/xslt/serializer.js

@@ -0,0 +1,90 @@
+/**
+ * XSLT Output Serializer
+ *
+ * Serializes a result tree to a string honoring the `xsl:output` settings of
+ * the stylesheet (XSLT 1.0 section 16): output method, indentation, XML
+ * declaration, document type declaration, CDATA sections and
+ * `disable-output-escaping`.
+ *
+ * @example
+ * import { serializeResult } from './serializer.js';
+ *
+ * serializeResult(resultDocument, { method: 'xml', indent: 'yes' });
+ * // '<?xml version="1.0" encoding="UTF-8"?>\n<BAR>\n  <QUX/>\n</BAR>'
+ */
+
+import { resolveOutputSettings } from "./serializer/settings.js";
+import { XmlWriter } from "./serializer/xmlSerializer.js";
+import { HtmlWriter } from "./serializer/htmlSerializer.js";
+import { textChunks } from "./serializer/textSerializer.js";
+import { toChunkSize } from "./serializer/chunks.js";
+
+export { markRawText, isRawText, rawTextNodes } from "./serializer/rawText.js";
+export {
+  resolveOutputSettings,
+  detectOutputMethod,
+  findRootElement,
+} from "./serializer/settings.js";
+export { XmlWriter } from "./serializer/xmlSerializer.js";
+export { HtmlWriter } from "./serializer/htmlSerializer.js";
+export { serializeText, textChunks } from "./serializer/textSerializer.js";
+export {
+  ChunkBuffer,
+  DEFAULT_CHUNK_SIZE,
+  toChunkSize,
+} from "./serializer/chunks.js";
+
+/**
+ * Serialize a transformation result incrementally, honoring the same
+ * `xsl:output` settings as {@link serializeResult}. The result tree must be
+ * complete (XSLT 1.0 builds it in memory); what is bounded is the output
+ * text: chunks are yielded as soon as they are full, so a consumer can write
+ * them out while the rest is being serialized.
+ *
+ * @param {Node|null} node - Result document, fragment or element
+ * @param {object} [outputSettings] - `xsl:output` settings (see serializeResult)
+ * @param {{chunkSize?: number}} [options] - `chunkSize` in UTF-16 code units,
+ *   {@link DEFAULT_CHUNK_SIZE} (16 KiB) by default, Infinity for one chunk
+ * @yields {string} Non-empty chunks of at most `chunkSize` code units (one
+ *   more when a surrogate pair straddles the boundary)
+ * @returns {Iterator<string>} The chunks; joined, they equal
+ *   `serializeResult(node, outputSettings)`
+ * @throws {RangeError} When `chunkSize` is not a positive integer or Infinity
+ *
+ * @example
+ * for (const chunk of serializeChunks(resultDocument, { method: "xml" })) {
+ *   stream.write(chunk);
+ * }
+ */
+export function serializeChunks(node, outputSettings = {}, options = {}) {
+  const chunkSize = toChunkSize(options.chunkSize);
+  if (!node) return [][Symbol.iterator]();
+
+  const settings = resolveOutputSettings(outputSettings, node);
+
+  if (settings.method === "text") {
+    return textChunks(node, chunkSize);
+  }
+  const writer =
+    settings.method === "html"
+      ? new HtmlWriter(settings)
+      : new XmlWriter(settings, { xhtml: settings.method === "xhtml" });
+  return writer.chunks(node, chunkSize);
+}
+
+/**
+ * Serialize a transformation result to a string.
+ *
+ * @param {Node|null} node - Result document, fragment or element
+ * @param {object} [outputSettings] - `xsl:output` settings, as collected by the
+ *   XSLT engine (`method`, `version`, `encoding`, `standalone`, `indent`,
+ *   `omitXmlDeclaration`, `doctypePublic`, `doctypeSystem`, `mediaType`,
+ *   `cdataSectionElements`)
+ * @returns {string} The serialized result, or an empty string for a null node
+ */
+export function serializeResult(node, outputSettings = {}) {
+  const chunks = serializeChunks(node, outputSettings, { chunkSize: Infinity });
+  let output = "";
+  for (const chunk of chunks) output += chunk;
+  return output;
+}