@tradik/xslt3 0.0.0-stage → 1.0.0

package/src/xslt/compiler/moduleLoading.js

@@ -0,0 +1,111 @@
+/**
+ * Loading of stylesheet modules for the static stage: the documents of
+ * xsl:import and xsl:include (cached by URI, so that a module is one tree
+ * however often it is referenced), loaded as soon as the reference is met
+ * so that the static variables of the module are in scope for what
+ * follows (XSLT 3.0 section 9.7).
+ *
+ * @module @tradik/xslt3/xslt/compiler/moduleLoading
+ */
+
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { attr, isXsl, xsltError } from "../names.js";
+import { infoOf, setModuleUri } from "./elementInfo.js";
+
+/**
+ * An embedded stylesheet module: the element of a document whose id is
+ * the fragment identifier of its URI.
+ * @param {Document} document
+ * @param {string} id
+ * @param {string} uri - For the error message
+ * @returns {Element}
+ */
+function embeddedStylesheet(document, id, uri) {
+  const stack = [document.documentElement];
+  while (stack.length > 0) {
+    const element = stack.pop();
+    if (element.getAttribute("id") === id) return element;
+    for (let child = element.lastChild; child; child = child.previousSibling) {
+      if (child.nodeType === 1) stack.push(child);
+    }
+  }
+  throw xsltError("XTSE0165", `No element with id ${id} in ${uri}`);
+}
+
+/**
+ * @param {Element} element
+ * @returns {boolean} whether an element is a top-level xsl:import or
+ *   xsl:include
+ */
+export const isModuleReference = (element) =>
+  (isXsl(element, "import") || isXsl(element, "include")) &&
+  isModuleRoot(element.parentNode);
+
+/**
+ * @param {Node} node
+ * @returns {boolean} whether a node is the root of a stylesheet module
+ */
+const isModuleRoot = (node) =>
+  isXsl(node, "stylesheet") ||
+  isXsl(node, "transform") ||
+  isXsl(node, "package");
+
+/**
+ * Loads the module of an xsl:import or xsl:include as soon as it is
+ * met, so that its static variables are in scope for what follows
+ * (XSLT 3.0 section 9.7); the module tree is built later from the same
+ * documents (modules.js).
+ * @param {object} stage - The static stage
+ * @param {Element} element - xsl:import or xsl:include
+ */
+export function preloadModule(stage, element) {
+  const href = attr(element, "href");
+  if (href === undefined) return;
+  const uri = resolveUri(href.trim(), infoOf(element).baseUri);
+  if (stage.preloading.has(uri)) return;
+  let loaded;
+  try {
+    loaded = stage.loadModule(uri, infoOf(element).baseUri);
+  } catch {
+    // reported when the module tree is built, after the checks of the
+    // element (modules.js)
+    return;
+  }
+  const root = loaded.nodeType === 9 ? loaded.documentElement : loaded;
+  if (!isModuleRoot(root)) return;
+  setModuleUri(root, uri);
+  stage.preloading.add(uri);
+  const imported = isXsl(element, "import");
+  if (imported) stage.importPath.push(stage.imports++);
+  if (stage.included(root)) stage.children(root);
+  if (imported) stage.importPath.pop();
+  stage.preloading.delete(uri);
+}
+
+/**
+ * Loads an included or imported module (`uri#id` for an embedded one).
+ * @param {object} stage - The static stage (`options`, `loadedModules`)
+ * @param {string} uri - Absolute URI
+ * @param {string} [base] - Base URI it was resolved against, passed on
+ *   to the `loadStylesheet` option
+ * @returns {Document|Element}
+ */
+export function loadModuleDocument(stage, uri, base) {
+  if (stage.loadedModules.has(uri)) return stage.loadedModules.get(uri);
+  const [location, fragment] = uri.split("#");
+  let document;
+  try {
+    document = stage.options.loadStylesheet?.(location, base);
+  } catch (error) {
+    throw xsltError("XTSE0165", `Cannot load ${uri}: ${error.message}`);
+  }
+  if (!document) throw xsltError("XTSE0165", `Cannot load ${uri}`);
+  if (typeof document === "string") {
+    document = stage.options.parse(document, location);
+  }
+  const module = fragment
+    ? embeddedStylesheet(document, fragment, uri)
+    : document;
+  stage.loadedModules.set(uri, module);
+  return module;
+}

package/src/xslt/compiler/modules.js

@@ -0,0 +1,158 @@
+/**
+ * Stylesheet modules (XSLT 3.0 sections 3.11 to 3.12): the principal
+ * module and the modules it includes and imports, loaded into a tree whose
+ * post-order numbering gives the import precedence of each declaration.
+ *
+ * @module @tradik/xslt3/xslt/compiler/modules
+ */
+
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { attr, isXsl, XSL_NS, xslAttr, xsltError } from "../names.js";
+import { setModuleUri } from "./elementInfo.js";
+import { checkAttributes, checkEmpty, required } from "./attributes.js";
+
+/**
+ * @typedef {object} ModuleNode
+ * @property {Element} root - xsl:stylesheet, xsl:transform or the literal
+ *   result element of a simplified stylesheet
+ * @property {string|undefined} uri
+ * @property {boolean} simplified
+ * @property {ModuleNode[]} imports
+ * @property {Element[]} declarations - Top-level elements, includes resolved
+ * @property {number} [precedence]
+ * @property {number} [importLow] - Lowest precedence of its import tree
+ */
+
+/** Roots of simplified stylesheet modules. */
+const simplifiedRoots = new WeakSet();
+
+/**
+ * The root element of a stylesheet module.
+ * @param {Document|Element} source
+ * @returns {{root: Element, simplified: boolean}}
+ */
+export function moduleRoot(source, principal = false) {
+  const root = source.nodeType === 9 ? source.documentElement : source;
+  if (!root) throw xsltError("XTSE0150", "The stylesheet is empty");
+  if (isXsl(root, "package") && !principal) {
+    throw xsltError("XTSE0165", "A package cannot be included or imported");
+  }
+  if (
+    isXsl(root, "stylesheet") ||
+    isXsl(root, "transform") ||
+    isXsl(root, "package")
+  ) {
+    if (attr(root, "version") === undefined && !root.hasAttribute("_version")) {
+      throw xsltError("XTSE0010", `xsl:${root.localName} requires a version`);
+    }
+    return { root, simplified: false };
+  }
+  if (root.namespaceURI === XSL_NS) {
+    throw xsltError("XTSE0150", `xsl:${root.localName} is not a stylesheet`);
+  }
+  if (xslAttr(root, "version") === undefined) {
+    throw xsltError(
+      "XTSE0150",
+      "A simplified stylesheet needs an xsl:version attribute",
+    );
+  }
+  return { root, simplified: true };
+}
+
+/**
+ * Loads the module tree.
+ * @param {Document|Element} source - Principal module
+ * @param {string|undefined} uri - Its URI
+ * @param {object} cx - Stylesheet compiler: `children(element)`,
+ *   `loadModule(uri)` (returns a Document), `moduleDocuments`
+ * @returns {ModuleNode}
+ */
+export function loadModuleTree(source, uri, cx) {
+  const active = [];
+  const load = (document, moduleUri, imported = false) => {
+    const { root, simplified } = moduleRoot(document, active.length === 0);
+    if (moduleUri !== undefined) {
+      if (active.includes(moduleUri)) {
+        throw imported
+          ? xsltError("XTSE0210", `${moduleUri} imports itself`)
+          : xsltError("XTSE0180", `${moduleUri} includes itself`);
+      }
+      cx.moduleDocuments.set(moduleUri, document.ownerDocument ?? document);
+    }
+    setModuleUri(root, moduleUri);
+    if (!simplified) checkAttributes(root);
+    const node = {
+      root,
+      uri: moduleUri,
+      simplified,
+      imports: [],
+      declarations: [],
+    };
+    if (simplified) {
+      simplifiedRoots.add(root);
+      node.declarations.push(root);
+      return node;
+    }
+    if (!cx.included(root)) return node;
+    active.push(moduleUri);
+    for (const child of cx.children(root)) {
+      if (child.nodeType === 3) {
+        throw xsltError("XTSE0120", "Text is not allowed at the top level");
+      }
+      const href = () => {
+        checkAttributes(child);
+        checkEmpty(child, cx);
+        return resolveUri(required(child, "href"), cx.baseUriOf(child));
+      };
+      const base = cx.baseUriOf(child);
+      // XSLT 3.0 allows xsl:import anywhere among the declarations
+      if (isXsl(child, "import")) {
+        const target = href();
+        node.imports.push(load(cx.loadModule(target, base), target, true));
+      } else if (isXsl(child, "include")) {
+        const target = href();
+        const included = load(cx.loadModule(target, base), target);
+        node.imports.push(...included.imports);
+        node.declarations.push(...included.declarations);
+      } else {
+        node.declarations.push(child);
+      }
+    }
+    active.pop();
+    return node;
+  };
+  const tree = load(source, uri);
+  let counter = 0;
+  const number = (node) => {
+    const low = counter;
+    for (const imported of node.imports) number(imported);
+    node.precedence = counter++;
+    node.importLow = low;
+  };
+  number(tree);
+  return tree;
+}
+
+/**
+ * The declarations of a module tree with their precedence, in
+ * declaration order (lowest precedence first).
+ * @param {ModuleNode} tree
+ * @returns {Array<{element: Element, precedence: number, importLow: number,
+ *   simplified: boolean}>}
+ */
+export function declarationsOf(tree) {
+  const result = [];
+  const visit = (node) => {
+    for (const imported of node.imports) visit(imported);
+    for (const element of node.declarations) {
+      result.push({
+        element,
+        precedence: node.precedence,
+        importLow: node.importLow,
+        simplified: simplifiedRoots.has(element),
+      });
+    }
+  };
+  visit(tree);
+  return result;
+}

package/src/xslt/compiler/outputDecl.js

@@ -0,0 +1,209 @@
+/**
+ * Declarations collected for serialization:
+ * xsl:output (XSLT 3.0 section 26) and xsl:character-map (26.1).
+ *
+ * @module @tradik/xslt3/xslt/compiler/outputDecl
+ */
+
+import { parametersFromElement } from "../../serialize/params/fromElement.js";
+import { resolveUri } from "../../xpath/eval/uris.js";
+import { clarkOf, isXsl, tokens, xsltError } from "../names.js";
+import { required } from "./attributes.js";
+
+/** xsl:output attributes whose value is a list of QNames. */
+const QNAME_LISTS = new Set(["cdata-section-elements", "suppress-indentation"]);
+
+/** The serialization methods of Serialization 3.1. */
+const METHODS = new Set(["xml", "html", "xhtml", "text", "json", "adaptive"]);
+
+/**
+ * The method parameter: a standard method, or a QName in Clark notation.
+ * @param {string} value
+ * @param {Element} element
+ * @param {object} cx
+ * @returns {string}
+ * @throws {import("../../errors.js").XPathError} XTSE1570 for an unknown
+ *   unprefixed method
+ */
+function outputMethod(value, element, cx) {
+  const method = value.trim();
+  if (METHODS.has(method)) return method;
+  if (!method.includes(":")) {
+    throw xsltError("XTSE1570", `Unknown output method ${method}`);
+  }
+  return clarkOf(cx.exprs.qname(method, element, { code: "XTSE1570" }));
+}
+
+/**
+ * The parameters of the parameter-document of an xsl:output, overridden
+ * by its attributes (Serialization 3.1 section 3.1).
+ * @param {Element} element
+ * @param {object} cx - Stylesheet compiler (`loadModule`, `baseUriOf`)
+ * @returns {Record<string, *>} parameters by name, none without the
+ *   attribute
+ */
+function parameterDocument(element, cx) {
+  const href = element.getAttribute("parameter-document");
+  if (!href) return {};
+  return readParameterDocument(href, element, cx);
+}
+
+/**
+ * The parameters of a serialization parameter document (xsl:output and
+ * xsl:result-document parameter-document).
+ * @param {string} href - URI reference, relative to the element's base
+ * @param {Element} element - The element that names the document
+ * @param {object} cx - Stylesheet compiler (`loadModule`, `baseUriOf`)
+ * @returns {Record<string, *>} parameters by name
+ */
+export function readParameterDocument(href, element, cx) {
+  const base = cx.baseUriOf(element);
+  const source = cx.loadModule(resolveUri(href.trim(), base), base);
+  const root = source.nodeType === 9 ? source.documentElement : source;
+  return parametersFromElement(root);
+}
+
+/**
+ * Collects the xsl:output declarations by name: the parameters of each
+ * name merged, higher precedence winning (XTSE1560 for a conflict at the
+ * same precedence).
+ * @param {object[]} declarations
+ * @param {object} cx
+ * @returns {Map<string, object>} parameters (spec names) by Clark name,
+ *   "" for the unnamed output definition
+ */
+export function collectOutputs(declarations, cx) {
+  const outputs = new Map();
+  const sources = new Map();
+  for (const { element, precedence } of declarations) {
+    const nameText = element.getAttribute("name");
+    const name = nameText ? clarkOf(cx.exprs.qname(nameText, element)) : "";
+    const params = outputs.get(name) ?? {};
+    const from = sources.get(name) ?? {};
+    const document = parameterDocument(element, cx);
+    for (const [key, value] of Object.entries(document)) {
+      if (!element.hasAttribute(key) && from[key] !== precedence) {
+        params[key] = value;
+        from[key] = precedence;
+      }
+    }
+    for (const attribute of element.attributes) {
+      const key = attribute.name;
+      if (
+        key === "name" ||
+        key === "parameter-document" ||
+        attribute.namespaceURI ||
+        key.startsWith("xmlns")
+      ) {
+        continue;
+      }
+      let value = attribute.value;
+      if (QNAME_LISTS.has(key)) {
+        const previous = params[key] ?? [];
+        const names = tokens(value).map((token) =>
+          clarkOf(cx.exprs.qname(token, element, { useDefault: true })),
+        );
+        params[key] = [...previous, ...names];
+        continue;
+      }
+      if (key === "use-character-maps") {
+        value = tokens(value).map((token) =>
+          clarkOf(cx.exprs.qname(token, element)),
+        );
+        params[key] = [...(params[key] ?? []), ...value];
+        continue;
+      }
+      if (key === "method") value = outputMethod(value, element, cx);
+      if (from[key] === precedence && params[key] !== value) {
+        throw xsltError(
+          "XTSE1560",
+          `Conflicting values of ${key} in xsl:output`,
+        );
+      }
+      if (from[key] === undefined || from[key] <= precedence) {
+        params[key] = value;
+        from[key] = precedence;
+      }
+    }
+    outputs.set(name, params);
+    sources.set(name, from);
+  }
+  return outputs;
+}
+
+/**
+ * Collects the character maps.
+ * @param {object[]} declarations
+ * @param {object} cx
+ * @returns {Map<string, {uses: string[], map: Map<string, string>}>}
+ */
+export function collectCharacterMaps(declarations, cx) {
+  const maps = new Map();
+  for (const { element, precedence } of declarations) {
+    const name = clarkOf(cx.exprs.qname(required(element, "name"), element));
+    const current = maps.get(name);
+    if (current?.precedence === precedence) {
+      throw xsltError("XTSE1580", `Two character maps are named ${name}`);
+    }
+    const map = new Map();
+    for (const child of cx.children(element)) {
+      if (child.nodeType !== 1 || !isXsl(child, "output-character")) {
+        throw xsltError(
+          "XTSE0010",
+          "xsl:character-map contains xsl:output-character",
+        );
+      }
+      const character = child.getAttribute("character");
+      if ([...character].length !== 1) {
+        throw xsltError("XTSE0020", "character must be a single character");
+      }
+      map.set(character, child.getAttribute("string"));
+    }
+    const uses = tokens(element.getAttribute("use-character-maps") || "").map(
+      (token) => clarkOf(cx.exprs.qname(token, element)),
+    );
+    // declarations come lowest precedence first: a later one wins
+    maps.set(name, { uses, map, precedence });
+  }
+  return maps;
+}
+
+/**
+ * Checks the character maps that maps and output definitions use: they
+ * exist (XTSE1590) and do not use themselves (XTSE1600).
+ * @param {Map<string, object>} outputs
+ * @param {Map<string, object>} maps
+ */
+export function checkCharacterMaps(outputs, maps) {
+  for (const name of maps.keys()) expandCharacterMaps([name], maps);
+  for (const output of outputs.values()) {
+    expandCharacterMaps(output["use-character-maps"] ?? [], maps);
+  }
+}
+
+/**
+ * Expands a list of character maps (with the maps they use) into one map.
+ * @param {string[]|Map<string, string>} names - Names, or a map already
+ * @param {Map<string, object>} maps
+ * @param {Set<string>} [active]
+ * @returns {Map<string, string>}
+ */
+export function expandCharacterMaps(names, maps, active = new Set()) {
+  // a parameter document gives the character map itself
+  if (names instanceof Map) return names;
+  const result = new Map();
+  for (const name of names) {
+    const entry = maps.get(name);
+    if (!entry) throw xsltError("XTSE1590", `No character map ${name}`);
+    if (active.has(name)) {
+      throw xsltError("XTSE1600", `The character map ${name} uses itself`);
+    }
+    active.add(name);
+    for (const [c, s] of expandCharacterMaps(entry.uses, maps, active)) {
+      result.set(c, s);
+    }
+    active.delete(name);
+    for (const [c, s] of entry.map) result.set(c, s);
+  }
+  return result;
+}

package/src/xslt/compiler/overrideLinks.js

@@ -0,0 +1,141 @@
+/**
+ * Overriding declarations (XSLT 3.0 sections 3.5.3.3 and 3.5.3.4)
+ * compiled into the component they override, so that the references of
+ * the used package reach them; the overridden body is kept for the name
+ * xsl:original, and template rules join the used package's mode.
+ *
+ * @module @tradik/xslt3/xslt/compiler/overrideLinks
+ */
+
+import { callFunction } from "../runtime/functionCall.js";
+import { ORIGINAL, XSL_NS, xsltError } from "../names.js";
+import { declareAttributeSet } from "../instructions/attributeSets.js";
+import { ExpressionCompiler } from "./expressions.js";
+import { compileFunction, functionSignature } from "./globals.js";
+import { LEVEL_PRECEDENCE } from "./packageTable.js";
+import { declareTemplate } from "./templatesDecl.js";
+
+/**
+ * Whether an overriding declaration refers to xsl:original.
+ * @param {Element} element
+ * @returns {boolean}
+ */
+export function usesOriginal(element) {
+  const stack = [element];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    for (const attribute of node.attributes) {
+      if (attribute.value.includes("xsl:original")) return true;
+    }
+    for (let c = node.firstChild; c; c = c.nextSibling) {
+      if (c.nodeType === 1) stack.push(c);
+    }
+  }
+  return false;
+}
+
+/**
+ * Compiles an overriding declaration while xsl:original names the
+ * overridden component.
+ * @param {object} cx
+ * @param {object} entry - `{kind, key}` of the overridden component
+ * @param {() => *} compile
+ * @returns {*} what compile returns
+ */
+function overriding(cx, entry, compile) {
+  cx.overriding = entry;
+  try {
+    return compile();
+  } finally {
+    cx.overriding = null;
+  }
+}
+
+/**
+ * Compiles an overriding function into the overridden one; its
+ * xsl:original() calls the overridden body.
+ * @param {object} cx
+ * @param {Element} element
+ * @param {object} component - The overridden function
+ */
+function overrideFunction(cx, element, component) {
+  const signature = functionSignature({ element }, cx);
+  const original = { ...component.cell };
+  const saved = cx.exprs;
+  cx.exprs = new ExpressionCompiler({
+    library: saved.library.extend([
+      {
+        namespace: XSL_NS,
+        local: "original",
+        params: Array(signature.arity).fill("item()*"),
+        returns: "item()*",
+        impl: (args, context) => callFunction(original, args, context),
+      },
+    ]),
+    decimalFormats: saved.decimalFormats,
+    owner: cx,
+  });
+  try {
+    Object.assign(component.cell, compileFunction(signature, cx));
+  } finally {
+    cx.exprs = saved;
+  }
+}
+
+/**
+ * Compiles an overriding attribute set into the parts of the overridden
+ * one.
+ * @param {object} cx
+ * @param {Element} element
+ * @param {object} component - The overridden attribute set
+ */
+function overrideAttributeSet(cx, element, component) {
+  const parts = cx.attributeSets.get(component.key);
+  cx.attributeSets.delete(component.key);
+  overriding(cx, component, () => declareAttributeSet(element, cx));
+  const original = [...parts];
+  parts.splice(0, parts.length, ...cx.attributeSets.get(component.key));
+  cx.attributeSets.set(component.key, parts);
+  cx.attributeSets.set(`${ORIGINAL}#${component.key}`, original);
+}
+
+/**
+ * Compiles an overriding named template into the overridden one.
+ * @param {object} cx
+ * @param {object} declaration - `{element, precedence, importLow}`
+ * @param {object} component - The overridden template
+ */
+function overrideTemplate(cx, declaration, component) {
+  const cell = cx.namedTemplates.get(component.key);
+  overriding(cx, component, () => declareTemplate(declaration, cx));
+  const original = { ...cell };
+  Object.assign(cell, cx.namedTemplates.get(component.key));
+  cx.namedTemplates.set(component.key, cell);
+  cx.namedTemplates.set(`${ORIGINAL}#${component.key}`, original);
+}
+
+/**
+ * Compiles the overriding declarations of this package's
+ * xsl:use-package elements and links them (overriding variables are
+ * linked by their slots, see packageTable.js).
+ * @param {object} cx
+ * @param {number} level - Import precedences start at level * 1e6
+ */
+export function linkOverrides(cx, level) {
+  for (const use of cx.uses) {
+    for (const { element, component } of use.overrides) {
+      if (component?.visibility === "abstract" && usesOriginal(element)) {
+        throw xsltError("XTSE3075", "The overridden component is abstract");
+      }
+      const precedence = level * LEVEL_PRECEDENCE + use.precedence;
+      const declaration = { element, precedence, importLow: precedence };
+      const kind = component?.kind;
+      if (kind === "function") overrideFunction(cx, element, component);
+      else if (kind === "attribute-set") {
+        overrideAttributeSet(cx, element, component);
+      } else if (kind === "template") {
+        overrideTemplate(cx, declaration, component);
+      } else if (kind === undefined) declareTemplate(declaration, cx);
+    }
+  }
+}

package/src/xslt/compiler/packageChecks.js

@@ -0,0 +1,84 @@
+/**
+ * Checks on a whole package: modes declared when declared-modes="yes"
+ * (XSLT 3.0 section 3.5.4.1, XTSE3085), no abstract component left in the
+ * top-level package (XTSE3080), and which components can start a
+ * transformation (sections 2.3.3 to 2.3.5).
+ *
+ * @module @tradik/xslt3/xslt/compiler/packageChecks
+ */
+
+import { standardAttr, xsltError } from "../names.js";
+import { matchesOf } from "./visibility.js";
+
+const ENTRY_VISIBILITIES = new Set(["public", "final"]);
+
+/**
+ * XTSE3085: with declared-modes="yes", every mode a package uses must be
+ * declared by xsl:mode or accepted from a used package.
+ * @param {object} cx - Package compiler, its templates compiled
+ */
+export function checkDeclaredModes(cx) {
+  if (!cx.header.declaredModes) return;
+  const declared = new Set(
+    cx.all("mode").map(({ element }) => cx.declaredModeName(element)),
+  );
+  for (const [key, entry] of cx.table) {
+    if (key.startsWith("mode ")) {
+      declared.add(entry.key);
+    }
+  }
+  const used = new Set([...cx.modes.keys(), ...cx.modeRefs]);
+  if (standardAttr(cx.tree.root, "default-mode") !== undefined) {
+    used.add(cx.defaultModeOf(cx.tree.root));
+  }
+  for (const name of used) {
+    if (!declared.has(name)) {
+      throw xsltError(
+        "XTSE3085",
+        `The mode ${name || "#unnamed"} is not declared`,
+      );
+    }
+  }
+}
+
+/**
+ * XTSE3080: the top-level package has no abstract component.
+ * @param {object} cx - Its compiler, prepared
+ */
+export function checkExecutable(cx) {
+  for (const entry of cx.table.values()) {
+    if (entry.visibility === "abstract") {
+      throw xsltError("XTSE3080", `The component ${entry.local} is abstract`);
+    }
+  }
+}
+
+/**
+ * Whether a component of the top-level package can be the initial named
+ * template or function (public or final).
+ * @param {object} cx
+ * @param {string} kind - "template" or "function"
+ * @param {string} key - Clark name (with `#arity` for a function)
+ * @returns {boolean}
+ */
+export function isEntryPoint(cx, kind, key) {
+  return ENTRY_VISIBILITIES.has(cx.table.get(`${kind} ${key}`)?.visibility);
+}
+
+/**
+ * Whether a mode can be the initial mode (section 2.3.3).
+ * @param {object} cx - The top-level package's compiler
+ * @param {string} name - Clark name, "" for the unnamed mode
+ * @returns {boolean}
+ */
+export function isEligibleMode(cx, name) {
+  if (name === "" || name === cx.defaultModeName) return true;
+  if (isEntryPoint(cx, "mode", name)) return true;
+  if (cx.header.declaredModes || !cx.modes.has(name)) return false;
+  if (cx.table.has(`mode ${name}`)) return false;
+  // a mode used without declaration is eligible, unless xsl:expose makes
+  // it private (XSLT 3.0 section 3.5.3.1)
+  const [uri, local] = name.slice(1).split("}");
+  const [best] = matchesOf(cx.exposeRules ?? [], { kind: "mode", uri, local });
+  return !best || ENTRY_VISIBILITIES.has(best.rule.visibility);
+}