@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/resultNamespaces.js

@@ -0,0 +1,219 @@
+/**
+ * Namespaces of result tree elements and attributes.
+ *
+ * - `xsl:element` and `xsl:attribute` resolve the prefix of their computed
+ *   name against the namespaces in scope on the instruction, and an
+ *   unprefixed `xsl:element` name takes the default namespace (XSLT 1.0
+ *   sections 7.1.2 and 7.1.3); a `namespace` attribute wins over both.
+ * - An attribute in a namespace needs a prefix, so one is generated (`ns_1`,
+ *   `ns_2`, ..., the names libxslt uses) when the name has none, its prefix
+ *   is `xmlns` or already bound to another namespace on the element. The XML
+ *   namespace always gets the `xml` prefix.
+ * - Literal result elements copy the namespace nodes in scope in the
+ *   stylesheet (section 7.1.1) as `xmlns` attributes; declarations the parent
+ *   result element already carries are not repeated.
+ *
+ * @module xslt/resultNamespaces
+ */
+
+"use strict";
+
+import {
+  XMLNS_NAMESPACE,
+  XML_NAMESPACE,
+  resolvePrefix,
+  resultNamespaceNodes,
+} from "./stylesheetNamespaces.js";
+
+/** Stylesheet scope each literal result element was created in. */
+const createdInScope = new WeakMap();
+
+/**
+ * Split a QName into prefix and local part.
+ *
+ * @param {string} qname - e.g. `xl:href` or `p`
+ * @returns {{prefix: string, localName: string}} The parts, prefix "" when absent
+ */
+export function splitQName(qname) {
+  const colon = qname.indexOf(":");
+  return colon < 0
+    ? { prefix: "", localName: qname }
+    : { prefix: qname.slice(0, colon), localName: qname.slice(colon + 1) };
+}
+
+/**
+ * Compute the expanded name of an element created by `xsl:element`.
+ *
+ * @param {string} qname - The evaluated `name` attribute
+ * @param {string|null} namespace - The evaluated `namespace` attribute, null when absent
+ * @param {Object<string, string>} scope - Namespaces in scope on the instruction
+ * @returns {{namespaceUri: (string|null), qname: string}} The element name
+ *
+ * @example
+ * elementName("p", null, { "": "http://www.w3.org/1999/xhtml" });
+ * // { namespaceUri: "http://www.w3.org/1999/xhtml", qname: "p" }
+ */
+export function elementName(qname, namespace, scope) {
+  const { prefix, localName } = splitQName(qname);
+  if (namespace !== null) {
+    // An element in no namespace cannot keep a prefix, as for attributes
+    return namespace
+      ? { namespaceUri: namespace, qname }
+      : { namespaceUri: null, qname: localName };
+  }
+  return { namespaceUri: resolvePrefix(scope, prefix), qname };
+}
+
+/**
+ * Compute the expanded name of an attribute created by `xsl:attribute`.
+ * Unprefixed attribute names are in no namespace unless `namespace` says so.
+ *
+ * @param {string} qname - The evaluated `name` attribute
+ * @param {string|null} namespace - The evaluated `namespace` attribute, null when absent
+ * @param {Object<string, string>} scope - Namespaces in scope on the instruction
+ * @returns {{namespaceUri: (string|null), qname: string}} The attribute name
+ */
+export function attributeName(qname, namespace, scope) {
+  const { prefix, localName } = splitQName(qname);
+  if (namespace !== null) {
+    return namespace
+      ? { namespaceUri: namespace, qname }
+      : { namespaceUri: null, qname: localName };
+  }
+  return { namespaceUri: prefix ? resolvePrefix(scope, prefix) : null, qname };
+}
+
+/**
+ * Whether a prefix may be used on an element for a namespace: it must not be
+ * bound to another namespace by the element name or by another attribute.
+ *
+ * @param {Element} element - The result element
+ * @param {string} prefix - A candidate prefix
+ * @param {string} uri - The namespace the prefix should denote
+ * @returns {boolean} True when the prefix is free or already bound to `uri`
+ */
+function prefixAvailable(element, prefix, uri) {
+  if (element.prefix === prefix && element.namespaceURI !== uri) return false;
+  for (const attribute of element.attributes) {
+    if (attribute.prefix === prefix && attribute.namespaceURI !== uri) {
+      return false;
+    }
+    if (
+      attribute.namespaceURI === XMLNS_NAMESPACE &&
+      attribute.localName === prefix &&
+      attribute.value !== uri
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Pick the prefix of a namespaced attribute on an element.
+ *
+ * @param {Element} element - The result element
+ * @param {string} prefix - The prefix of the requested name, "" when none
+ * @param {string} uri - The attribute namespace
+ * @returns {string} A prefix bound to nothing else on the element
+ */
+function attributePrefix(element, prefix, uri) {
+  if (uri === XML_NAMESPACE) return "xml";
+  const reserved = prefix === "xmlns" || prefix === "xml";
+  if (prefix && !reserved && prefixAvailable(element, prefix, uri)) {
+    return prefix;
+  }
+  let index = 1;
+  while (!prefixAvailable(element, `ns_${index}`, uri)) index++;
+  return `ns_${index}`;
+}
+
+/**
+ * Add (or replace) an attribute of a result element.
+ *
+ * @param {Element} element - The result element
+ * @param {{namespaceUri: (string|null), qname: string}} name - Expanded name
+ * @param {string} value - The attribute value
+ * @returns {void}
+ *
+ * @example
+ * setResultAttribute(el, { namespaceUri: "urn:x", qname: "a" }, "1"); // ns_1:a="1"
+ */
+export function setResultAttribute(element, name, value) {
+  const { prefix, localName } = splitQName(name.qname);
+  if (!name.namespaceUri) {
+    if (localName === "xmlns") return;
+    element.setAttribute(localName, value);
+    return;
+  }
+  // Namespace declarations are not attributes
+  if (name.qname === "xmlns" || name.namespaceUri === XMLNS_NAMESPACE) return;
+
+  const existing = element.getAttributeNodeNS(name.namespaceUri, localName);
+  if (existing) {
+    existing.value = value;
+    return;
+  }
+  const chosen = attributePrefix(element, prefix, name.namespaceUri);
+  element.setAttributeNS(name.namespaceUri, `${chosen}:${localName}`, value);
+}
+
+/**
+ * Copy the namespace nodes of a literal result element onto its result
+ * element, skipping the declarations already in effect on the parent.
+ *
+ * @param {Element} element - The new result element
+ * @param {Element} stylesheetNode - The literal result element
+ * @param {Node} parent - The result node receiving `element`
+ * @param {(uri: string) => boolean} isAliased - Whether a URI is the
+ *   stylesheet side of an `xsl:namespace-alias` (such namespaces are replaced,
+ *   never copied)
+ * @returns {void}
+ */
+export function copyLiteralNamespaces(
+  element,
+  stylesheetNode,
+  parent,
+  isAliased,
+) {
+  const nodes = resultNamespaceNodes(stylesheetNode);
+  if (nodes.length === 0) return;
+  createdInScope.set(element, nodes);
+  if (createdInScope.get(parent) === nodes) return;
+
+  const parentElement = parent.nodeType === 1 ? parent : null;
+  for (const [prefix, uri] of nodes) {
+    if (isAliased(uri)) continue;
+    if (parentElement?.lookupNamespaceURI(prefix || null) === uri) continue;
+    if ((element.prefix ?? "") === prefix && element.namespaceURI !== uri) {
+      continue;
+    }
+    element.setAttributeNS(
+      XMLNS_NAMESPACE,
+      prefix ? `xmlns:${prefix}` : "xmlns",
+      uri,
+    );
+  }
+}
+
+/**
+ * Copy the namespace declarations of a source element (its own `xmlns`
+ * attributes) onto a copy, as `xsl:copy` and `xsl:copy-of` do.
+ *
+ * @param {Element} source - The copied element
+ * @param {Element} copy - The result element
+ * @returns {void}
+ */
+export function copyNamespaceDeclarations(source, copy) {
+  for (const attribute of source.attributes) {
+    if (attribute.namespaceURI !== XMLNS_NAMESPACE) continue;
+    const prefix = attribute.prefix ? attribute.localName : "";
+    if (
+      (copy.prefix ?? "") === prefix &&
+      copy.namespaceURI !== attribute.value
+    ) {
+      continue;
+    }
+    copy.setAttributeNS(XMLNS_NAMESPACE, attribute.name, attribute.value);
+  }
+}

package/src/xslt/resultTree.js

@@ -0,0 +1,211 @@
+/**
+ * Result tree construction helpers.
+ *
+ * XSLT builds its result tree in a neutral XML document: building directly in
+ * an HTML owner document would lower case element names and force the XHTML
+ * namespace on every created element. The finished tree is imported into the
+ * caller's document only at the very end, which keeps names, namespaces and the
+ * `disable-output-escaping` markers intact.
+ */
+
+"use strict";
+
+/**
+ * Create an empty, namespace neutral XML document.
+ *
+ * @param {Document} ownerDocument - Any document, used for its DOM implementation
+ * @returns {Document} A fresh empty XML document
+ *
+ * @example
+ * const resultDoc = createResultDocument(window.document);
+ */
+export function createResultDocument(ownerDocument) {
+  return ownerDocument.implementation.createDocument(null, null, null);
+}
+
+/**
+ * Copy an element in no namespace into an HTML document as an element of the
+ * XHTML namespace, as Chrome and Firefox do when they insert XML output into
+ * an HTML document: `<ul><li>` become HTMLElements that render as a list.
+ * The name is kept as written (no case folding).
+ *
+ * @param {Element} element - Element in no namespace
+ * @param {Document} targetDoc - The HTML document that will own the copy
+ * @returns {Element} The shallow copy, with the attributes
+ */
+function importAsHtmlElement(element, targetDoc) {
+  const copy = targetDoc.createElementNS(XHTML_NAMESPACE, element.localName);
+  for (const attribute of element.attributes) {
+    copy.setAttributeNS(
+      attribute.namespaceURI,
+      attribute.name,
+      attribute.value,
+    );
+  }
+  return copy;
+}
+
+/**
+ * Deep-import a result tree node into another document.
+ *
+ * Unlike `Document.importNode` this preserves the internal
+ * `_disableOutputEscaping` marker set by `disable-output-escaping`. With
+ * `htmlElements` and an HTML target document, elements in no namespace
+ * become XHTML elements (see importAsHtmlElement), as in the fragments
+ * browsers return; elements of other namespaces are kept.
+ *
+ * @param {Node} node - The node to import
+ * @param {Document} targetDoc - The document that will own the copy
+ * @param {{htmlElements?: boolean}} [options] - Import options
+ * @returns {Node} The imported copy
+ *
+ * @example
+ * const copy = importResultNode(element, window.document);
+ */
+export function importResultNode(node, targetDoc, options = {}) {
+  const asHtml =
+    options.htmlElements === true &&
+    node.nodeType === 1 &&
+    !node.namespaceURI &&
+    isHtmlDocument(targetDoc);
+  const copy = asHtml
+    ? importAsHtmlElement(node, targetDoc)
+    : targetDoc.importNode(node, false);
+
+  if (node._disableOutputEscaping) {
+    copy._disableOutputEscaping = true;
+  }
+
+  if (node.childNodes) {
+    for (const child of node.childNodes) {
+      copy.appendChild(importResultNode(child, targetDoc, options));
+    }
+  }
+
+  return copy;
+}
+
+/**
+ * Move a finished result fragment into the caller's output document.
+ *
+ * @param {DocumentFragment} fragment - The fragment built in the neutral document
+ * @param {Document} targetDoc - The document that will own the result
+ * @param {{htmlElements?: boolean}} [options] - See {@link importResultNode}
+ * @returns {DocumentFragment} A fragment owned by `targetDoc`
+ *
+ * @example
+ * const result = importResultFragment(fragment, window.document);
+ */
+export function importResultFragment(fragment, targetDoc, options = {}) {
+  if (fragment.ownerDocument === targetDoc) return fragment;
+
+  const imported = targetDoc.createDocumentFragment();
+  for (const child of fragment.childNodes) {
+    imported.appendChild(importResultNode(child, targetDoc, options));
+  }
+
+  return imported;
+}
+
+/** The XHTML namespace. */
+export const XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+
+/** Public and system identifiers of the XHTML 1.0 Strict DTD. */
+const XHTML_STRICT_DOCTYPE = [
+  "-//W3C//DTD XHTML 1.0 Strict//EN",
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd",
+];
+
+/**
+ * Turn an empty document into the one Chrome's `XSLTProcessor` returns from
+ * `transformToDocument` for `method="text"`: the text in a `pre` element of
+ * the XHTML 1.0 Strict page Blink builds, with its line breaks:
+ * `<!DOCTYPE html PUBLIC ...>` then
+ * `<html>\n<head><title/></head>\n<body>\n<pre>text</pre>\n</body>\n</html>`.
+ * A text result has no element to be the document element of an XML
+ * document.
+ *
+ * @param {Document} doc - An empty document
+ * @param {string} text - The serialized text output
+ * @returns {Document} The same document, filled in
+ *
+ * @example
+ * wrapTextResult(emptyDoc, "hello").documentElement.textContent;
+ * // "\n\n\nhello\n\n"
+ */
+export function wrapTextResult(doc, text) {
+  // appendChild, not append: xmldom has no ParentNode.append
+  const create = (name, ...children) => {
+    const element = doc.createElementNS(XHTML_NAMESPACE, name);
+    for (const child of children) {
+      element.appendChild(
+        typeof child === "string" ? doc.createTextNode(child) : child,
+      );
+    }
+    return element;
+  };
+  const pre = create("pre");
+  if (text) pre.appendChild(doc.createTextNode(text));
+  const head = create("head", create("title"));
+  const body = create("body", "\n", pre, "\n");
+  // One node at a time: a doctype cannot pass through a fragment
+  appendDoctype(doc, "html", ...XHTML_STRICT_DOCTYPE);
+  doc.appendChild(create("html", "\n", head, "\n", body, "\n"));
+  return doc;
+}
+
+/**
+ * Append a document type node to a document.
+ *
+ * @param {Document} doc - A document without a doctype
+ * @param {string} name - The root element name
+ * @param {string} publicId - Public identifier ("" for none)
+ * @param {string} systemId - System identifier ("" for none)
+ * @returns {DocumentType} The appended node
+ *
+ * @example
+ * appendDoctype(doc, "html", "", "about:legacy-compat");
+ */
+export function appendDoctype(doc, name, publicId, systemId) {
+  const doctype = doc.implementation.createDocumentType(
+    name,
+    publicId,
+    systemId,
+  );
+  doc.appendChild(doctype);
+  // xmldom leaves Document.doctype null when a doctype node is appended
+  doc.doctype ??= doctype;
+  return doctype;
+}
+
+/**
+ * Whether a document is an HTML document (as opposed to an XML one).
+ *
+ * @param {Document} doc - Any document
+ * @returns {boolean} True for documents of content type text/html
+ */
+export function isHtmlDocument(doc) {
+  return doc.contentType === "text/html";
+}
+
+/**
+ * Parse serialized `html` output into a fragment of an HTML document, as
+ * Chrome's `XSLTProcessor.transformToFragment` does: the elements are
+ * created by the HTML parser, so `<a>` is an `HTMLAnchorElement` and
+ * `<script>` elements run when inserted. Like Blink, the markup is parsed
+ * in the context of a (detached) `body` element, that is in the "in body"
+ * insertion mode: `<html>`, `<head>` and `<body>` tags are dropped and their
+ * content becomes children of the fragment.
+ *
+ * @param {string} markup - HTML markup
+ * @param {Document} doc - The HTML document that will own the fragment
+ * @returns {DocumentFragment} The parsed fragment
+ *
+ * @example
+ * parseHtmlFragment('<a href="u">x</a>', document).firstChild; // HTMLAnchorElement
+ */
+export function parseHtmlFragment(markup, doc) {
+  const range = doc.createRange();
+  range.selectNodeContents(doc.createElement("body"));
+  return range.createContextualFragment(markup);
+}