@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/functions/baseUris.js

@@ -0,0 +1,82 @@
+/**
+ * Base URIs of nodes: the base URI recorded for document nodes that
+ * differ from their document URI (the documents of fn:parse-xml and
+ * fn:parse-xml-fragment have the static base URI as base URI and no
+ * document URI) and for constructed nodes, and the base URI of any node
+ * from these and xml:base attributes.
+ *
+ * @module @tradik/xslt3/functions/baseUris
+ */
+
+import { parentOf } from "../xpath/eval/domNodes.js";
+import { XML_NAMESPACE } from "../xpath/eval/namespaceNodes.js";
+import { resolveUri } from "../xpath/eval/uris.js";
+import { resolveUri as resolveReference } from "./uri.js";
+
+/** @type {WeakMap<object, string>} */
+const baseUris = new WeakMap();
+
+/**
+ * Records the base URI of a document node.
+ * @param {Node} node
+ * @param {string|undefined} uri - Nothing is recorded when undefined
+ * @returns {Node} the node
+ */
+export function setBaseUri(node, uri) {
+  if (uri !== undefined) baseUris.set(node, uri);
+  return node;
+}
+
+/**
+ * @param {Node} node
+ * @returns {string|undefined} the base URI recorded for the node
+ */
+export const recordedBaseUri = (node) => baseUris.get(node);
+
+/**
+ * An xml:base attribute resolved against the base URI of the parent
+ * (RFC 3986: an absolute URI stays as written).
+ * @param {string} value
+ * @param {string|undefined} base
+ * @returns {string}
+ */
+function resolveBase(value, base) {
+  try {
+    return base === undefined ? value : resolveReference(value, base);
+  } catch {
+    return resolveUri(value, base);
+  }
+}
+
+/**
+ * Base URI of a node: its xml:base attributes resolved against the
+ * document URI, or against the base URI recorded for a constructed node.
+ * Namespace nodes have none (XDM 3.1 section 6.6.2).
+ * @param {Node} node
+ * @returns {string|undefined}
+ */
+export function nodeBaseUri(node) {
+  if (node.nodeType === 13) return undefined;
+  const chain = [];
+  for (let n = node; n; n = parentOf(n)) chain.unshift(n);
+  let base;
+  for (const n of chain) {
+    const own =
+      recordedBaseUri(n) ??
+      (n.nodeType === 9 || n.nodeType === 11 ? documentUriOf(n) : undefined);
+    if (own !== undefined) base = own;
+    if (n.nodeType === 1 && n.hasAttributeNS(XML_NAMESPACE, "base")) {
+      base = resolveBase(n.getAttributeNS(XML_NAMESPACE, "base"), base);
+    }
+  }
+  return base;
+}
+
+/**
+ * @param {Node} node - A document node
+ * @returns {string|undefined} its URI, undefined when unknown
+ */
+export function documentUriOf(node) {
+  const uri = node.documentURI ?? node.URL;
+  return uri && uri !== "about:blank" ? uri : undefined;
+}

package/src/functions/collations.js

@@ -0,0 +1,127 @@
+/**
+ * Collations (F&O 3.1 section 5.3): the Unicode codepoint collation, the
+ * HTML ASCII case-insensitive collation and the UCA collation family,
+ * which falls back to `Intl.Collator` (allowed by `fallback=yes`, the
+ * default).
+ *
+ * @module @tradik/xslt3/functions/collations
+ */
+
+import { XPathError } from "../errors.js";
+import { compareCodepoints } from "../xdm/strings.js";
+import { resolveUri } from "../xpath/eval/uris.js";
+import { ucaCollation } from "./ucaCollation.js";
+
+/** URI of the Unicode codepoint collation, the default collation. */
+export const CODEPOINT_COLLATION =
+  "http://www.w3.org/2005/xpath-functions/collation/codepoint";
+/** URI of the HTML ASCII case-insensitive collation. */
+export const HTML_ASCII_COLLATION =
+  "http://www.w3.org/2005/xpath-functions/collation/html-ascii-case-insensitive";
+const UCA_PREFIX = "http://www.w3.org/2013/collation/UCA";
+
+/**
+ * A collation.
+ * @typedef {object} Collation
+ * @property {string} uri
+ * @property {(a: string, b: string) => number} compare - -1, 0 or 1
+ * @property {((s: string) => string)|null} key - Maps equal strings to the
+ *   same key, with the same length (for hashing and substring matching);
+ *   null when only `compare` is available
+ * @property {boolean} [substrings] - false when substring matching is not
+ *   supported
+ */
+
+/** @param {string} s @returns {string} A-Z mapped to a-z */
+const asciiLower = (s) => s.replace(/[A-Z]+/g, (m) => m.toLowerCase());
+
+const codepoint = Object.freeze({
+  uri: CODEPOINT_COLLATION,
+  compare: compareCodepoints,
+  key: (s) => s,
+});
+
+const htmlAscii = Object.freeze({
+  uri: HTML_ASCII_COLLATION,
+  compare: (a, b) => compareCodepoints(asciiLower(a), asciiLower(b)),
+  key: asciiLower,
+});
+
+/**
+ * Finds the first substring of `text` that is equal to `search` under a
+ * collation (the shortest one at the leftmost position).
+ * @param {Collation} collation
+ * @param {string} text
+ * @param {string} search
+ * @param {"start"|"end"|null} [anchor] - Require a match at an end
+ * @returns {[number, number]|null} [start, end) offsets, null when absent
+ * @throws {XPathError} FOCH0004 for collations without substring matching
+ */
+export function findSubstring(collation, text, search, anchor = null) {
+  if (collation.substrings === false) {
+    throw new XPathError(
+      "FOCH0004",
+      `The collation ${collation.uri} does not support substring matching`,
+    );
+  }
+  if (collation.key) {
+    const a = collation.key(text);
+    const b = collation.key(search);
+    const index =
+      anchor === "start"
+        ? a.startsWith(b)
+          ? 0
+          : -1
+        : anchor === "end"
+          ? a.endsWith(b)
+            ? a.length - b.length
+            : -1
+          : a.indexOf(b);
+    return index < 0 ? null : [index, index + b.length];
+  }
+  const starts = anchor === "start" ? [0] : [...Array(text.length + 1).keys()];
+  for (const start of starts) {
+    const ends =
+      anchor === "end" ? [text.length] : [...Array(text.length + 1).keys()];
+    for (const end of ends.filter((e) => e >= start)) {
+      if (collation.compare(text.slice(start, end), search) === 0) {
+        return [start, end];
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Resolves a collation URI.
+ * @param {string} [uri] - Collation URI, resolved against the static base
+ *   URI when relative; the default collation when absent
+ * @param {{defaultCollation?: string, staticBaseUri?: string}} [context]
+ * @returns {Collation}
+ * @throws {XPathError} FOCH0002 for an unsupported collation
+ */
+export function getCollation(uri, context = {}) {
+  const relative = uri !== undefined && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(uri);
+  const name =
+    (relative && context.staticBaseUri
+      ? resolveUri(uri, context.staticBaseUri)
+      : uri) ??
+    context.defaultCollation ??
+    CODEPOINT_COLLATION;
+  if (name === CODEPOINT_COLLATION) return codepoint;
+  if (name === HTML_ASCII_COLLATION) return htmlAscii;
+  if (name === UCA_PREFIX || name.startsWith(`${UCA_PREFIX}?`)) {
+    return ucaCollation(name);
+  }
+  throw new XPathError("FOCH0002", `Unsupported collation ${name}`);
+}
+
+/**
+ * The collation named by an optional xs:string argument.
+ * @param {Array<{value: string}>|undefined} sequence - The argument, or
+ *   undefined for an arity without collation
+ * @param {object} context
+ * @returns {Collation}
+ */
+export const collationArg = (sequence, context) =>
+  getCollation(sequence?.[0]?.value, context);

package/src/functions/collections.js

@@ -0,0 +1,84 @@
+/**
+ * fn:collection and fn:uri-collection (F&O 3.1 sections 14.6.6 and
+ * 14.6.7), through the dynamic context hook `collection` (see
+ * xpath/eval/resources.js), and fn:collation-key (section 5.3.6).
+ *
+ * @module @tradik/xslt3/functions/collections
+ */
+
+import { XPathError } from "../errors.js";
+import { AtomicValue, isNode } from "../xdm/atomic.js";
+import { types } from "../xdm/types.js";
+import { collationArg } from "./collations.js";
+import { define } from "./support.js";
+
+const encoder = new globalThis.TextEncoder();
+
+/**
+ * The items of a collection.
+ * @param {Array|undefined} uri - The optional argument
+ * @param {object} context
+ * @returns {Array}
+ */
+const items = (uri, context) => context.collection(uri?.[0]?.value ?? null);
+
+/**
+ * The URIs of a collection: document URIs of its document nodes, atomic
+ * items (xs:anyURI) as they are; other nodes have no URI.
+ * @param {Array|undefined} uri
+ * @param {object} context
+ * @returns {Array} xs:anyURI values
+ */
+function uris(uri, context) {
+  const result = [];
+  for (const item of items(uri, context)) {
+    const text = isNode(item)
+      ? item.nodeType === 9 && item.documentURI
+      : item.value;
+    if (text) result.push(new AtomicValue(types.anyURI, text));
+  }
+  return result;
+}
+
+/**
+ * fn:collation-key: the UTF-8 bytes of the collation key of a string,
+ * which order as the collation does (UTF-8 keeps the codepoint order).
+ * @param {string} text
+ * @param {import("./collations.js").Collation} collation
+ * @returns {AtomicValue} an xs:base64Binary
+ * @throws {XPathError} FOCH0002 for the UCA collations, whose keys
+ *   Intl.Collator does not expose
+ */
+function collationKey(text, collation) {
+  if (!collation.key) {
+    throw new XPathError(
+      "FOCH0002",
+      `No collation keys for the collation ${collation.uri}`,
+    );
+  }
+  return new AtomicValue(
+    types.base64Binary,
+    encoder.encode(collation.key(text)),
+  );
+}
+
+/** Function definitions. */
+export const collectionFunctions = [
+  define("collection", [], "item()*", (_, c) => items(undefined, c)),
+  define("collection", ["xs:string?"], "item()*", ([uri], c) => items(uri, c)),
+  define("uri-collection", [], "xs:anyURI*", (_, c) => uris(undefined, c)),
+  define("uri-collection", ["xs:string?"], "xs:anyURI*", ([uri], c) =>
+    uris(uri, c),
+  ),
+  define("collation-key", ["xs:string"], "xs:base64Binary", ([[key]], c) => [
+    collationKey(key.value, collationArg(undefined, c)),
+  ]),
+  define(
+    "collation-key",
+    ["xs:string", "xs:string"],
+    "xs:base64Binary",
+    ([[key], collation], c) => [
+      collationKey(key.value, collationArg(collation, c)),
+    ],
+  ),
+];

package/src/functions/context.js

@@ -0,0 +1,83 @@
+/**
+ * Functions on the dynamic context (F&O 3.1 section 15): the current date
+ * and time, the implicit timezone, the default collation and language,
+ * the static base URI. No environment variables are exposed to
+ * expressions (the set is implementation-dependent, and empty here).
+ *
+ * @module @tradik/xslt3/functions/context
+ */
+
+import { AtomicValue } from "../xdm/atomic.js";
+import { DateTimeValue } from "../xdm/datetime.js";
+import { Decimal } from "../xdm/decimal.js";
+import { DurationValue } from "../xdm/duration.js";
+import { types } from "../xdm/types.js";
+
+/**
+ * The current date/time projected onto some components.
+ * @param {DateTimeValue} now
+ * @param {string[]} components
+ * @returns {DateTimeValue}
+ */
+function project(now, components) {
+  const fields = { timezone: now.timezone };
+  for (const name of components) fields[name] = now[name];
+  return new DateTimeValue(fields);
+}
+
+/**
+ * Definition of a function of the context without parameters.
+ * @param {string} local
+ * @param {string} returns
+ * @param {(context: object) => Array} impl
+ * @returns {object}
+ */
+const contextFunction = (local, returns, impl) => ({
+  local,
+  params: [],
+  returns,
+  impl: (_, context) => impl(context),
+});
+
+/** Function definitions. */
+export const contextFunctions = [
+  contextFunction("current-dateTime", "xs:dateTimeStamp", (c) => [
+    new AtomicValue(types.dateTime, c.currentDateTime),
+  ]),
+  contextFunction("current-date", "xs:date", (c) => [
+    new AtomicValue(
+      types.date,
+      project(c.currentDateTime, ["year", "month", "day"]),
+    ),
+  ]),
+  contextFunction("current-time", "xs:time", (c) => [
+    new AtomicValue(
+      types.time,
+      project(c.currentDateTime, ["hour", "minute", "second"]),
+    ),
+  ]),
+  contextFunction("implicit-timezone", "xs:dayTimeDuration", (c) => [
+    new AtomicValue(
+      types.dayTimeDuration,
+      new DurationValue(0, Decimal.of(BigInt(c.implicitTimezone * 60))),
+    ),
+  ]),
+  contextFunction("default-collation", "xs:string", (c) => [
+    new AtomicValue(types.string, c.defaultCollation),
+  ]),
+  contextFunction("default-language", "xs:language", (c) => [
+    new AtomicValue(types.language, c.defaultLanguage),
+  ]),
+  contextFunction("available-environment-variables", "xs:string*", () => []),
+  {
+    local: "environment-variable",
+    params: ["xs:string"],
+    returns: "xs:string?",
+    impl: () => [],
+  },
+  contextFunction("static-base-uri", "xs:anyURI?", (c) =>
+    c.staticBaseUri === undefined
+      ? []
+      : [new AtomicValue(types.anyURI, c.staticBaseUri)],
+  ),
+];

package/src/functions/core.js

@@ -0,0 +1,167 @@
+/**
+ * The core functions of F&O 3.1 that depend on the evaluator: booleans,
+ * focus, string, data and number conversion, count, empty and exists.
+ * `coreFunctions` gathers these and the other modules of this package
+ * that depend on the evaluator or on the hooks of the dynamic context
+ * (nodes, higher-order functions, maps and arrays, JSON, resources,
+ * random numbers, IDs, collections).
+ *
+ * @module @tradik/xslt3/functions/core
+ */
+
+import { toNumber } from "../xdm/generalCompare.js";
+import { atomize, effectiveBooleanValue, stringValue } from "../xdm/nodes.js";
+import {
+  booleanItem,
+  doubleItem,
+  integerItem,
+  stringItem,
+} from "../xpath/eval/atomics.js";
+import { arrayFunctions } from "./arrays.js";
+import { contextFunctions } from "./context.js";
+import { higherOrderFunctions } from "./higherOrder.js";
+import { coreStringFunctions, libraryFunctions } from "./library.js";
+import { mapFunctions } from "./maps.js";
+import { nodeFunctions } from "./nodes.js";
+import { focusItem } from "./focus.js";
+import { diagnosticFunctions } from "./diagnostics.js";
+import { collectionFunctions } from "./collections.js";
+import { idFunctions } from "./ids.js";
+import { jsonFunctions } from "./json/index.js";
+import { parseXmlFunctions } from "./parseXml.js";
+import { randomFunctions } from "./random.js";
+import { unparsedTextFunctions } from "./unparsedText.js";
+import { xqueryModuleFunctions } from "./xqueryModule.js";
+
+/**
+ * fn:string of an optional item.
+ * @param {Array} arg
+ * @returns {Array} an xs:string
+ */
+const stringOf = (arg) => [stringItem(arg.length ? stringValue(arg[0]) : "")];
+
+/**
+ * fn:number of an optional atomic value.
+ * @param {Array} arg
+ * @returns {Array} an xs:double
+ */
+const numberOf = (arg) => [arg.length ? toNumber(arg[0]) : doubleItem(NaN)];
+
+/** Core function definitions. */
+export const coreBasics = [
+  {
+    local: "true",
+    params: [],
+    returns: "xs:boolean",
+    impl: () => [booleanItem(true)],
+  },
+  {
+    local: "false",
+    params: [],
+    returns: "xs:boolean",
+    impl: () => [booleanItem(false)],
+  },
+  {
+    local: "not",
+    params: ["item()*"],
+    returns: "xs:boolean",
+    impl: ([arg]) => [booleanItem(!effectiveBooleanValue(arg))],
+  },
+  {
+    local: "boolean",
+    params: ["item()*"],
+    returns: "xs:boolean",
+    impl: ([arg]) => [booleanItem(effectiveBooleanValue(arg))],
+  },
+  {
+    local: "position",
+    params: [],
+    returns: "xs:integer",
+    focus: true,
+    impl: (_, context) => (focusItem(context), [integerItem(context.position)]),
+  },
+  {
+    local: "last",
+    params: [],
+    returns: "xs:integer",
+    focus: true,
+    impl: (_, context) => (focusItem(context), [integerItem(context.size)]),
+  },
+  {
+    local: "string",
+    params: [],
+    returns: "xs:string",
+    focus: true,
+    impl: (_, context) => stringOf([focusItem(context)]),
+  },
+  {
+    local: "string",
+    params: ["item()?"],
+    returns: "xs:string",
+    impl: ([arg]) => stringOf(arg),
+  },
+  {
+    local: "data",
+    params: [],
+    returns: "xs:anyAtomicType*",
+    focus: true,
+    impl: (_, context) => atomize([focusItem(context)]),
+  },
+  {
+    local: "data",
+    params: ["item()*"],
+    returns: "xs:anyAtomicType*",
+    impl: ([arg]) => atomize(arg),
+  },
+  {
+    local: "number",
+    params: [],
+    returns: "xs:double",
+    focus: true,
+    impl: (_, context) => numberOf(atomize([focusItem(context)])),
+  },
+  {
+    local: "number",
+    params: ["xs:anyAtomicType?"],
+    returns: "xs:double",
+    impl: ([arg]) => numberOf(arg),
+  },
+  {
+    local: "count",
+    params: ["item()*"],
+    returns: "xs:integer",
+    impl: ([arg]) => [integerItem(arg.length)],
+  },
+  {
+    local: "empty",
+    params: ["item()*"],
+    returns: "xs:boolean",
+    impl: ([arg]) => [booleanItem(arg.length === 0)],
+  },
+  {
+    local: "exists",
+    params: ["item()*"],
+    returns: "xs:boolean",
+    impl: ([arg]) => [booleanItem(arg.length > 0)],
+  },
+];
+
+/** All the function definitions of this package's built-in modules. */
+export const coreFunctions = [
+  ...libraryFunctions,
+  ...coreStringFunctions,
+  ...coreBasics,
+  ...diagnosticFunctions,
+  ...contextFunctions,
+  ...nodeFunctions,
+  ...higherOrderFunctions,
+  ...mapFunctions,
+  ...arrayFunctions,
+  ...jsonFunctions,
+  ...unparsedTextFunctions,
+  ...xqueryModuleFunctions,
+  ...parseXmlFunctions,
+  ...randomFunctions,
+  ...idFunctions,
+  ...collectionFunctions,
+];