SAXON10.SAXON(1)

📦 version 10.9, in opensuse-leap 16.0

💖 NAME 💖

Okay bestie, welcome to the SAXON10.SAXON(1) page — yes, the User Commands one — and it's all about saxon10, aka the Saxon XSLT 3.0 processor. 💅✨

🦋 SYNOPSIS 🦋

saxon10 [options] [params]

🌸 DESCRIPTION 🌸

It's an XSLT processor, and you can use it from the command line, or invoke it from an application using a supplied API. Saxon implements the XSLT 3.0 Recommendation. The product can also be used to run XSLT 2.0 stylesheets, or XSLT 1.0 stylesheets in backwards compatibility mode. Periodt. 💖

💅 OPTIONS 💅

Every flag is here, no skipping, no cap. 🫶

  • -a[:(on|off)] — Use the xml-stylesheet processing instruction in the source document to identify the stylesheet to be used. The stylesheet argument must not be present on the command line. For more details see Using the -a option: https://www.saxonica.com/documentation10/index.html#!using-xsl/commandline/aoption.
  • -catalog:filenames — filenames is either a file name or a list of file names separated by semicolons; the files are OASIS XML catalogs used to define how public identifiers and system identifiers (URIs) used in a source document, stylesheet, or schema are to be redirected, typically to resources available locally. For more details see Using XML Catalogs: https://www.saxonica.com/documentation10/index.html#!sourcedocs/xml-catalogs.
  • -config:filename — Indicates that configuration information should be taken from the supplied configuration file: https://www.saxonica.com/documentation10/index.html#!configuration/configuration-file. Any options supplied on the command line override options specified in the configuration file.
  • -dtd:(on|off|recover) — Setting -dtd:on requests DTD-based validation of the source file and of any files read using the document() function. Requires an XML parser that supports validation. The setting -dtd:off (which is the default) suppresses DTD validation. The setting -dtd:recover performs DTD validation but treats the error as non-fatal if it fails. Note that any external DTD is likely to be read even if not used for validation, because DTDs can contain definitions of entities.
  • -ea:(on|off) — Setting -ea:on enables assertions both at compile time and at run time. Assertions (defined using the XSLT 3.0 xsl:assert instruction) are disabled by default at compile time, and enabled by default at run-time provided they were enabled at compile time.
  • -expand:(on|off) — Normally, if validation using a DTD or schema is requested, any fixed or default values defined in the DTD or schema will be expanded. Specifying -expand:off suppresses this. (In the case of DTD-defined defaults, this might not work with all XML parsers. It does work with the Xerces parser (default for Java) and the Microsoft parser (default for .NET).)
  • -explain[:filename] — Display an execution plan and other diagnostic information for the stylesheet. This is a representation of the expression tree after rewriting by the optimizer. It combines the XSLT instructions and the XPath expressions into a single tree. If no file name is specified the output is sent to the standard error stream. The output is in XML format.
  • -export:filename — Export the compiled stylesheet, in a form suitable for subsequent execution. For more details, see Compiling a Stylesheet: https://www.saxonica.com/documentation10/index.html#!using-xsl/compiling.
  • -ext:(on|off) — If -ext:off is specified, suppress calls on dynamically-loaded external Java functions. This does not affect calls on integrated extension functions, including Saxon and EXSLT extension functions. This option is useful when loading an untrusted stylesheet, perhaps from a remote site using an http:// URL; it ensures that the stylesheet cannot call arbitrary Java methods and thereby gain privileged access to resources on your machine.
  • -im:modename — Selects the initial mode for the transformation. If this is namespaced, it can be written as {uri}localname.
  • -init:initializer — The value is the name of a user-supplied class that implements the interface Initializer; this initializer will be called during the initialization process, and may be used to set any options required on the Configuration programmatically.
  • -it[:template-name] — Selects the initial named template to be executed. If this is namespaced, it can be written as {uri}localname. If the template name is omitted, the default is xsl:initial-template. When this option is used, you do not need to supply a source file, but if you do, you must supply it using the -s option.
  • -jit:(on|off) — Determines whether just-in-time compilation of template rules is in force. The default is on, unless the nogo or explain option is set. When JIT is enabled, the body of a template rule is not compiled until the rule first fires. This gives faster compilation when a stylesheet has been written to handle a large XML vocabulary, but the source document only uses a fraction of the vocabulary. The drawback is that static errors in the stylesheet may go undetected.
  • -l[:(on|off)] — If -l or -l:on is specified, causes line and column numbers to be maintained for source documents. These are accessible using the extension functions saxon:line-number() and saxon:column-number(). Line numbers are useful when the purpose of the stylesheet is to find errors or anomalies in the source XML file. Without this option, line numbers are available while source documents are being parsed and validated, but they are not retained in the tree representation of the document.
  • -lib:filenames — A list of filenames containing library packages. The filenames are separated by ; on Windows systems, or : on Linux and Mac. Each filename must identify either (a) a top-level module in a source XSLT package, or (b) a SEF file containing an exported library package. There is no constraint on the order of the packages.
  • -license:(on|off) — Relevant only when SaxonJ-PE or SaxonJ-EE software is loaded. By default, Saxon will look for a license and report a warning if none is found, which escalates to a fatal error if licenseable features (such as schema-awareness) are used. If -license:off is specified, Saxon will not look for a license unless it is needed, and will fall back silently if none is found (this means that the transformation might succeed, but without taking advantage of Saxon-EE optimizations). The option -license:off is useful to suppress warnings in the case where it is known that a compiled stylesheet containing an embedded license key is being executed.
  • -m:classname — Use the specified Receiver to process the output from xsl:message. The class must implement the Receiver interface, and it must have a public zero-argument constructor. This interface is similar to a SAX ContentHandler, it takes a stream of events to generate output. In general the content of a message is an XML fragment. By default the standard XML emitter is used, configured to write to the standard error stream, and to include no XML declaration. Each message is output as a new document. The sequence of calls to this Receiver is as follows: there is a single open() call at the start of the transformation, and a single close() call at the end; and each evaluation of an xsl:message instruction starts with a startDocument() call and ends with endDocument(). The startDocument() event has a properties argument indicating whether terminate="yes" was specified, and the locationId on calls such as startElement() and characters() can be used to identify the location in the stylesheet where the message data originated (this is achieved by passing the supplied locationId in a call to getPipelineConfiguration().getLocator().getSystemId(locationId), or to getLineNumber() on the same object). Select the class MessageWarner to have xsl:message output notified to the JAXP ErrorListener, as described in the JAXP documentation.
  • -nogo — If set, the stylesheet is analysed for errors, and any requested -explain or -export output is generated, but the stylesheet is not executed.
  • -now:yyyy-mm-ddThh:mm:ss+hh:mm — Sets the value of current-dateTime() (and implicit-timezone()) for the transformation. This is designed for testing, to enable repeatable results to be obtained for comparison with reference results, or to test that stylesheets can handle significant dates and times such as end-of-year processing.
  • -ns:(uri|##any|##html5) — Defines the handling of unprefixed element names appearing as name tests in path expressions and match patterns in the stylesheet.
    • Supplying a URI sets the default namespace for elements and types (effectively a default value for xpath-default-namespace — note that an explicit value for this attribute takes precedence).
    • The value ##any declares that unprefixed names are treated as a test on the local name of the element only: they will match regardless of namespace.
    • The value ##html5 declares that an unprefixed element name will match either a name in the XHTML namespace, or a name in no namespace. This option is intended primarily for use when generating stylesheets to run under Saxon-JS in the browser, since the resulting behavior is close to that defined by the special rules in the HTML5 specification for XSLT and XPath running against an HTML5 DOM.
  • -o:filename — Send output to named file. If the source (-s) argument identifies a directory, this option is mandatory and must also identify a directory; on completion it will contain one output file for each file in the source directory. In other cases, this option has two effects: it defines the file where the principal output of the transformation will be written, and it defines the base URI used for resolving the value of the xsl:result-document/@href attribute when secondary result documents are written. In the absence of this option, (a) the principal output is written to the standard output stream, and (b) secondary output file locations are resolved relative to the current working directory. Output files are created if they do not already exist; any necessary directories will also be created. If a file does already exist, it is generally overwritten, though this will not necessarily happen if the transformation fails.
  • -opt:[-]flags — bestie, this is the optimization control panel ✨ You can turn individual optimizations on or off with these single-letter flags:
    • c — generate bytecode
    • d — detect void path expressions
    • e — cache regular expressions
    • f — inline functions
    • g — extract global variables
    • j — just-in-time compilation of template rules
    • k — create keys
    • l — loop lifting
    • m — miscellaneous
    • n — constant folding
    • r — template rule-sets
    • s — extract common subexpressions
    • t — tail call optimization
    • v — inline variables
    • w — create switch statements
    • x — index predicates

So like, a value such as -opt:gs runs with only the selected optimizations; -opt:-gs runs with the selected optimizations disabled and all others enabled. The value -opt:0 suppresses all optimizations. The default is full optimization; this feature lets you suppress optimization when reducing compile time is important, or when optimization gets in the way of debugging, or when it causes extension functions with side-effects to behave unpredictably. (Note however that even with no optimization, lazy evaluation may still cause the evaluation order to be not as expected.) Disabling optimizations may in some cases prevent streamed evaluation. For example, some expressions only become streamable because the optimizer is able to work out that sorting nodes into document order is unnecessary. Most of these flags enable optimizations that cause extra work at compile time to improve run-time performance. The j option is an exception: enabling this option shifts work from compile time to run time.

  • -or:classname — use the specified OutputURIResolver to process output URIs appearing in the href attribute of xsl:result-document. The OutputURIResolver is a user-defined class that implements the net.sf.saxon.lib.OutputURIResolver interface. 💅
  • -outval:(recover|fatal) — okay so normally, if validation of result documents is requested, a validation error is fatal. Setting the option -outval:recover causes such validation failures to be treated as warnings. The validation message is written both to the standard error stream, and (where possible) as a comment in the result document itself.

This option does not by itself cause result documents to be validated; that happens only as a consequence of the type or validation attribute on an xsl:result-document instruction. The only effect of the option is to determine what happens when validation fails.

Validating result documents can be very useful while debugging a stylesheet, because it provides instant feedback when the output is incorrect. However, it can sometimes be frustrating during development when you know that parts of the code have not yet been written. The option -outval:recover is designed to give you the best of both worlds: it tells you that the output is wrong, but still enables you to see the complete result document that your code is producing. 🫶

  • -p[:(on|off)] — enable recognition of query parameters (such as xinclude=yes) in the StandardURIResolver. This option is available in Saxon-PE and Saxon-EE only. It cannot be used in conjunction with the -r option, and it automatically switches on the -u and -sa options. The effect is that Saxon-specific query parameters are recognized in a URI. One query parameter that is recognized is val. This may take the values strict, lax, or strip. For example, source.xml?val=strict loads a document with strict schema validation. 🌈
  • -quit:(on|off) — with the default setting, on, the command will quit the Java VM and return an exit code if a failure occurs. This is useful when running from an operating system shell. With the setting -quit:off the command instead throws a RunTimeException, which is more useful when the command is invoked from another Java application such as Ant. 💀
  • -r:classname — use the specified URIResolver to process all URIs. The URIResolver is a user-defined class that implements the javax.xml.transform.URIResolver interface, whose function is to take a URI supplied as a string, and return a SAX Source object. It is invoked to process URIs used in the document() function, in the xsl:include and xsl:import elements, and (if -u is also specified) to process the URIs of the source file and stylesheet file provided on the command line. 🦋
  • -relocate:(on|off) — used with -export to produce an export package which can be deployed to a different location, with a different base URI. If on, then static-base-uri() represents the deployed location of the package, rather than its compile time location. The default is off.

The practical effect of this is that if -relocate:off (the default) is specified, then the generated SEF file will contain references to the stylesheet’s original location as its static base URI, and run-time operations that are relative to this base URI (for example, calling doc() with a relative URI) will retrieve resources exactly as if the stylesheet had not been exported. By contrast, if -relocate:on is specified, the SEF file will contain no reference to the original location of the source stylesheet, and operations such as doc() will be relative to the location from which the SEF file was loaded. 👑

  • -repeat:integer — performs the transformation N times, where N is the specified integer. This option is useful for performance measurement, since timings for the first transformation are often dominated by Java warm-up time. 🔥
  • -s:filename — identifies the source file or directory. Mandatory unless the -it option is used. The source file is parsed to create a tree, and the document node of this tree acts as the initial context item for the transformation.

The filename can be given as - to take the source from standard input, in which case the base URI is taken from that of the current directory.

If the name identifies a directory, all the files in the directory will be processed individually. In this case the -o option is mandatory, and must also identify a directory, to contain the corresponding output files. A directory must be specified as a filename, not as a URL.

For backwards compatibility the source filename can also be specified immediately before the stylesheet filename, without the -s flag, provided that the -it option is not present. 🎀

  • -sa — invoke a schema-aware transformation. Requires Saxon-EE to be installed. This option is not needed if either (a) another option implying schema-awareness is present (for example -val:strict) or (b) the stylesheet contains an xsl:import-schema declaration. ✨
  • -scmin:filename — loads a precompiled schema component model from the given file. The file should be generated in a previous run of com.saxonica.Validate using the -export option. When this option is used, the -xsd option should not be present. Schemas loaded from an SCM file are assumed to be valid, without checking.

This option is retained for compatibility. From Saxon 9.7, SCM files can also be supplied in the -xsd option. 💜

  • -strip:(all|none|ignorable) — specifies what whitespace is to be stripped from source documents (applies both to the principal source document and to any documents loaded for example using the document() function). The default is ignorable: all ignorable whitespace is stripped. Whitespace text nodes are ignorable if they appear in elements defined in the DTD or schema as having element-only content. Specifying all strips all whitespace text nodes from source documents before any further processing, regardless of any xsl:strip-space declarations in the stylesheet, or any xml:space attributes in the source document. Specifying ignorable strips all ignorable whitespace text nodes from source documents before any further processing, regardless of any xsl:strip-space declarations in the stylesheet, or any xml:space attributes in the source document. Specifying none suppresses all whitespace stripping unless requested elsewhere, for example using xsl:strip-space. 🌸
  • -t — display version and timing information to the standard error output. The output also traces the files that are read and written, and extension modules that are loaded. ⏱️
  • -T[:classname] — display stylesheet tracing information. This traces execution of each instruction in the stylesheet, so the output can be quite voluminous. Also switches line numbering on for the source document. If a classname is specified, it is a user-defined class, which must implement TraceListener. If the classname is omitted, a system-supplied trace listener is used. For performance profiling, set classname to net.sf.saxon.trace.TimingTraceListener. This creates an output file giving timings for each instruction executed. This output file can subsequently be analyzed to give an execution time profile for the stylesheet. See Performance Analysis at https://www.saxonica.com/documentation10/index.html#!using-xsl/performanceanalysis. 🔍
  • -target:(EE|PE|HE|JS) — relevant only when -export is specified, identifies the target platform on which the exported stylesheet is to run. When exporting for Saxon-JS, the value JS must be specified, because this adds information to the SEF file that is required by Saxon-JS. Specifying JS means the SEF is produced in JSON format for use with Saxon-JS 2.x. (To generate SEF files for Saxon-JS 1.x, you need to revert to Saxon-EE 9.9). In principle, specifying HE or PE will inhibit optimizations that generate code which Saxon-HE/Saxon-PE cannot execute; however, this is not fully tested. 🧚
  • -TB:filename — monitors generation of hot-spot bytecode and produces an XML report on the given filename giving, for each expression that was a candidate for bytecode generation and that was actually executed, data about the number of times and speed of execution in the interpreter, the number of times and speed of execution in compiled form, and the cost of compilation. 🍓
  • -threads:N — used only when the -s option specifies a directory. Controls the number of threads used to process the files in the directory. Each transformation runs in a single thread. 🌟
  • -TJ — turns on tracing for the binding of calls to external Java methods. Super niche but honestly a lifesaver when you're sitting there like "why is Saxon not finding a Java method to match my extension function call 😭" — or why it picked one method over another when you've got several to choose from. It's giving detective mode 🔍
  • -Tlevel:(none|low|normal|high) — controls how much detail the -T option spits at you. The values are:
    • none — effectively switches tracing off. Nothing to see here, moving on 💀
    • low — traces function and template calls.
    • normal — traces execution of instructions.
    • high — traces execution of finer-grained expressions. Maximum tea ☕
  • -Tout:filename — sends the tracing output to a file you name (assuming -T is actually enabled, bestie — this isn't a magic wand ✨).
  • -TP:filename — this one's a shortcut: it's equivalent to setting -T:net.sf.saxon.trace.TimedTraceListener and -traceout:filename. In other words, it dumps trace profile info into the file you specify. Then you can analyze that output file later to get an execution time profile of your stylesheet. Literally performance analysis, iykyk. See Performance Analysis https://www.saxonica.com/documentation10/index.html#!using-xsl/performanceanalysis.
  • -traceout:filename — says "hey, send the output of the trace() function to this file instead." Or you can pass #out to send it to System.out, #err to send it to System.err (that's the default, btw), or #null to just have it yeeted into the void 🕳️. Heads up though: this option is ignored when a trace listener is in use — in that case trace() output goes to the registered trace listener. No cap.
  • -tree:(linked|tiny|tinyc) — picks which internal tree model implementation gets used: tiny selects the “tiny tree” model (the default 👑), linked selects the linked tree model, and tinyc selects the “condensed tiny tree” model. See Choosing a tree model https://www.saxonica.com/documentation10/index.html#!sourcedocs/choosingmodel.
  • -u — tells Saxon that the names of the source document and the stylesheet document are URLs. Otherwise they get treated as filenames — unless they start with http:, https:, file: or classpath:, and in that case they're URLs anyway. Slay, flexible queen 💅
  • -val[:(strict|lax)] — requests schema-based validation of the source file and of any files read using document() or similar functions. Important: validation is only available with Saxon-EE, and this flag automatically switches on the -sa option. Write -val or -val:strict for strict validation, or -val:lax for lax validation. Pick your fighter 🥊
  • -warnings:(silent|recover|fatal) — sets the policy for handling recoverable errors in the stylesheet: silent means recover silently 🤫, recover means recover after writing a warning message to the system error output, and fatal means signal the error and don't even try to recover 💀. (Note: this does not currently apply to all errors that the XSLT recommendation calls recoverable — don't come for me, that's just what the docs say.) The default is recover.
  • -x:classname — use this SAX parser for the source file and any files loaded via the document() function. The parser has to be the fully-qualified class name of a Java class that implements the org.xml.sax.XMLReader or javax.xml.parsers.SAXParserFactory interface, and it must be instantiable using a zero-argument public constructor. One use: picking an HTML parser like John Cowan's TagSoup instead of an XML parser — in that case the TagSoup JAR file must be on the classpath, and the class name to use is org.ccil.cowan.tagsoup.Parser. Another common use is specifying org.apache.xml.resolver.tools.ResolvingXMLReader — that parser comes from the Apache commons project, and it customizes the default parser by using an EntityResolver that resolves external entity references (you know, the reference to an external DTD in a DOCTYPE declaration) by reference to an OASIS catalog file. Which means you can dodge repeated calls to external web servers (like the W3C server) for commonly used DTDs such as the XHTML DTD. Obsessed, honestly. Also: the option to supply a SAXParserFactory was introduced in 9.6 for the benefit of the Aalto parser, whose XMLReader implementation can't be directly instantiated — so you can request that parser by nominating its factory class, com.fasterxml.aalto.sax.SAXParserImpl.
  • -xi:(on|off) — applies XInclude processing to all source XML documents (but not to schema and stylesheet modules). Currently this only works when documents are parsed using the Xerces parser, which is the default on the SaxonJ platform (but not on .NET). Just so you know 🫶
  • -xmlversion:(1.0|1.1) — if you specify -xmlversion:1.1, it allows XML 1.1 and XML Namespaces 1.1 constructs. You must set this if source documents using XML 1.1 are gonna be read, or if result documents are gonna be serialized as XML 1.1. It also enables XML 1.1 constructs inside the stylesheet itself. Periodt ✨
  • -xsd:file1;file2;file3… — loads extra schema documents. The declarations in those schema documents are available when validating source documents (or for use by the validate{} expression). You can also use this to supply the locations of schema documents imported into the stylesheet, for the case where the xsl:import-schema declaration gives the target namespace of the schema but not its location. Drop them in, separated by semicolons 💖
  • -xsdversion:(1.0|1.1) — if -xsdversion:1.1 is specified (that's the default), it allows schema documents using XML Schema 1.1 to be read, plus XML Schema 1.1 constructs such as assertions. Fancy 😌
  • -xsiloc:(on|off) — if set to on (the default), the schema processor tries to load any schema documents referenced in xsi:schemaLocation and xsi:noNamespaceSchemaLocation attributes in the instance document — unless a schema for the specified namespace (or non-namespace) is already available. If set to off, those attributes are just ignored. Bye 👋
  • -xsl:filename — specifies the file containing the principal stylesheet module. Mandatory unless the -a option is used. The value - identifies the standard input stream, and in that case the static base URI is taken from that of the current directory. If the -u option is specified, then the value must be a URI rather than a filename.

The selected file can contain either XSLT source code, or a compiled version of the stylesheet (a SEF file) as produced using the -export option. Either way, she's ready 💅

  • -y:classname — use the specified SAX parser for stylesheet files, including any loaded using xsl:include or xsl:import. The classname you give has to be the fully-qualified class name of a Java class that implements the org.xml.sax.XMLReader or javax.xml.parsers.SAXParserFactory interface, and it must be instantiable using a zero-argument public constructor. Same rules as -x, just for stylesheets 🎀
  • --feature:value — sets a feature defined in the Configuration interface. The names of features are defined in the Javadoc for class Feature (or, alternatively, see Configuration Features https://www.saxonica.com/documentation10/index.html#!configuration/config-features): the value used here is the part of the name after the last / — for example --allow-external-functions:off. Only features accepting a string or boolean may be set; for booleans the values true/false, on/off, yes/no, and 1/0 are recognized. So many ways to say yes 😌
  • -? — displays the command syntax. The "help me" of it all 🙈
  • --? — displays a list of features available through the --feature:value syntax. So you don't have to guess, bestie 💜

💬 COMMAND LINE PARAMETERS 💬

Okay so a param takes the form name=value, where name is the name of the parameter and value is the value of the parameter. These params are accessible inside the stylesheet as normal variables, using the $name syntax — provided they're declared using a top-level xsl:param element. If there's no such declaration, the supplied parameter value is just silently ignored. Rude, but that's the vibe 😭

If the xsl:param element has an as attribute indicating the required type, then the string value you supplied on the command line gets cast to that type. Which can absolutely result in an error — for example if an integer is required and the value you gave can't be converted to an integer. Math is hard 💀

If the parameter is declared with the option static="yes" (new in XSLT 3.0), then the value is supplied as a static parameter value. Special treatment, honestly 👑

A param preceded by a leading question mark (?) is interpreted as an XPath expression. For example, ?time=current-dateTime() sets the value of the stylesheet parameter $time to the value of the current date and time, as an instance of xs:dateTime. Meanwhile ?debug=false() sets the value of the parameter $debug to the boolean value false. If the parameter has a required type (for example <xsl:param name="p" as="xs:date"/>), then the supplied value must be compatible with that type according to the standard rules for converting variable values and function arguments.

The static context for this XPath expression includes only the standard namespaces conventionally bound to the prefixes xs, fn, xsi, and saxon. The static base URI (used when calling the doc() function) is the current directory. The dynamic context contains no context item, position, or size, and no variables. Bare bones, no cap 🦋

A param preceded by a leading exclamation mark (!) is interpreted as an output parameter. For example, !indent=yes requests indented output. This is equivalent to specifying the attribute indent="yes" on an xsl:output declaration in the stylesheet. An output parameter specified on the command line overrides one specified within the stylesheet — command line stays winning 💅

For the parameters doctype-system, doctype-public, and saxon:next-in-chain, a zero-length value is treated as “absent” — that is, the effect is to cancel any value that was set within the stylesheet. Sneaky but iconic.

⚠️ If you're using the bash shell, you'll need to escape ! as \!. Yes, really. Bash is like that.

A param preceded by a leading plus sign (+) is interpreted as a filename or directory. The content of the file is parsed as XML, and the resulting document node is passed to the stylesheet as the value of the parameter. If the parameter value is a directory, then all the immediately contained files are parsed as XML, and the resulting sequence of document nodes is passed as the value of the parameter. For example, +lookup=lookup.xml sets the value of the stylesheet parameter lookup to the document node at the root of the tree representing the parsed contents of the file lookup.xml. Multi-document slay 🌈

Okay so a lil PSA about values with spaces in them 💅 — under most operating systems you can hand over a value that's got spaces in it by wrapping it in double quotes, like name="John Smith". But plot twist: that's a feature of the operating system shell, not something Saxon does itself, so it might not behave the same way on every OS or command processor 🫠. Case in point: in the jEdit console plugin it has to be written as "name=John Smith" — quotes wrapped around the whole thing, not just the value. iykyk 😌

Now, if the parameter name lives in a non-null namespace, you can still give it a value using the syntax {uri}localname=value. Here uri is the namespace URI of the parameter's name, and localname is the local part of the name. No cap, that's the whole format ✨

This applies to output parameters too 🎀 — like, you can set the indentation level to 4 using the parameter !{http://saxon.sf.net/}indent-spaces=4. But in this case specifically, lexical QNames that use the prefix saxon are also recognized, for example !saxon:indent-spaces=4 🔥. Also go peep Additional serialization parameters at <https://www.saxonica.com/documentation10/index.html#!extensions/output-extras> for more 👑

🌈 SEE ALSO 🌈

Like, the whole friend group fr fr 🫶

💖 AUTHOR 💖

Michael H. Kay <mike@saxonica.com> — the main character who made all this happen 👑

And that's a wrap, bestie!! 🎀✨ This whole saga is saxon10 version 10.9, dated 2023-09-27, and the page you just devoured is SAXON10.SAXON(1). Go forth and slay your transformations 💅🔥

📦 where this page comes from