@tradik/xslt-processor 1.0.3 → 1.3.0

package/src/xslt/serializer/htmlDoctype.js

@@ -0,0 +1,102 @@
+/**
+ * Document type declaration of the html output method (XSLT 1.0 section
+ * 16.2), as libxslt and libxml2 (and so Chrome) write it.
+ *
+ * Without `doctype-public` and `doctype-system`, libxslt derives the
+ * identifiers from the `version` attribute of `xsl:output` (its table
+ * below): `version="5"` gives `<!DOCTYPE html>`, `version="4.01"` the HTML
+ * 4.01 Transitional DTD. The system identifier `about:legacy-compat` is not
+ * written (HTML5's legacy doctype string).
+ *
+ * @module xslt/serializer/htmlDoctype
+ */
+
+/** Doctype identifiers by html `version`, libxslt's xsltHTMLVersions. */
+const HTML_VERSIONS = new Map([
+  ["5", [null, "about:legacy-compat"]],
+  [
+    "4.01frame",
+    [
+      "-//W3C//DTD HTML 4.01 Frameset//EN",
+      "http://www.w3.org/TR/1999/REC-html401-19991224/frameset.dtd",
+    ],
+  ],
+  [
+    "4.01strict",
+    [
+      "-//W3C//DTD HTML 4.01//EN",
+      "http://www.w3.org/TR/1999/REC-html401-19991224/strict.dtd",
+    ],
+  ],
+  [
+    "4.01trans",
+    [
+      "-//W3C//DTD HTML 4.01 Transitional//EN",
+      "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd",
+    ],
+  ],
+  [
+    "4.01",
+    [
+      "-//W3C//DTD HTML 4.01 Transitional//EN",
+      "http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd",
+    ],
+  ],
+  [
+    "4.0strict",
+    ["-//W3C//DTD HTML 4.01//EN", "http://www.w3.org/TR/html4/strict.dtd"],
+  ],
+  [
+    "4.0trans",
+    [
+      "-//W3C//DTD HTML 4.01 Transitional//EN",
+      "http://www.w3.org/TR/html4/loose.dtd",
+    ],
+  ],
+  [
+    "4.0frame",
+    [
+      "-//W3C//DTD HTML 4.01 Frameset//EN",
+      "http://www.w3.org/TR/html4/frameset.dtd",
+    ],
+  ],
+  [
+    "4.0",
+    [
+      "-//W3C//DTD HTML 4.01 Transitional//EN",
+      "http://www.w3.org/TR/html4/loose.dtd",
+    ],
+  ],
+  ["3.2", ["-//W3C//DTD HTML 3.2//EN", null]],
+]);
+
+/** System identifier libxml2 leaves out of an HTML doctype. */
+const LEGACY_COMPAT = "about:legacy-compat";
+
+/**
+ * Build the doctype of html output.
+ *
+ * @param {{doctypePublic?: string|null, doctypeSystem?: string|null,
+ *   version?: string|null}} settings - Normalized output settings
+ * @param {string} name - Name of the document element
+ * @returns {string} The doctype markup, or "" when there is none
+ *
+ * @example
+ * htmlDoctypeMarkup({ version: "5" }, "html"); // "<!DOCTYPE html>"
+ */
+export function htmlDoctypeMarkup(settings, name) {
+  let publicId = settings.doctypePublic || null;
+  let systemId = settings.doctypeSystem || null;
+  if (!publicId && !systemId) {
+    const ids = HTML_VERSIONS.get(String(settings.version).toLowerCase());
+    if (!ids) return "";
+    [publicId, systemId] = ids;
+  }
+  if (publicId) {
+    const system = systemId ? ` "${systemId}"` : "";
+    return `<!DOCTYPE ${name} PUBLIC "${publicId}"${system}>`;
+  }
+  return systemId === LEGACY_COMPAT
+    ? `<!DOCTYPE ${name}>`
+    : `<!DOCTYPE ${name} SYSTEM "${systemId}">`;
+}

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

@@ -0,0 +1,239 @@
+/**
+ * HTML Output Serializer
+ *
+ * Implements the `html` output method of XSLT 1.0 section 16.2 on top of the
+ * 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,
+  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.
+   * @returns {boolean} Always false
+   */
+  get emitsXmlDeclaration() {
+    return false;
+  }
+
+  /**
+   * 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 isXhtmlDocument() {
+    return false;
+  }
+
+  /**
+   * HTML processing instructions are terminated by `>` alone.
+   * @returns {string} The HTML processing instruction terminator
+   */
+  get piTerminator() {
+    return ">";
+  }
+
+  /**
+   * HTML has no CDATA sections, so such nodes are escaped as text.
+   * @returns {string} A {@link TEXT_MODE} value
+   */
+  get cdataNodeMode() {
+    return TEXT_MODE.ESCAPE;
+  }
+
+  /**
+   * 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) {
+    return htmlDoctypeMarkup(
+      this.settings,
+      rootElement ? rootElement.nodeName : "html",
+    );
+  }
+
+  /**
+   * Script and style content is written verbatim.
+   *
+   * @param {Element} element - Parent element
+   * @returns {string} A {@link TEXT_MODE} value
+   */
+  childTextMode(element) {
+    return RAW_TEXT_ELEMENTS.has(String(element.localName).toLowerCase())
+      ? TEXT_MODE.RAW
+      : TEXT_MODE.ESCAPE;
+  }
+
+  /**
+   * Content of `pre`, `script`, `style` and `textarea` is never re-indented.
+   *
+   * @param {Element} element - Element being inspected
+   * @returns {boolean} True when the content may be indented
+   */
+  allowsIndentInside(element) {
+    return !PRESERVE_SPACE_ELEMENTS.has(
+      String(element.localName).toLowerCase(),
+    );
+  }
+
+  /**
+   * Void elements have no end tag; every other element gets one.
+   *
+   * @param {Element} element - Empty element
+   * @param {string} name - Element name as written
+   * @returns {string} Markup terminating the start tag
+   */
+  emptyElementMarkup(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; URI attributes
+   * are %-escaped (see isUriAttribute).
+   *
+   * @param {Attr} attribute - Attribute to write
+   * @returns {string} Attribute markup, starting with a space
+   */
+  attributeMarkup(attribute) {
+    const { name, value } = attribute;
+    if (String(value).toLowerCase() === name.toLowerCase()) {
+      return ` ${name}`;
+    }
+    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)}">`;
+  }
+
+  /**
+   * Escape character data for HTML.
+   *
+   * @param {string} value - Text content
+   * @returns {string} Escaped text
+   */
+  escapeText(value) {
+    return this.encodeReferences(escapeHtmlText(value));
+  }
+
+  /**
+   * Escape an attribute value for HTML.
+   *
+   * @param {string} value - Attribute value
+   * @returns {string} Escaped value
+   */
+  escapeAttribute(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/indent.js

@@ -0,0 +1,51 @@
+/**
+ * Indentation Rules
+ *
+ * Decides which elements may be pretty printed when `indent="yes"` is set.
+ * Only element-only content is indented; mixed content is left untouched so
+ * that the transformation result stays character-for-character faithful.
+ */
+
+import { NODE_TYPE } from "./constants.js";
+
+/**
+ * Test whether a character data node holds only whitespace.
+ *
+ * @param {Node} node - Text node to test
+ * @returns {boolean} True when the node contains no non-whitespace character
+ */
+export function isWhitespaceOnlyText(node) {
+  return !/\S/.test(node.nodeValue || "");
+}
+
+/**
+ * Collect the children to write when indenting an element.
+ *
+ * @param {Element} element - Element whose children are inspected
+ * @returns {Node[]|null} Children to indent, or null when the element must be
+ *   serialized without any added whitespace
+ */
+export function getIndentableChildren(element) {
+  const indentable = [];
+
+  for (const child of element.childNodes) {
+    if (child.nodeType === NODE_TYPE.TEXT) {
+      if (isWhitespaceOnlyText(child)) {
+        continue;
+      }
+      return null;
+    }
+
+    if (
+      child.nodeType !== NODE_TYPE.ELEMENT &&
+      child.nodeType !== NODE_TYPE.COMMENT &&
+      child.nodeType !== NODE_TYPE.PROCESSING_INSTRUCTION
+    ) {
+      return null;
+    }
+
+    indentable.push(child);
+  }
+
+  return indentable.length > 0 ? indentable : null;
+}

package/src/xslt/serializer/namespaces.js

@@ -0,0 +1,68 @@
+/**
+ * Namespace Declaration Tracking
+ *
+ * Computes the `xmlns` declarations an element has to carry so that every
+ * namespace is declared where it is first used and never twice.
+ */
+
+import { XMLNS_NAMESPACE, XML_NAMESPACE } from "./constants.js";
+
+/**
+ * Create the namespace scope in effect above the result tree root.
+ *
+ * @returns {Map<string, string>} Prefix (empty string for the default) to URI
+ */
+export function createNamespaceScope() {
+  return new Map([
+    ["", ""],
+    ["xml", XML_NAMESPACE],
+  ]);
+}
+
+/**
+ * Collect the namespace declarations an element must emit.
+ *
+ * @param {Element} element - Element being serialized
+ * @param {Map<string, string>} scope - Namespace scope inherited from the parent
+ * @returns {{declarations: Array<{prefix: string, uri: string}>, scope: Map<string, string>}}
+ *   The declarations to write and the scope in effect for the children
+ */
+export function collectNamespaceDeclarations(element, scope) {
+  const declarations = [];
+  let next = scope;
+
+  /**
+   * Record a declaration when the binding is not already in scope.
+   * @param {string} prefix - Namespace prefix, empty for the default namespace
+   * @param {string} uri - Namespace URI
+   * @returns {void}
+   */
+  const declare = (prefix, uri) => {
+    if (next.get(prefix) === uri) {
+      return;
+    }
+    if (next === scope) {
+      next = new Map(scope);
+    }
+    next.set(prefix, uri);
+    declarations.push({ prefix, uri });
+  };
+
+  declare(element.prefix || "", element.namespaceURI || "");
+
+  const attributes = Array.from(element.attributes || []);
+
+  for (const attribute of attributes) {
+    if (attribute.namespaceURI !== XMLNS_NAMESPACE && attribute.prefix) {
+      declare(attribute.prefix, attribute.namespaceURI || "");
+    }
+  }
+
+  for (const attribute of attributes) {
+    if (attribute.namespaceURI === XMLNS_NAMESPACE) {
+      declare(attribute.prefix ? attribute.localName : "", attribute.value);
+    }
+  }
+
+  return { declarations, scope: next };
+}

package/src/xslt/serializer/rawText.js

@@ -0,0 +1,41 @@
+/**
+ * Raw Text Registry
+ *
+ * Tracks the text nodes produced with `disable-output-escaping="yes"`
+ * (XSLT 1.0 section 16.4) so the serializers can emit them verbatim.
+ */
+
+/**
+ * Text nodes whose content must be written without escaping.
+ * @type {WeakSet<Node>}
+ */
+export const rawTextNodes = new WeakSet();
+
+/**
+ * Mark a text node as produced with `disable-output-escaping="yes"`.
+ *
+ * @param {Node|null} node - Text node to mark
+ * @returns {Node|null} The same node, for chaining
+ */
+export function markRawText(node) {
+  if (node) {
+    rawTextNodes.add(node);
+  }
+  return node;
+}
+
+/**
+ * Check whether a node must be serialized without output escaping.
+ *
+ * Both the registry and the legacy `_disableOutputEscaping` flag set by the
+ * XSLT engine are honored so that either marking mechanism works.
+ *
+ * @param {Node|null} node - Node to test
+ * @returns {boolean} True when the node content must be emitted raw
+ */
+export function isRawText(node) {
+  if (!node) {
+    return false;
+  }
+  return rawTextNodes.has(node) || node._disableOutputEscaping === true;
+}