@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/functions/strings.js

@@ -0,0 +1,194 @@
+/**
+ * Functions on strings (F&O 3.1 sections 5.2, 5.3 and 5.4): codepoints,
+ * comparison, substring, normalization, case mapping, translate and
+ * contains-token. Strings are handled as sequences of Unicode codepoints,
+ * not UTF-16 code units.
+ *
+ * @module @tradik/xslt3/functions/strings
+ */
+
+import { XPathError } from "../errors.js";
+import { normalizeWhitespace } from "../xdm/strings.js";
+import { collationArg } from "./collations.js";
+import {
+  booleanItem,
+  contextString,
+  define,
+  integerItem,
+  isXmlChar,
+  stringArg,
+  stringItem,
+} from "./support.js";
+
+/**
+ * fn:round on a double: nearest integer, halves toward positive infinity.
+ * @param {number} x
+ * @returns {number}
+ */
+export function roundHalfUp(x) {
+  const floor = Math.floor(x);
+  return x - floor >= 0.5 ? floor + 1 : floor;
+}
+
+/**
+ * The codepoints p (1-based) of a sequence of `length` codepoints with
+ * `round(start) <= p < round(start) + round(size)`, the selection rule of
+ * fn:substring and fn:subsequence (comparisons with NaN are false).
+ * @param {number} length
+ * @param {number} start
+ * @param {number} [size] - All remaining when undefined
+ * @returns {[number, number]} 0-based [from, to) slice bounds, from >= to
+ *   when nothing is selected
+ */
+export function selectRange(length, start, size) {
+  const first = roundHalfUp(start);
+  const end = size === undefined ? Infinity : first + roundHalfUp(size);
+  const from = Math.max(first, 1);
+  const to = Math.min(end, length + 1);
+  return from < to ? [from - 1, to - 1] : [0, 0];
+}
+
+/** @param {string} s @returns {string} XML whitespace collapsed */
+const collapse = (s) => normalizeWhitespace(s, "collapse");
+
+/** @param {string} s @returns {string[]} the codepoints as strings */
+const codepoints = (s) => Array.from(s);
+
+const NORMALIZATION_FORMS = new Set(["NFC", "NFD", "NFKC", "NFKD"]);
+
+/**
+ * fn:normalize-unicode.
+ * @param {string} text
+ * @param {string} form - Normalization form name (any case, trimmed)
+ * @returns {string}
+ * @throws {XPathError} FOCH0003 for another form than NFC, NFD, NFKC and
+ *   NFKD (FULLY-NORMALIZED is not supported: no normalization of a string
+ *   that starts with a composing character yields a fully-normalized one)
+ */
+function normalizeUnicode(text, form) {
+  const name = collapse(form).toUpperCase();
+  if (name === "") return text;
+  if (!NORMALIZATION_FORMS.has(name)) {
+    throw new XPathError("FOCH0003", `Unsupported normalization form ${form}`);
+  }
+  return text.normalize(name);
+}
+
+/**
+ * fn:translate.
+ * @param {string} text
+ * @param {string} mapString
+ * @param {string} transString
+ * @returns {string}
+ */
+function translate(text, mapString, transString) {
+  const map = new Map();
+  const replacements = codepoints(transString);
+  codepoints(mapString).forEach((char, i) => {
+    if (!map.has(char)) map.set(char, replacements[i] ?? "");
+  });
+  return codepoints(text)
+    .map((char) => map.get(char) ?? char)
+    .join("");
+}
+
+/**
+ * fn:compare.
+ * @param {Array<*>[]} args - [$a, $b, $collation?]
+ * @param {object} context
+ * @returns {Array<*>}
+ */
+function compare([a, b, collation], context) {
+  const { compare: order } = collationArg(collation, context);
+  if (a.length === 0 || b.length === 0) return [];
+  return [integerItem(order(a[0].value, b[0].value))];
+}
+
+/**
+ * fn:contains-token.
+ * @param {Array<*>[]} args - [$input, $token, $collation?]
+ * @param {object} context
+ * @returns {Array<*>}
+ */
+function containsToken([input, [token], collation], context) {
+  const { compare: order } = collationArg(collation, context);
+  const wanted = collapse(token.value);
+  if (wanted === "") return [booleanItem(false)];
+  const found = input.some((item) =>
+    collapse(item.value)
+      .split(" ")
+      .some((part) => order(part, wanted) === 0),
+  );
+  return [booleanItem(found)];
+}
+
+/**
+ * fn:substring.
+ * @param {Array<*>[]} args - [$source, $start, $length?]
+ * @returns {Array<*>}
+ */
+function substring([source, [start], length]) {
+  const chars = codepoints(stringArg(source));
+  const size = length === undefined ? undefined : length[0].value;
+  const [from, to] = selectRange(chars.length, start.value, size);
+  return [stringItem(chars.slice(from, to).join(""))];
+}
+
+const S = "xs:string";
+const S_OPT = "xs:string?";
+
+/** @type {import("./support.js").FunctionDefinition[]} */
+export const stringFunctions = [
+  define("codepoints-to-string", ["xs:integer*"], S, ([cps]) => [
+    stringItem(
+      cps
+        .map(({ value }) => {
+          const cp = Number(value);
+          if (!isXmlChar(cp)) {
+            throw new XPathError("FOCH0001", `Invalid codepoint ${value}`);
+          }
+          return String.fromCodePoint(cp);
+        })
+        .join(""),
+    ),
+  ]),
+  define("string-to-codepoints", [S_OPT], "xs:integer*", ([s]) =>
+    codepoints(stringArg(s)).map((c) => integerItem(c.codePointAt(0))),
+  ),
+  define("compare", [S_OPT, S_OPT], "xs:integer?", compare),
+  define("compare", [S_OPT, S_OPT, S], "xs:integer?", compare),
+  define("codepoint-equal", [S_OPT, S_OPT], "xs:boolean?", ([a, b]) =>
+    a.length === 0 || b.length === 0
+      ? []
+      : [booleanItem(a[0].value === b[0].value)],
+  ),
+  define("substring", [S_OPT, "xs:double"], S, substring),
+  define("substring", [S_OPT, "xs:double", "xs:double"], S, substring),
+  define(
+    "normalize-space",
+    [],
+    S,
+    (_args, context) => [stringItem(collapse(contextString(context)))],
+    { focus: true },
+  ),
+  define("normalize-space", [S_OPT], S, ([s]) => [
+    stringItem(collapse(stringArg(s))),
+  ]),
+  define("normalize-unicode", [S_OPT], S, ([s]) => [
+    stringItem(normalizeUnicode(stringArg(s), "NFC")),
+  ]),
+  define("normalize-unicode", [S_OPT, S], S, ([s, [form]]) => [
+    stringItem(normalizeUnicode(stringArg(s), form.value)),
+  ]),
+  define("upper-case", [S_OPT], S, ([s]) => [
+    stringItem(stringArg(s).toUpperCase()),
+  ]),
+  define("lower-case", [S_OPT], S, ([s]) => [
+    stringItem(stringArg(s).toLowerCase()),
+  ]),
+  define("translate", [S_OPT, S, S], S, ([s, [map], [trans]]) => [
+    stringItem(translate(stringArg(s), map.value, trans.value)),
+  ]),
+  define("contains-token", ["xs:string*", S], "xs:boolean", containsToken),
+  define("contains-token", ["xs:string*", S, S], "xs:boolean", containsToken),
+];

package/src/functions/stringsCore.js

@@ -0,0 +1,66 @@
+/**
+ * fn:concat, fn:string-join and fn:string-length (F&O 3.1 5.4.1 to 5.4.4).
+ *
+ * The evaluator's core library may define these functions itself; this
+ * array exists so they are available either way. Register it only for the
+ * names the core library leaves out, to avoid duplicate definitions.
+ *
+ * @module @tradik/xslt3/functions/stringsCore
+ */
+
+import { canonicalString } from "../xdm/lexical.js";
+import {
+  contextString,
+  define,
+  integerItem,
+  stringArg,
+  stringItem,
+} from "./support.js";
+
+/** @param {Array<*>} sequence @returns {string} "" or the canonical string */
+const optionalString = (sequence) =>
+  sequence.length === 0 ? "" : canonicalString(sequence[0]);
+
+/** @param {string} s @returns {number} length in codepoints */
+const codepointLength = (s) => {
+  let length = 0;
+  for (const _char of s) length++;
+  return length;
+};
+
+/**
+ * fn:string-join.
+ * @param {Array<*>[]} args - [$arg1, $arg2?]
+ * @returns {Array<*>}
+ */
+const stringJoin = ([items, separator = []]) => [
+  stringItem(items.map(canonicalString).join(stringArg(separator))),
+];
+
+/** @type {import("./support.js").FunctionDefinition[]} */
+export const coreStringFunctions = [
+  define(
+    "concat",
+    ["xs:anyAtomicType?", "xs:anyAtomicType?"],
+    "xs:string",
+    (args) => [stringItem(args.map(optionalString).join(""))],
+    { variadic: true },
+  ),
+  define("string-join", ["xs:anyAtomicType*"], "xs:string", stringJoin),
+  define(
+    "string-join",
+    ["xs:anyAtomicType*", "xs:string"],
+    "xs:string",
+    stringJoin,
+  ),
+  define(
+    "string-length",
+    [],
+    "xs:integer",
+    (_args, context) => [integerItem(codepointLength(contextString(context)))],
+    { focus: true },
+  ),
+  define("string-length", ["xs:string?"], "xs:integer", ([s]) => [
+    integerItem(codepointLength(stringArg(s))),
+  ]),
+];

package/src/functions/support.js

@@ -0,0 +1,106 @@
+/**
+ * Shared helpers of the function modules: namespaces, a compact way to
+ * declare {@link FunctionDefinition}s and constructors of the atomic
+ * results the functions return.
+ *
+ * @module @tradik/xslt3/functions/support
+ */
+
+import { XPathError } from "../errors.js";
+import { AtomicValue } from "../xdm/atomic.js";
+import { Decimal } from "../xdm/decimal.js";
+import { stringValue } from "../xdm/nodes.js";
+import { types } from "../xdm/types.js";
+
+/** Namespace of the standard functions (prefix fn). */
+export const FN_NAMESPACE = "http://www.w3.org/2005/xpath-functions";
+/** Namespace of the math functions (prefix math). */
+export const MATH_NAMESPACE = "http://www.w3.org/2005/xpath-functions/math";
+
+/**
+ * A built-in function of one arity, as consumed by the function registry.
+ * @typedef {object} FunctionDefinition
+ * @property {string} [namespace] - Defaults to {@link FN_NAMESPACE}
+ * @property {string} local - Local name, e.g. "upper-case"
+ * @property {string[]} params - Parameter sequence types, e.g. ["xs:string?"]
+ * @property {string} returns - Result sequence type
+ * @property {boolean} [variadic] - The last parameter repeats
+ * @property {boolean} [focus] - Needs the focus (context item, position, size)
+ * @property {(args: Array<Array<*>>, context: object) => Array<*>} impl
+ */
+
+/**
+ * Declares a function of the fn namespace.
+ * @param {string} local
+ * @param {string[]} params
+ * @param {string} returns
+ * @param {FunctionDefinition["impl"]} impl
+ * @param {Partial<FunctionDefinition>} [extra] - namespace, focus, variadic
+ * @returns {FunctionDefinition}
+ */
+export function define(local, params, returns, impl, extra = {}) {
+  return Object.freeze({
+    namespace: FN_NAMESPACE,
+    local,
+    params,
+    returns,
+    impl,
+    ...extra,
+  });
+}
+
+/** @param {string} s @returns {AtomicValue} an xs:string */
+export const stringItem = (s) => new AtomicValue(types.string, s);
+/** @param {boolean} b @returns {AtomicValue} an xs:boolean */
+export const booleanItem = (b) => new AtomicValue(types.boolean, b);
+/** @param {number} n @returns {AtomicValue} an xs:double */
+export const doubleItem = (n) => new AtomicValue(types.double, n);
+/** @param {bigint|number} n @returns {AtomicValue} an xs:integer */
+export const integerItem = (n) => new AtomicValue(types.integer, BigInt(n));
+/** @param {Decimal} d @returns {AtomicValue} an xs:decimal */
+export const decimalItem = (d) => new AtomicValue(types.decimal, d);
+
+/**
+ * @param {number} cp
+ * @returns {boolean} whether the codepoint is an XML 1.0 Char
+ */
+export const isXmlChar = (cp) =>
+  cp === 0x9 ||
+  cp === 0xa ||
+  cp === 0xd ||
+  (cp >= 0x20 && cp <= 0xd7ff) ||
+  (cp >= 0xe000 && cp <= 0xfffd) ||
+  (cp >= 0x10000 && cp <= 0x10ffff);
+
+/**
+ * The string of an optional xs:string argument ("" for the empty sequence).
+ * @param {Array<AtomicValue>} sequence
+ * @returns {string}
+ */
+export const stringArg = (sequence) => sequence[0]?.value ?? "";
+
+/**
+ * Numeric value of an atomic number as a JS double.
+ * @param {AtomicValue} item - xs:integer, xs:decimal, xs:float or xs:double
+ * @returns {number}
+ */
+export function toDouble(item) {
+  const { value } = item;
+  if (typeof value === "number") return value;
+  return value instanceof Decimal ? value.toNumber() : Number(value);
+}
+
+/**
+ * String value of the context item, for the zero-argument forms that
+ * default to it (fn:normalize-space(), fn:string-length()).
+ * @param {{contextItem?: *}} context
+ * @returns {string}
+ * @throws {XPathError} XPDY0002 when the context item is absent,
+ *   FOTY0014 for function items
+ */
+export function contextString(context) {
+  if (context.contextItem === undefined || context.contextItem === null) {
+    throw new XPathError("XPDY0002", "The context item is absent");
+  }
+  return stringValue(context.contextItem);
+}

package/src/functions/textDecoding.js

@@ -0,0 +1,117 @@
+/**
+ * Decoding of the text resources read by fn:unparsed-text and its family
+ * (F&O 3.1 section 14.6.1): the encoding comes from a byte order mark,
+ * else from external information (the loader's `encoding`), else from the
+ * XML declaration of an XML media type, else from the `$encoding`
+ * argument, else UTF-8.
+ *
+ * @module @tradik/xslt3/functions/textDecoding
+ */
+
+import { XPathError } from "../errors.js";
+
+/** A character that is not an XML 1.0 Char (lone surrogates included). */
+const NON_XML = /[^\t\n\r\x20-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/u;
+
+/**
+ * What a text loader returns: the text itself, its bytes, or either with
+ * external encoding information and a media type.
+ * @typedef {string|Uint8Array|ArrayBuffer|{content: string|Uint8Array|ArrayBuffer, encoding?: string, mediaType?: string}} TextResource
+ */
+
+/**
+ * The encoding a byte order mark announces.
+ * @param {Uint8Array} bytes
+ * @returns {string|null}
+ */
+function bomEncoding(bytes) {
+  if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+    return "utf-8";
+  }
+  if (bytes[0] === 0xfe && bytes[1] === 0xff) return "utf-16be";
+  if (bytes[0] === 0xff && bytes[1] === 0xfe) return "utf-16le";
+  return null;
+}
+
+/**
+ * The encoding of an XML document without byte order mark: UTF-16 by its
+ * first bytes, else the encoding declaration, else UTF-8.
+ * @param {Uint8Array} bytes
+ * @returns {string}
+ */
+function xmlEncoding(bytes) {
+  if (bytes[0] === 0x3c && bytes[1] === 0) return "utf-16le";
+  if (bytes[0] === 0 && bytes[1] === 0x3c) return "utf-16be";
+  const head = String.fromCharCode(...bytes.subarray(0, 200));
+  return (
+    /^<\?xml[^>]*?encoding\s*=\s*["']([^"']*)["']/.exec(head)?.[1] ?? "utf-8"
+  );
+}
+
+/** @param {string} [type] @returns {boolean} whether it is an XML media type */
+const isXmlMediaType = (type) =>
+  /^(?:text|application)\/(?:[\w.-]+\+)?xml\b/i.test(type ?? "");
+
+/**
+ * A fatal TextDecoder; "utf-16" without byte order mark is big-endian.
+ * @param {string} label
+ * @returns {TextDecoder}
+ * @throws {XPathError} FOUT1190 for an unsupported encoding
+ */
+export function textDecoder(label) {
+  const name = /^utf-?16$/i.test(label.trim()) ? "utf-16be" : label;
+  try {
+    return new globalThis.TextDecoder(name, { fatal: true });
+  } catch (error) {
+    throw new XPathError("FOUT1190", `Unsupported encoding ${label}`, {
+      cause: error,
+    });
+  }
+}
+
+/**
+ * Decodes a text resource and checks its characters.
+ * @param {TextResource} resource
+ * @param {string} [encoding] - The `$encoding` argument
+ * @returns {string} the text, without byte order mark
+ * @throws {XPathError} FOUT1190 for an unsupported encoding, bytes that
+ *   do not decode or characters that are not XML characters; FOUT1200
+ *   when UTF-8, the encoding assumed for want of any information, fails
+ */
+export function decodeText(resource, encoding) {
+  const requested = encoding === undefined ? null : textDecoder(encoding);
+  const plain =
+    typeof resource === "string" ||
+    resource instanceof Uint8Array ||
+    resource instanceof ArrayBuffer;
+  const {
+    content,
+    encoding: external,
+    mediaType,
+  } = plain ? { content: resource } : resource;
+  let text;
+  if (typeof content === "string") {
+    text = content;
+  } else {
+    const bytes = new Uint8Array(content);
+    const label =
+      bomEncoding(bytes) ??
+      external ??
+      (isXmlMediaType(mediaType) ? xmlEncoding(bytes) : null);
+    const decoder = label ? textDecoder(label) : requested;
+    try {
+      text = (decoder ?? textDecoder("utf-8")).decode(bytes);
+    } catch (error) {
+      throw new XPathError(
+        decoder ? "FOUT1190" : "FOUT1200",
+        `The resource is not ${decoder?.encoding ?? "utf-8"} text`,
+        { cause: error },
+      );
+    }
+  }
+  text = text.replace(/^\uFEFF/, "");
+  if (NON_XML.test(text)) {
+    throw new XPathError("FOUT1190", "The resource has a non-XML character");
+  }
+  return text;
+}

package/src/functions/ucaCollation.js

@@ -0,0 +1,127 @@
+/**
+ * The UCA collation family (F&O 3.1 section 5.3.4) on top of
+ * `Intl.Collator`, which the `fallback=yes` default allows: `lang`,
+ * `strength`, `numeric`, `caseFirst` and `alternate` are honoured, the
+ * quaternary and identical strengths through a tie-break.
+ *
+ * @module @tradik/xslt3/functions/ucaCollation
+ */
+
+import { XPathError } from "../errors.js";
+import { compareCodepoints } from "../xdm/strings.js";
+
+/** @typedef {import("./collations.js").Collation} Collation */
+
+const strengths = {
+  primary: "base",
+  1: "base",
+  secondary: "accent",
+  2: "accent",
+  tertiary: "variant",
+  3: "variant",
+};
+
+/**
+ * UCA parameters that Intl.Collator honours, with their valid values
+ * (null: any value).
+ */
+const SUPPORTED = new Map([
+  ["fallback", ["yes", "no"]],
+  ["lang", null],
+  [
+    "strength",
+    Object.keys(strengths).concat(["quaternary", "identical", "4", "5"]),
+  ],
+  ["numeric", ["yes", "no"]],
+  ["caseFirst", ["upper", "lower"]],
+  ["alternate", ["non-ignorable", "shifted", "blanked"]],
+]);
+
+/**
+ * Whether a UCA parameter is honoured with this value.
+ * @param {string} key
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isSupported(key, value) {
+  if (!SUPPORTED.has(key)) return false;
+  const values = SUPPORTED.get(key);
+  return values === null || values.includes(value);
+}
+
+/**
+ * The comparison of strings that the collator finds equal, for the levels
+ * Intl.Collator lacks: at strength identical any difference counts (the
+ * NFD forms compared by codepoint, UTS #10 section 4.3); at strength
+ * quaternary with alternate=shifted, the ignored variable characters
+ * count (with alternate=blanked they stay ignored).
+ * @param {string|undefined} strength
+ * @param {string|undefined} alternate
+ * @param {Intl.Collator} collator
+ * @returns {(a: string, b: string) => number}
+ */
+function tieBreaker(strength, alternate, collator) {
+  if (strength === "identical" || strength === "5") {
+    return (a, b) => compareCodepoints(a.normalize("NFD"), b.normalize("NFD"));
+  }
+  if (
+    (strength === "quaternary" || strength === "4") &&
+    alternate === "shifted"
+  ) {
+    const { locale, ...options } = collator.resolvedOptions();
+    const full = new Intl.Collator(locale, {
+      ...options,
+      ignorePunctuation: false,
+    });
+    return (a, b) => Math.sign(full.compare(a, b));
+  }
+  return () => 0;
+}
+
+/**
+ * Builds a collation from a UCA collation URI with `Intl.Collator`. Only
+ * `lang`, `strength`, `numeric`, `caseFirst` and `alternate` (as
+ * ignorePunctuation) are honoured; the others fall back to the defaults.
+ * @param {string} uri
+ * @returns {Collation}
+ * @throws {XPathError} FOCH0002 when `fallback=no` asks for an unsupported
+ *   parameter or value
+ */
+export function ucaCollation(uri) {
+  const query = uri.includes("?") ? uri.slice(uri.indexOf("?") + 1) : "";
+  const params = new Map(
+    query
+      .split(";")
+      .filter(Boolean)
+      .map((pair) => pair.split("=")),
+  );
+  if (
+    params.get("fallback") === "no" &&
+    [...params].some(([key, value]) => !isSupported(key, value))
+  ) {
+    throw new XPathError("FOCH0002", `Unsupported collation ${uri}`);
+  }
+  const caseFirst = params.get("caseFirst");
+  const options = {
+    sensitivity: strengths[params.get("strength")] ?? "variant",
+    numeric: params.get("numeric") === "yes",
+    caseFirst:
+      caseFirst === "upper" || caseFirst === "lower" ? caseFirst : "false",
+    ignorePunctuation: ["blanked", "shifted"].includes(params.get("alternate")),
+  };
+  let collator;
+  try {
+    collator = new Intl.Collator(params.get("lang") || "en", options);
+  } catch {
+    collator = new Intl.Collator("en", options);
+  }
+  const strength = params.get("strength");
+  const tieBreak = tieBreaker(strength, params.get("alternate"), collator);
+  return Object.freeze({
+    uri,
+    compare: (a, b) => Math.sign(collator.compare(a, b)) || tieBreak(a, b),
+    key: null,
+    // numeric collation units have no substrings ("10" is one unit)
+    substrings: !options.numeric,
+  });
+}

package/src/functions/unparsedText.js

@@ -0,0 +1,71 @@
+/**
+ * fn:unparsed-text, fn:unparsed-text-lines and fn:unparsed-text-available
+ * (F&O 3.1 section 14.6), through the dynamic context hook `loadText`
+ * (see xpath/eval/resources.js for the loader and its default).
+ *
+ * @module @tradik/xslt3/functions/unparsedText
+ */
+
+import { booleanItem, define, stringItem } from "./support.js";
+
+/**
+ * Lines of a text: split at CRLF, CR or LF; a final line ending does not
+ * start an empty line.
+ * @param {string} text
+ * @returns {string[]}
+ */
+export function splitLines(text) {
+  if (text === "") return [];
+  const lines = text.split(/\r\n|\r|\n/);
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+
+/**
+ * Declares a function of the family in its two arities.
+ * @param {string} local
+ * @param {string} returns
+ * @param {(load: () => string) => Array} impl - Gets the loading of the
+ *   resource, not called for an empty href
+ * @param {Array} empty - Result for an empty href
+ * @returns {object[]}
+ */
+function family(local, returns, impl, empty) {
+  const run = ([href, encoding], context) =>
+    href.length
+      ? impl(() => context.loadText(href[0].value, encoding?.[0].value))
+      : empty;
+  return [
+    define(local, ["xs:string?"], returns, run),
+    define(local, ["xs:string?", "xs:string"], returns, run),
+  ];
+}
+
+/**
+ * fn:unparsed-text-available: whether loading succeeds (every error of
+ * the loading is a FOUT error).
+ * @param {() => string} load
+ * @returns {Array}
+ */
+function available(load) {
+  try {
+    load();
+    return [booleanItem(true)];
+  } catch {
+    return [booleanItem(false)];
+  }
+}
+
+/** Function definitions. */
+export const unparsedTextFunctions = [
+  ...family("unparsed-text", "xs:string?", (load) => [stringItem(load())], []),
+  ...family(
+    "unparsed-text-lines",
+    "xs:string*",
+    (load) => splitLines(load()).map(stringItem),
+    [],
+  ),
+  ...family("unparsed-text-available", "xs:boolean", available, [
+    booleanItem(false),
+  ]),
+];