construct-name attribute*;

<xsl:construct-name ...attribute...* />

construct-name attribute* { attribute* }

construct-name attribute* element*;

<xsl:construct-name ...attribute...* >
  ...element...*
</xsl:construct-name>

construct-name attribute* { attribute* element* }

construct-name attribute* element* { element* }

{brace-less-expression}

"brace-less-expression"

"arbitrary-expression"

"arbitrary-expression"

'arbitrary-expression'

'arbitrary-expression'

analyze-string (select,"regex") ...

<xsl:analyze-string select="select" regex="regex" ...

apply-imports ...

<xsl:apply-imports ...

apply-templates () ...

<xsl:apply-templates ...

apply-templates (select) ...

<xsl:apply-templates select="select" ...

apply-templates mode(select)(p1, p2 := s2, p3 := {...s3...}) ...

<xsl:apply-templates select="select" mode="mode" ...
  <xsl:with-param name="p1"/>
  <xsl:with-param name="p2" select="s2"/>
  <xsl:with-param name="p3">
    ... s3 ...
  </xsl:with-param> ...
</xsl:apply-templates>

apply-templates (select)(p1, p2 := s2, p3 := {...s3...}) mode=mode ...

@name = "..."

<xsl:attribute name="...";

attribute name = "..."

@name := xpath-expression;

<xsl:attribute name="name">
  <xsl:value-of select="xpath-expression"/>
</xsl:attribute>

or if attributeHasSelect preference enabled

<xsl:attribute name="name" select="xpath-expression">

attribute name := xpath-expression;

attribute-set name ...

<xsl:attribute-set name="name" ...

call name ...

<xsl:call-template name="name" ...

call-template name ...

call name(p1, p2 := s2, p3:= {...s3...}) ...;

<xsl:call-template name="name" ...>
  <xsl:with-param name="p1"/>
  <xsl:with-param name="p2" select="s2"/>
  <xsl:with-param name="p3">
    ... s3 ...
  </xsl:with-param>
  ...
</xsl:call-template>

character-map name ...

<xsl:character-map name="name" ...

choose ...

<xsl:choose ...

comment ...

<xsl:comment ...

comment (select) ...

<xsl:comment select="select" ...

copy ...

<xsl:copy ...

copy-of (select) ...

<xsl:copy-of select="select" ...

decimal-format ...

<xsl:decimal-format ...

document ...

<xsl:document ...

element name ...

<xsl:element name="name" ...;

element {brace-less-attr-value} ...

<xsl:element name="{brace-less-attr-value}" ...;

element "any-attr-value" ...

<xsl:element name="{any-attr-value}" ...;

fallback ...

<xsl:fallback ...

for-each (select) ...

<xsl:for-each select="select" ...

for-each-group (select) ...

<xsl:for-each-group select="select" ...

function name(p1, p2, p3 : t3) : t0 { ... }

<xsl:function name="name" as="t0">
  <xsl:param name="p1"/>
  <xsl:param name="p2"/>
  <xsl:param name="p3 as="t3"/>
    ...
</xsl:function>

if (test) ...

<xsl:if test="test" ...

if (test1) ...;
else if (test2) ...;
else ...;

<xsl:choose>
  <xsl:when test="test1" ...
  <xsl:when test="test2" ...
  <xsl:otherwise ...
</xsl:choose>

import href ...

<xsl:import href="href" ...

import "href" ...

import-schema ...

<xsl:import-schema ...

include href ...

<xsl:include href="href" ...

include "href" ...

key name (pattern) ...

<xsl:key name="name" match="pattern" ...

match (match) ...

<xsl:template match="match" ...

match (match)(p1, p2 := s2, p3 : t3 := {...s3...}) : t0 ...

<xsl:template match="match" as="t0" ...
  <xsl:param name="p1"/>
  <xsl:param name="p2" select="s2"/>
  <xsl:param name="p3" as="t3">
    ... s3 ...
  </xsl:param> ...
</xsl:template>

match mode(match)(p1, p2 := s2, p3 : t3 := {...s3...}) : t0 ...

<xsl:template match="match" mode="mode" as="t0" ...
  <xsl:param name="p1"/>
  <xsl:param name="p2" select="s2"/>
  <xsl:param name="p3" as="t3">
    ... s3 ...
  </xsl:param> ...
</xsl:template>

match mode(match) | name(p1, p2 := s2, p3 : t3 := {...s3...}) : t0 ...

<xsl:template match="match" mode="mode" name="name" as="t0" ...
  <xsl:param name="p1"/>
  <xsl:param name="p2" select="s2"/>
  <xsl:param name="p3" as="t3">
    ... s3 ...
  </xsl:param> ...
</xsl:template>

matching-substring ...

<xsl:matching-substring ...

message ...

<xsl:message ...

message := xpath-expression;

<xsl:message select="xpath-expression"/>

message := <...elements...*>;

<xsl:message>
  ...elements...*
</xsl:message>

message := {...constructs...}

<xsl:message>
  ...constructs...
</xsl:message>

namespace name ...

<xsl:namespace name="name" ...

namespace name = select

<xsl:namespace name="name" select="select"/>

namespace-alias stylesheet-prefix = result-prefix ...

<xsl:namespace-alias stylesheet-prefix="stylesheet-prefix"
 result-prefix="result-prefix" ...

next-match name(p1, p2 := s2, p3 : t3 := {...s3...}) : t0 ...;

<xsl:next-match name="name" as="t0 ...>
  <xsl:with-param name="p1"/>
  <xsl:with-param name="p2" select="s2"/>
  <xsl:with-param name="p3 as="t3">
    ... s3 ...
  </xsl:with-param>
  ...
</xsl:next-match>

non-matching-substring ...

<xsl:non-matching-substring ...

number ...

<xsl:number ...

otherwise ...

<xsl:otherwise ...

output "" ...

<xsl:output ...

output method indent="indent" ...

<xsl:output method="method" indent="indent" ...

output "method" indent="indent" ...

output-character "character" = "string" ...

<xsl:output-character character="character" string="string" ...

perform-sort ...

<xsl:perform-sort ...

See function/stylesheet/template.

<xsl:param ...

perform-sort (select) ...

<xsl:perform-sort select="select" ...

preserve-space "e1" e2,*...

<xsl:preserve-space elements="e1 e2 *" ...

processing-instruction name ...

<xsl:processing-instruction name="name" ...

processing-instruction name (select) ...

<xsl:processing-instruction name="name" select="select" ...

result-document "" ...

<xsl:result-document ...

result-document href ...

<xsl:result-document href="href" ...

result-document "href" ...

sequence ...

<xsl:sequence ...

sequence (select) as="as" ...

<xsl:sequence select="select" as="as" ...

sort ...

<xsl:sort ...

sort (select) order="order" ...

<xsl:sort select="select" order="order" ...

strip-space e1,*,"e2" ...

<xsl:strip-space elements="e1 * e2" ...

stylesheet ...

<xsl:stylesheet ...

transform ...

stylesheet(p1, p2 := s2, p3 := {...s3...}) ... { ... }

<xsl:stylesheet ... >
  <xsl:param name="p1"/>
  <xsl:param name="p2" select="s2"/>
  <xsl:param name="p3">
    ... s3 ...
  </xsl:param>
  ...
</xsl:stylesheet>

transform(p1, p2 := s2, p3 := {...s3...}) ... { ... }

transform rather than stylesheet generation is a preference/command line option.

template name ...

<xsl:template name="name">
  ...
</xsl:template>

template name () ...

template name(p1, p2 := s2, p3 : t3 := {...s3...}) : t0 { ... }

<xsl:template name="name as="t0">
  <xsl:param name="p1"/>
  <xsl:param name="p2" select="s2"/>
  <xsl:param name="p3 as="t3">
    ... s3 ...
  </xsl:param>
  ...
</xsl:template>

text ...

<xsl:text ...

value-of ...

<xsl:value-of ...

value-of (select) ...

<xsl:value-of select="select" ...

variable qname ...

<xsl:variable name="qname" ...

variable qname = (select) ...

<xsl:variable name="qname" select="select" ...

variable qname := xpath-expression;

<xsl:variable name="qname" select="xpath-expression"/>

variable qname : schema-type := xpath-expression;

<xsl:variable name="qname" as="schema-type" select="xpath-expression"/>

variable qname : schema-type := <...elements...*>;

<xsl:variable name="qname" as="schema-type">
  ...elements...*
</xsl:variable>

variable qname : schema-type := {...constructs...}

<xsl:variable name="qname" as="schema-type">
  ...constructs...
</xsl:variable>

when (test) ...

<xsl:when test="test" ...

See apply-imports, apply-templates, call-template, next-match.

<xsl:with-param ...

Use of = rather than := for parameters.