@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/functions/uri.js

@@ -0,0 +1,166 @@
+/**
+ * Functions on URIs (F&O 3.1 sections 5.4.10 to 5.4.12 and 8.1):
+ * encode-for-uri, iri-to-uri, escape-html-uri and resolve-uri, which
+ * implements the reference resolution of RFC 3986 section 5.2.
+ *
+ * @module @tradik/xslt3/functions/uri
+ */
+
+import { XPathError } from "../errors.js";
+import { AtomicValue } from "../xdm/atomic.js";
+import { types } from "../xdm/types.js";
+import { define, stringArg, stringItem } from "./support.js";
+
+const encoder = new globalThis.TextEncoder();
+
+/**
+ * Percent-encodes (UTF-8, upper-case hex) the codepoints that `keep`
+ * rejects.
+ * @param {string} text
+ * @param {(cp: number) => boolean} keep
+ * @returns {string}
+ */
+export function percentEncode(text, keep) {
+  let result = "";
+  for (const char of text) {
+    if (keep(char.codePointAt(0))) {
+      result += char;
+      continue;
+    }
+    for (const byte of encoder.encode(char)) {
+      result += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+    }
+  }
+  return result;
+}
+
+const unreserved = /^[A-Za-z0-9\-_.~]$/;
+const notInUri = new Set([...'<>"{}|\\^`'].map((c) => c.codePointAt(0)));
+
+/** @type {Record<string, (cp: number) => boolean>} kept codepoints */
+const escapers = {
+  "encode-for-uri": (cp) => unreserved.test(String.fromCodePoint(cp)),
+  "iri-to-uri": (cp) => cp > 0x20 && cp < 0x7f && !notInUri.has(cp),
+  "escape-html-uri": (cp) => cp >= 0x20 && cp <= 0x7e,
+};
+
+const referencePattern =
+  /^(?:([^:/?#]*):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/s;
+const schemePattern = /^[A-Za-z][A-Za-z0-9+.-]*$/;
+
+/**
+ * Splits a URI reference into its RFC 3986 components.
+ * @param {string} uri
+ * @returns {{scheme?: string, authority?: string, path: string,
+ *   query?: string, fragment?: string}}
+ * @throws {XPathError} FORG0002 for an invalid scheme or percent-encoding,
+ *   or a "#" in the fragment
+ */
+function parseReference(uri) {
+  const [, scheme, authority, path, query, fragment] =
+    referencePattern.exec(uri);
+  if (
+    (scheme !== undefined && !schemePattern.test(scheme)) ||
+    /%(?![0-9A-Fa-f]{2})/.test(uri) ||
+    fragment?.includes("#")
+  ) {
+    throw new XPathError("FORG0002", `Invalid URI ${uri}`);
+  }
+  return { scheme, authority, path, query, fragment };
+}
+
+/**
+ * remove_dot_segments of RFC 3986 section 5.2.4.
+ * @param {string} path
+ * @returns {string}
+ */
+export function removeDotSegments(path) {
+  const output = [];
+  const segments = path.split("/");
+  segments.forEach((segment, i) => {
+    const last = i === segments.length - 1;
+    if (segment === ".") {
+      if (last) output.push("");
+    } else if (segment === "..") {
+      if (output.length > 1 || (output.length === 1 && output[0] !== "")) {
+        output.pop();
+      }
+      if (last) output.push("");
+    } else {
+      output.push(segment);
+    }
+  });
+  return output.join("/");
+}
+
+/**
+ * Resolves a URI reference against an absolute base (RFC 3986 5.2.2).
+ * @param {string} relative
+ * @param {string} base
+ * @returns {string}
+ * @throws {XPathError} FORG0002 for invalid URIs, a relative base or a base
+ *   with a fragment
+ */
+export function resolveUri(relative, base) {
+  const r = parseReference(relative);
+  if (r.scheme !== undefined) return relative;
+  const b = parseReference(base);
+  if (b.scheme === undefined || b.fragment !== undefined) {
+    throw new XPathError("FORG0002", `Invalid base URI ${base}`);
+  }
+  let { authority, path, query } = r;
+  if (authority === undefined) {
+    authority = b.authority;
+    if (path === "") {
+      path = b.path;
+      query ??= b.query;
+    } else if (!path.startsWith("/")) {
+      path =
+        b.authority !== undefined && b.path === ""
+          ? `/${path}`
+          : b.path.slice(0, b.path.lastIndexOf("/") + 1) + path;
+    }
+  }
+  return (
+    `${b.scheme}:` +
+    (authority === undefined ? "" : `//${authority}`) +
+    removeDotSegments(path) +
+    (query === undefined ? "" : `?${query}`) +
+    (r.fragment === undefined ? "" : `#${r.fragment}`)
+  );
+}
+
+/**
+ * fn:resolve-uri.
+ * @param {Array<*>[]} args - [$relative, $base?]
+ * @param {{staticBaseUri?: string}} context
+ * @returns {Array<*>}
+ */
+function resolveUriFunction([relative, base], context) {
+  if (relative.length === 0) return [];
+  const baseUri = base ? base[0].value : context.staticBaseUri;
+  // an absolute URI is returned as is, without a base
+  const absolute = parseReference(relative[0].value).scheme !== undefined;
+  if (!absolute && (baseUri === undefined || baseUri === null)) {
+    throw new XPathError("FONS0005", "The static base URI is absent");
+  }
+  return [
+    new AtomicValue(types.anyURI, resolveUri(relative[0].value, baseUri)),
+  ];
+}
+
+/** @type {import("./support.js").FunctionDefinition[]} */
+export const uriFunctions = [
+  ...Object.entries(escapers).map(([local, keep]) =>
+    define(local, ["xs:string?"], "xs:string", ([s]) => [
+      stringItem(percentEncode(stringArg(s), keep)),
+    ]),
+  ),
+  define("resolve-uri", ["xs:string?"], "xs:anyURI?", resolveUriFunction),
+  define(
+    "resolve-uri",
+    ["xs:string?", "xs:string"],
+    "xs:anyURI?",
+    resolveUriFunction,
+  ),
+];

package/src/functions/xqueryModule.js

@@ -0,0 +1,24 @@
+/**
+ * fn:load-xquery-module (F&O 3.1, "Dynamic loading"): there is no XQuery
+ * processor, so every call raises FOQM0006 once its arguments are checked
+ * against the signature.
+ *
+ * @module @tradik/xslt3/functions/xqueryModule
+ */
+
+import { XPathError } from "../errors.js";
+import { define } from "./support.js";
+
+/**
+ * @returns {never}
+ * @throws {XPathError} FOQM0006
+ */
+function noXQuery() {
+  throw new XPathError("FOQM0006", "No XQuery processor is available");
+}
+
+/** Function definitions. */
+export const xqueryModuleFunctions = [
+  define("load-xquery-module", ["xs:string"], "map(*)", noXQuery),
+  define("load-xquery-module", ["xs:string", "map(*)"], "map(*)", noXQuery),
+];

package/src/index.js

@@ -0,0 +1,38 @@
+/**
+ * @tradik/xslt3: XSLT 3.0 and XPath 3.1 in JavaScript (in development).
+ *
+ * One engine for XSLT 3.0 and 2.0 stylesheets, and 1.0 ones in
+ * backwards-compatible mode; see docs/XSLT3.md for the design and the
+ * milestones. Public so far: XPath 3.1 (compileXPath, evaluateXPath) and
+ * Serialization 3.1 (serialize, serializeChunks, serializeToBytes) and
+ * XSLT (compileStylesheet, XSLTProcessor).
+ *
+ * @module @tradik/xslt3
+ */
+
+/** Version of this package, kept equal to package.json. */
+export const VERSION = "1.0.0";
+
+export {
+  compileXPath,
+  createFunctionLibrary,
+  defaultFunctionLibrary,
+  evaluateXPath,
+  FunctionLibrary,
+  readFileUri,
+  XPathError,
+} from "./xpath/index.js";
+
+export {
+  serialize,
+  serializeChunks,
+  serializeToBytes,
+} from "./serialize/index.js";
+
+export {
+  CompiledStylesheet,
+  compileStylesheet,
+  untypedAtomic,
+  versionMatches,
+  XSLTProcessor,
+} from "./xslt/index.js";

package/src/items/array.js

@@ -0,0 +1,84 @@
+/**
+ * Arrays of XDM 3.1: immutable lists of members, each member a sequence.
+ * An array is also a function of arity 1 from a position (xs:integer,
+ * starting at 1) to the member there.
+ *
+ * @module @tradik/xslt3/items/array
+ */
+
+import { XPathError } from "../errors.js";
+import { ITEM_KIND } from "../xdm/atomic.js";
+import { cast } from "../xdm/cast.js";
+import { atomize } from "../xdm/nodes.js";
+import { derivesFrom, types } from "../xdm/types.js";
+
+/** An immutable XDM array. */
+export class XdmArray {
+  /**
+   * @param {Array<Array>} [members] - Members (sequences); owned by the array
+   */
+  constructor(members = []) {
+    this.members = members;
+    Object.freeze(this);
+  }
+
+  /** @returns {"array"} the item kind */
+  get [ITEM_KIND]() {
+    return "array";
+  }
+
+  /** @returns {number} 1: an array is a function of one position */
+  get arity() {
+    return 1;
+  }
+
+  /** @returns {null} arrays are anonymous functions */
+  get name() {
+    return null;
+  }
+
+  /** @returns {number} number of members */
+  get size() {
+    return this.members.length;
+  }
+
+  /**
+   * Member at a position.
+   * @param {bigint|number} position - 1-based
+   * @returns {Array} the member
+   * @throws {XPathError} FOAY0001 when the position is out of bounds
+   */
+  get(position) {
+    const index = Number(position) - 1;
+    if (!(index >= 0 && index < this.members.length)) {
+      throw new XPathError(
+        "FOAY0001",
+        `Array index ${position} is out of bounds (size ${this.members.length})`,
+      );
+    }
+    return this.members[index];
+  }
+
+  /**
+   * Calls the array as a function: `$array($position)`.
+   * @param {Array<Array>} args - One argument: a single xs:integer
+   *   (xs:untypedAtomic is cast)
+   * @returns {Array} the member
+   * @throws {XPathError} XPTY0004 for another argument, FOAY0001 when out
+   *   of bounds
+   */
+  invoke(args) {
+    const values = atomize(args[0]);
+    let position = values[0];
+    if (values.length === 1 && position.type === types.untypedAtomic) {
+      position = cast(position, types.integer);
+    }
+    if (values.length !== 1 || !derivesFrom(position.type, types.integer)) {
+      throw new XPathError(
+        "XPTY0004",
+        "An array lookup needs exactly one xs:integer",
+      );
+    }
+    return this.get(position.value);
+  }
+}

package/src/items/function.js

@@ -0,0 +1,45 @@
+/**
+ * Function items of XDM 3.1 other than maps and arrays: named function
+ * references, inline functions, partial applications and coerced functions.
+ *
+ * A function item is self-contained: `invoke(args)` applies the function
+ * conversion rules to its arguments and checks its result, using the
+ * static and dynamic context captured when the item was created.
+ *
+ * @module @tradik/xslt3/items/function
+ */
+
+import { ITEM_KIND } from "../xdm/atomic.js";
+
+/**
+ * Signature of a function item.
+ * @typedef {object} Signature
+ * @property {object[]} params - Compiled sequence types of the parameters
+ *   (see xpath/eval/sequenceType.js)
+ * @property {object} returns - Compiled sequence type of the result
+ */
+
+/** A function item. */
+export class FunctionItem {
+  /**
+   * @param {object} init
+   * @param {import("../xdm/qname.js").QNameValue|null} [init.name] - Name,
+   *   null for anonymous functions
+   * @param {number} init.arity - Number of parameters
+   * @param {Signature} init.signature - Parameter and result types
+   * @param {(args: Array<Array>) => Array} init.invoke - Implementation,
+   *   called with one sequence per parameter
+   */
+  constructor({ name = null, arity, signature, invoke }) {
+    this.name = name;
+    this.arity = arity;
+    this.signature = signature;
+    this.invoke = invoke;
+    Object.freeze(this);
+  }
+
+  /** @returns {"function"} the item kind */
+  get [ITEM_KIND]() {
+    return "function";
+  }
+}

package/src/items/map.js

@@ -0,0 +1,120 @@
+/**
+ * Maps of XDM 3.1: immutable sets of entries from atomic keys (compared
+ * with op:same-key, see mapKey.js) to sequences. A map is also a function
+ * of arity 1 that returns the value of a key, or the empty sequence.
+ *
+ * Entries keep their insertion order, which XDM leaves
+ * implementation-dependent.
+ *
+ * @module @tradik/xslt3/items/map
+ */
+
+import { XPathError } from "../errors.js";
+import { ITEM_KIND } from "../xdm/atomic.js";
+import { atomize } from "../xdm/nodes.js";
+import { mapKey } from "./mapKey.js";
+
+/** An immutable XDM map. */
+export class XdmMap {
+  /**
+   * @param {Map<string, {key: import("../xdm/atomic.js").AtomicValue, value: Array}>} [entries]
+   *   - Entries by key string; owned by the new map
+   */
+  constructor(entries = new Map()) {
+    this.entries = entries;
+    Object.freeze(this);
+  }
+
+  /** @returns {"map"} the item kind */
+  get [ITEM_KIND]() {
+    return "map";
+  }
+
+  /** @returns {number} 1: a map is a function of one key */
+  get arity() {
+    return 1;
+  }
+
+  /** @returns {null} maps are anonymous functions */
+  get name() {
+    return null;
+  }
+
+  /** @returns {number} number of entries */
+  get size() {
+    return this.entries.size;
+  }
+
+  /**
+   * Builds a map from key/value pairs; a later duplicate key replaces the
+   * earlier one unless `onDuplicate` throws.
+   * @param {Iterable<[import("../xdm/atomic.js").AtomicValue, Array]>} pairs
+   * @param {(key: import("../xdm/atomic.js").AtomicValue) => void} [onDuplicate]
+   * @returns {XdmMap}
+   */
+  static from(pairs, onDuplicate) {
+    const entries = new Map();
+    for (const [key, value] of pairs) {
+      const k = mapKey(key);
+      if (onDuplicate && entries.has(k)) onDuplicate(key);
+      entries.set(k, { key, value });
+    }
+    return new XdmMap(entries);
+  }
+
+  /**
+   * @param {import("../xdm/atomic.js").AtomicValue} key
+   * @returns {Array|undefined} the value of the key, undefined when absent
+   */
+  get(key) {
+    return this.entries.get(mapKey(key))?.value;
+  }
+
+  /** @param {import("../xdm/atomic.js").AtomicValue} key @returns {boolean} */
+  has(key) {
+    return this.entries.has(mapKey(key));
+  }
+
+  /** @returns {import("../xdm/atomic.js").AtomicValue[]} the keys */
+  keys() {
+    return [...this.entries.values()].map((entry) => entry.key);
+  }
+
+  /**
+   * @param {import("../xdm/atomic.js").AtomicValue} key
+   * @param {Array} value
+   * @returns {XdmMap} a copy with the entry added or replaced
+   */
+  put(key, value) {
+    const entries = new Map(this.entries);
+    entries.set(mapKey(key), { key, value });
+    return new XdmMap(entries);
+  }
+
+  /**
+   * @param {import("../xdm/atomic.js").AtomicValue[]} keys
+   * @returns {XdmMap} a copy without the keys
+   */
+  remove(keys) {
+    const entries = new Map(this.entries);
+    for (const key of keys) entries.delete(mapKey(key));
+    return new XdmMap(entries);
+  }
+
+  /**
+   * Calls the map as a function: `$map($key)`.
+   * @param {Array<Array>} args - One argument: a single atomic value
+   * @returns {Array} the value, or the empty sequence
+   * @throws {XPathError} XPTY0004 when the argument is not one atomic value
+   */
+  invoke(args) {
+    const key = atomize(args[0]);
+    if (key.length !== 1) {
+      throw new XPathError(
+        "XPTY0004",
+        "A map lookup needs exactly one atomic key",
+      );
+    }
+    return this.get(key[0]) ?? [];
+  }
+}

package/src/items/mapKey.js

@@ -0,0 +1,82 @@
+/**
+ * Map keys: the string under which a map stores an atomic key, equal for
+ * two keys exactly when they are the same key under op:same-key (F&O 3.1
+ * section 17.1.1):
+ *
+ * - strings, xs:anyURI and xs:untypedAtomic compare as codepoint strings;
+ * - numbers compare by exact mathematical value, whatever their type
+ *   (the double 0.1 is not the decimal 0.1), NaN is the same key as NaN;
+ * - dates and times are equal when they are the same instant, but a value
+ *   with a timezone is never the same key as one without;
+ * - durations compare by months and seconds, whatever their subtype;
+ * - other values are only the same key as values of the same primitive.
+ *
+ * @module @tradik/xslt3/items/mapKey
+ */
+
+import { Decimal } from "../xdm/decimal.js";
+import { formatHexBinary } from "../xdm/binary.js";
+import { localSeconds, timelineSeconds } from "../xdm/timeline.js";
+
+const stringLike = new Set(["string", "anyURI", "untypedAtomic"]);
+const numeric = new Set(["decimal", "float", "double"]);
+
+/**
+ * Exact decimal value of a finite double.
+ * @param {number} n
+ * @returns {Decimal}
+ */
+export function exactDecimal(n) {
+  const view = new DataView(new ArrayBuffer(8));
+  view.setFloat64(0, n);
+  const high = view.getUint32(0);
+  const biased = (high >>> 20) & 0x7ff;
+  const fraction = (BigInt(high & 0xfffff) << 32n) | BigInt(view.getUint32(4));
+  const mantissa = biased === 0 ? fraction : fraction | (1n << 52n);
+  const exponent = (biased === 0 ? 1 : biased) - 1075;
+  const signed = n < 0 ? -mantissa : mantissa;
+  if (exponent >= 0) return Decimal.of(signed << BigInt(exponent));
+  return Decimal.of(signed * 5n ** BigInt(-exponent), -exponent);
+}
+
+/**
+ * Key string of a numeric value.
+ * @param {bigint|Decimal|number} value
+ * @returns {string}
+ */
+function numericKey(value) {
+  if (typeof value === "bigint") return `n${value}`;
+  if (typeof value === "object") return `n${value}`;
+  if (Number.isNaN(value)) return "nNaN";
+  if (!Number.isFinite(value)) return value > 0 ? "nINF" : "n-INF";
+  return `n${exactDecimal(value)}`;
+}
+
+/**
+ * Key string of an atomic map key.
+ * @param {import("../xdm/atomic.js").AtomicValue} key
+ * @returns {string}
+ */
+export function mapKey(key) {
+  const primitive = key.type.primitive.localName;
+  const { value } = key;
+  if (stringLike.has(primitive)) return `s${value}`;
+  if (numeric.has(primitive)) return numericKey(value);
+  switch (primitive) {
+    case "boolean":
+      return `b${value}`;
+    case "duration":
+      return `d${value.months}:${value.seconds}`;
+    case "hexBinary":
+    case "base64Binary":
+      return `${primitive}${formatHexBinary(value)}`;
+    case "QName":
+    case "NOTATION":
+      return `${primitive}{${value.namespaceURI}}${value.localName}`;
+    default: {
+      const zoned = value.timezone !== null;
+      const seconds = zoned ? timelineSeconds(value, 0) : localSeconds(value);
+      return `${primitive}${zoned ? "Z" : "L"}${seconds}`;
+    }
+  }
+}

package/src/serialize/index.js

@@ -0,0 +1,129 @@
+/**
+ * XSLT and XQuery Serialization 3.1: turns an XDM sequence into text with
+ * the xml, xhtml, html, text, json or adaptive output method.
+ *
+ * ```js
+ * serialize(items, { method: "xml", indent: true }); // a string
+ * for (const chunk of serializeChunks(items, { method: "html" })) write(chunk);
+ * serializeToBytes(items, { encoding: "UTF-16" }); // a Uint8Array
+ * ```
+ *
+ * Parameters are given by their camelCase names (`omitXmlDeclaration`) or
+ * the hyphenated names of the specification (`"omit-xml-declaration"`);
+ * see params/settings.js for the values and the defaults. Errors are
+ * XPathErrors with the codes of Serialization 3.1 (SENR0001, SERE00xx,
+ * SEPM00xx, SESU00xx).
+ *
+ * @module @tradik/xslt3/serialize
+ */
+
+import { DEFAULT_CHUNK_SIZE, OutputBuffer } from "./output/buffer.js";
+import { encodeText } from "./output/encoding.js";
+import { Expander } from "./output/expander.js";
+import { MarkupWriter } from "./markup/writer.js";
+import { AdaptiveWriter } from "./methods/adaptive.js";
+import { JsonWriter } from "./methods/json.js";
+import { writeText } from "./methods/text.js";
+import { normalizeSettings } from "./params/settings.js";
+import { normalizeSequence } from "./sequence.js";
+
+export { DEFAULT_CHUNK_SIZE } from "./output/buffer.js";
+export { normalizeSettings } from "./params/settings.js";
+export { OUTPUT_NAMESPACE } from "./params/names.js";
+
+/**
+ * @param {*} value - A sequence (JS array) or a single item
+ * @returns {Array}
+ */
+const toSequence = (value) => (Array.isArray(value) ? value : [value]);
+
+/**
+ * Serializes nodes inside JSON or adaptive output: a whole serialization
+ * with another method, without an XML declaration.
+ * @param {import("./params/settings.js").Settings} settings
+ * @param {string} method
+ * @returns {(node: Node) => string}
+ */
+const nodeSerializer = (settings, method) => (node) => {
+  const nested = { ...settings, method, omitXmlDeclaration: true };
+  return [...chunksOf([node], nested, new OutputBuffer(Infinity))].join("");
+};
+
+/**
+ * @param {Array} sequence
+ * @param {import("./params/settings.js").Settings} settings
+ * @param {OutputBuffer} buffer
+ * @yields {string} the output in chunks
+ * @returns {Generator<string, void, void>}
+ */
+function* chunksOf(sequence, settings, buffer) {
+  const { method } = settings;
+  if (method === "json") {
+    const node = nodeSerializer(settings, settings.jsonNodeOutputMethod);
+    const writer = new JsonWriter(settings, new Expander(settings), node);
+    buffer.write(writer.sequence(sequence, 0));
+  } else if (method === "adaptive") {
+    const writer = new AdaptiveWriter(
+      new Expander(settings),
+      nodeSerializer(settings, "xml"),
+    );
+    const separator = settings.itemSeparator ?? "\n";
+    sequence.forEach((item, index) => {
+      buffer.write((index ? separator : "") + writer.item(item));
+    });
+  } else {
+    const entries = normalizeSequence(sequence, settings.itemSeparator);
+    yield* method === "text"
+      ? writeText(entries, settings, buffer)
+      : new MarkupWriter(settings, buffer).run(entries);
+  }
+  const rest = buffer.take();
+  if (rest) yield rest;
+}
+
+/**
+ * Serializes a sequence in chunks, as the output is produced, so a large
+ * result can be streamed.
+ * @param {*} sequence - XDM items (array) or one item
+ * @param {Record<string, *>} [params] - Serialization parameters
+ * @param {{chunkSize?: number}} [options] - Chunk size in UTF-16 code
+ *   units (default {@link DEFAULT_CHUNK_SIZE}); a chunk can be longer
+ *   when one text node or attribute is
+ * @returns {Generator<string, void, void>} the chunks
+ * @throws {import("../errors.js").XPathError} serialization errors (on
+ *   creation for parameter errors, while iterating for the others)
+ */
+export function serializeChunks(sequence, params = {}, options = {}) {
+  const settings = normalizeSettings(params);
+  const buffer = new OutputBuffer(options.chunkSize ?? DEFAULT_CHUNK_SIZE);
+  return chunksOf(toSequence(sequence), settings, buffer);
+}
+
+/**
+ * Serializes a sequence to a string.
+ * @param {*} sequence - XDM items (array) or one item
+ * @param {Record<string, *>} [params] - Serialization parameters
+ * @returns {string}
+ * @throws {import("../errors.js").XPathError} serialization errors
+ * @example serialize([doc], { method: "xml", omitXmlDeclaration: true })
+ */
+export function serialize(sequence, params = {}) {
+  const settings = normalizeSettings(params);
+  const buffer = new OutputBuffer(Infinity);
+  return [...chunksOf(toSequence(sequence), settings, buffer)].join("");
+}
+
+/**
+ * Serializes a sequence to bytes in the requested encoding, with a byte
+ * order mark when byte-order-mark is set (by default for "UTF-16").
+ * @param {*} sequence - XDM items (array) or one item
+ * @param {Record<string, *>} [params] - Serialization parameters
+ * @returns {Uint8Array}
+ * @throws {import("../errors.js").XPathError} serialization errors
+ */
+export function serializeToBytes(sequence, params = {}) {
+  const settings = normalizeSettings(params);
+  const buffer = new OutputBuffer(Infinity);
+  const text = [...chunksOf(toSequence(sequence), settings, buffer)].join("");
+  return encodeText(text, settings.encoding, settings.byteOrderMark);
+}