Functions, global variables, keys, and named templates

rgx:analyze-string($input as xs:string?, $pattern as xs:string) as element()

two-parameter version of the fuller one, below

Used by function rgx:analyze-string().

Relies upon rgx:analyze-string.

Option 2 (TAN-fn-regex-standard)

rgx:analyze-string($input as xs:string?, $pattern as xs:string, $flags as xs:string) as element()

Input: three strings

Output: an XML structure that identifies which parts of the first parameter matched 
or failed to match the regular expression, supplied by the send parameter, taking into 
account flags supplied by the third. In the case of matched substrings, indicates 
substrings matched each capturing group in the regular expression.

Used by function rgx:analyze-string().

Does not rely upon global variables, keys, functions, or templates.

`rgx:codepoints-to-string()`

rgx:codepoints-to-string($arg as xs:integer*) as xs:string?

one-parameter version of the fuller one below; default XML 1.0

Used by function rgx:codepoints-to-string(), rgx:process-regex-escape-u().

Relies upon rgx:codepoints-to-string.

Option 2 (TAN-fn-regex-standard)

rgx:codepoints-to-string($arg as xs:integer*, $xml-1-0 as xs:boolean) as xs:string?

Input: any number of integers

Output: the string value representation, but only if the integers represent valid 
characters in XML

Like fn:codepoints-to-string(), but filters out XML illegal characters

Used by function rgx:codepoints-to-string(), rgx:process-regex-escape-u().

Does not rely upon global variables, keys, functions, or templates.

`rgx:escape()`

TAN-fn-regex-standard

rgx:escape($strings as xs:string*) as xs:string*

Input: any sequence of strings

Output: each string prepared for regular expression searches, i.e., with reserved 
characters escaped out.

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $characters-to-escape-when-converting-string-to-regex.

`rgx:matches()`

rgx:matches($input as xs:string?, $pattern as xs:string) as xs:boolean

two-param function of the three-param version below

Used by function rgx:matches(), rgx:regex-is-valid().

Relies upon rgx:matches.

Option 2 (TAN-fn-regex-standard)

rgx:matches($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:boolean

Parallel to fn:matches(), but converts \u{} into classes. See rgx:regex() for 
details.

Input: three strings

Output: true if the first string matches the regular expression supplied as the 
second, taking account into flags supplied by the third.

rgx:regex-is-valid($input-regex as xs:string?) as xs:boolean

Used by function rgx:matches(), rgx:regex-is-valid().

Does not rely upon global variables, keys, functions, or templates.

`rgx:regex-is-valid()`

TAN-fn-regex-standard

Input: a string

Output: true if the string is a valid regular expression, false otherwise

Related: regular expressions

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon rgx:matches.

`rgx:replace()`

rgx:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string) as xs:string

three-param function of the four-param version below

Used by function rgx:replace().

Relies upon rgx:replace.

Option 2 (TAN-fn-regex-standard)

rgx:replace($input as xs:string?, $pattern as xs:string, $replacement as xs:string, $flags as xs:string) as xs:string

Parallel to fn:replace(), but converts \u{} into classes. See rgx:regex() for 
details.

Input: four strings

Output: the xs:string that is obtained by replacing each non-overlapping 
substring of the first parameter given pattern declared by the second with an occurrence of the 
third, taking into account flags supplied by the fourth.

Used by function rgx:replace().

Does not rely upon global variables, keys, functions, or templates.

`rgx:replace-by-char-name()`

rgx:replace-by-char-name($string-to-replace as xs:string?, $words-in-name-to-drop as xs:string*, $words-in-replacement-char-name as xs:string*, $words-not-in-replacement-char-name as xs:string*, $search-is-strict as xs:boolean?) as xs:string?

five-parameter version of the full function, below

Used by function rgx:replace-by-char-name().

Relies upon rgx:replace-by-char-name.

Option 2 (TAN-fn-regex-standard)

six-parameter version of the full function, below

Used by function rgx:replace-by-char-name().

Relies upon rgx:replace-by-char-name.

`rgx:string-base()`

rgx:string-base($arg as xs:string?) as xs:string?

one-param version of the fuller one, below

Used by function rgx:string-base(), rgx:process-regex-escape-u().

Relies upon rgx:string-base.

Option 2 (TAN-fn-regex-standard)

rgx:string-base($arg as xs:string?, $version as xs:double) as xs:string?

Input: a string and a double

Output: the string, with each character reduced to its base character

This function takes any string and replaces every character with its base Unicode 
character. This function is useful to prepare a text to be searched without respect to accents. 
E.g., ἄνθρωπός - > ανθρωπος Note, the ς is retained because it doesn't decompose. To match 
on σ one needs to use the flag 'i' (case insensitive) because ς case-folds to σ. This 
function is similar to rgx:string-to-components(), but strictly enforces a one-for-one 
replacement, so that it behaves much like fn:lower-case() and fn:upper-case(), where the string 
length is always preserved. To this end, this function is based on fn:translate(), and uses 
simple decomposition databases, which are much smaller and quicker to use than are full 
decomposition databases. The strict one-for-one replacement observes the following rules: If a 
character decomposes to a single character, that single character is returned. If a character 
decomposes to multiple characters that are identical, that single character is returned, 
e.g., ‴ to ′ If a character decomposes to multiple characters, a distinction is made 
between base and non-base characters: 
- Base characters: 
\p{Lu}\p{Ll}\p{Lt}\p{Lo}\p{N}\p{S} 
- Non-base characters: \p{Lm}\p{M}\p{P}\p{Z}\p{C} If after non-base 
characters are removed there is not exactly one unique decomposed character left, the original 
input is retained. The above rules are already reflected in the contents of the simple 
decomposition database, so do not need to be expressed in this function. For more, see 
ucd/ucd-decomp.xsl.

Used by function rgx:string-base(), rgx:process-regex-escape-u().

Does not rely upon global variables, keys, functions, or templates.

`rgx:string-to-components()`

rgx:string-to-components($arg as xs:string?) as xs:string*

one-param version of the fuller one, below

Used by function rgx:string-to-components().

Relies upon rgx:string-to-components.

Option 2 (TAN-fn-regex-standard)

rgx:string-to-components($arg as xs:string?, $version as xs:double) as xs:string*

Input: any string; a Unicode version number.

Output: one string per character in the input; if a character lends itself to 
decomposition, its component parts are returned, otherwise the character itself is returned.

This function is the inverse of rgx:string-to-composites().

If you wish to have more control over which components are returned (e.g., exclusion 
of combining marks), consider using either rgx:string-base() or the database 
directly: rgx:get-ucd-decomp-db(). The each rgx:char/rgx:b has @gc with the code for the 
component's general category

Used by function rgx:string-to-components().

Relies upon $default-ucd-decomp-db.

`rgx:string-to-composites()`

rgx:string-to-composites($arg as xs:string?) as xs:string*

one-parameter version of fuller one, below

Used by function rgx:string-to-composites(), rgx:process-regex-escape-u().

Relies upon rgx:string-to-composites.

Option 2 (TAN-fn-regex-standard)

rgx:string-to-composites($arg as xs:string?, $version as xs:double) as xs:string*

Input: a string; a version of Unicode (double)

Output: one string per character in the input; that string consists of the character 
itself followed by all characters that use it as a base

This function is the inverse of rgx:string-to-components. E.g., 'Max' - > 
'MᴹḾṀṂℳⅯⓂ㎆㎒㎫㎹㎿㏁Ｍ𝐌𝑀𝑴𝓜𝔐𝕄𝕸𝖬𝗠𝘔𝙈𝙼🄼🅋🅪🅫aªàáâãäåāăąǎǟǡǻȁȃȧᵃḁẚạảấầẩẫậắằẳẵặₐ℀℁ⓐ㏂ａ𝐚𝑎𝒂𝒶𝓪𝔞𝕒𝖆𝖺𝗮𝘢𝙖𝚊xˣẋẍₓⅹⅺⅻⓧｘ𝐱𝑥𝒙𝓍𝔁𝔵𝕩𝖝𝗑𝘅𝘹𝙭𝚡' 
This is useful for preparing regex character classes to broaden a search.

Used by function rgx:string-to-composites(), rgx:process-regex-escape-u().

Relies upon $default-ucd-decomp-db.

`rgx:tokenize()`

rgx:tokenize($input as xs:string?, $pattern as xs:string) as xs:string*

two-param function of the three-param version below

Used by function rgx:tokenize().

Relies upon rgx:tokenize.

Option 2 (TAN-fn-regex-standard)

rgx:tokenize($input as xs:string?, $pattern as xs:string, $flags as xs:string) as xs:string*

Parallel to fn:tokenize(), but converts \u{} into classes. See rgx:regex() for 
details.

Input: three strings

Output: the first string cut into a sequence of strings, with any substring that 
matches the second parameter treated as a separator, not returned, taking account into 
flags supplied by the third.

Used by function rgx:tokenize().

Does not rely upon global variables, keys, functions, or templates.

Setup

Used by function tan:dec-to-n(), tan:n-to-dec().

Does not rely upon global variables, keys, functions, or templates.

Definition: ($tan:base26-key, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/')

Used by function tan:dec-to-n(), tan:n-to-dec().

Relies upon $tan:base26-key.

`$tan:body`

Definition: if ($tan:doc-namespace = $tan:TAN-namespace) then $tan:self-resolved/*/(tan:body, tei:text/tei:body) else //*:body

No variables, keys, functions, or named templates depend upon this xsl:variable.

Relies upon $tan:TAN-namespace, $tan:doc-namespace, $tan:self-resolved.

`$tan:break-marker-regex`

Definition: [\|‖  ⁣￺]

Used by template ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1.

Does not rely upon global variables, keys, functions, or templates.

`$tan:char-regex`

Definition: /*/@id

Definition: base-uri(/*)

This variable has a complex definition. See stylesheet for definiton.

No variables, keys, functions, or named templates depend upon this xsl:variable.

Does not rely upon global variables, keys, functions, or templates.

`$tan:error-key`

This variable has a complex definition. See stylesheet for definiton.

This error key pertains NOT to validation errors when evaluating TAN files' 
structures, but to the behavior of TAN functions, mainly when input is not what is expected.

No variables, keys, functions, or named templates depend upon this xsl:variable.

Relies upon $tan:binary-error-key, $tan:hash-error-key, $tan:numeric-conversion-error-key, $tan:octet-error-key.

`$tan:extra-vocabulary-files`

Definition: for $i in $tan:TAN-vocabularies-vocabulary/tan:TAN-voc/tan:body/tan:item[tan:location] return tan:get-1st-doc$i)

No variables, keys, functions, or named templates depend upon this xsl:variable.

Relies upon $tan:TAN-vocabularies-vocabulary, tan:get-1st-doc.

Definition: for $i in $tan:head/tan:vocabulary-key/tan:morphology return tan:resolve-doctan:get-1st-doc$i), true(), tan:attr'morphology', ($i/@xml:id, '1')[1]))

Used by variable $tan:morphologies-expanded.

Used by function tan:expand-doc().

Relies upon $tan:head, tan:attr, tan:get-1st-doc, tan:resolve-doc.

`$tan:most-common-indentations`

This variable has a complex definition. See stylesheet for definiton.

No variables, keys, functions, or named templates depend upon this xsl:variable.

Relies upon tan:most-common-item.

`$tan:names-of-attributes-that-are-case-indifferent`

Definition: ('n', 'ref', 'affects-element', 'affects-attribute', 'item-type', 'in-lang')

Used by template ŧ tan:core-expansion-terse-attributes-to-elements.

Used by function tan:normalize-sequence().

Does not rely upon global variables, keys, functions, or templates.

`$tan:names-of-attributes-that-may-take-multiple-space-delimited-values`

Definition: $tan:names-of-attributes-that-take-idrefs, ('affects-element', 'affects-attribute', 'item-type')

Used by template ŧ tan:core-expansion-terse-attributes-to-elements.

Used by function tan:normalize-sequence().

Relies upon $tan:names-of-attributes-that-take-idrefs.

`$tan:names-of-attributes-that-permit-keyword-last`

Definition: ('pos', 'chars', 'm-has-how-many-features')

Used by function tan:normalize-sequence().

Does not rely upon global variables, keys, functions, or templates.

`$tan:names-of-attributes-that-take-idrefs`

Definition: $tan:id-idrefs/tan:id-idrefs/tan:id/tan:idrefs/@attribute

Used by variable $tan:names-of-attributes-that-may-take-multiple-space-delimited-values.

Used by template ŧ tan:core-expansion-terse-attributes.

Used by function tan:resolve-doc-loop().

Relies upon $tan:id-idrefs.

`$tan:names-of-elements-targeted-by-objects`

Definition: $tan:id-idrefs/tan:id-idrefs/tan:id[tan:idrefs[@attribute = 'object']]/tan:element

Used by template ŧ tan:core-expansion-terse.

Relies upon $tan:id-idrefs.

`$tan:names-of-elements-targeted-by-subjects`

Definition: $tan:id-idrefs/tan:id-idrefs/tan:id[tan:idrefs[@attribute = 'subject']]/tan:element

Used by template ŧ tan:core-expansion-terse.

Relies upon $tan:id-idrefs.

`$tan:names-of-elements-that-describe-text-bearers`

`$tan:regex-characters-not-permitted`

Used by template ŧ tan:core-expansion-normal.

Definition: [ - ]

Used by function tan:normalize-text().

Does not rely upon global variables, keys, functions, or templates.

`$tan:regex-name-space-characters`

Used by function tan:normalize-text().

Definition: [_-]

Does not rely upon global variables, keys, functions, or templates.

`$tan:see-alsos-1st-da`

Definition: tan:get-1st-doc$tan:head/tan:see-also)

Used by variable $tan:see-alsos-resolved.

Relies upon $tan:head, tan:get-1st-doc.

`$tan:see-alsos-resolved`

Definition: tan:resolve-doc$tan:see-alsos-1st-da, false(), tan:attr'relationship', 'see-also'))

No variables, keys, functions, or named templates depend upon this xsl:variable.

Relies upon $tan:see-alsos-1st-da, tan:attr, tan:resolve-doc.

`$tan:self-expanded`

Definition: tan:expand-doc$tan:self-resolved)

Used by variable $tan:self-expanded-vocabulary.

Used by template ŧ tan:imitate-validation.

Relies upon $tan:self-resolved, tan:expand-doc.

`$tan:self-expanded-vocabulary`

Definition: tan:vocabulary(), (), ($tan:self-expanded/(*/tan:head | (tan:TAN-A | tan:TAN-voc)/tan:body)))

No variables, keys, functions, or named templates depend upon this xsl:variable.

Relies upon $tan:self-expanded, tan:vocabulary.

`$tan:self-resolved`

Definition: tan:resolve-doc/)

Used by variable $tan:self-resolved-plus, $tan:self-expanded, $tan:head, $tan:body, $tan:doc-class, $tan:doc-id-namespace, $tan:doc-vocabulary.

Relies upon tan:resolve-doc.

`$tan:self-resolved-plus`

Definition: tan:normalize-tree-space$tan:self-resolved, true())

No variables, keys, functions, or named templates depend upon this xsl:variable.

Relies upon $tan:self-resolved, tan:normalize-tree-space.

`$tan:separator-hierarchy`

`$tan:special-end-div-chars`

Definition: ($tan:zwj, $tan:dhy, $tan:zwsp)

Used by variable $tan:special-end-div-chars-regex.

Used by template ŧ tan:tokenize-div, ŧ tan:normalize-tree-space.

Used by function tan:normalize-div-text().

Relies upon $tan:dhy, $tan:zwj, $tan:zwsp.

`$tan:special-end-div-chars-regex`

Does not rely upon global variables, keys, functions, or templates.

`$tan:TAN-version`

Definition: 2021

Used by template ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1, ŧ tan:resolve-critical-dependencies-loop, ŧ tan:core-expansion-terse.

Does not rely upon global variables, keys, functions, or templates.

`$tan:TAN-version-is-under-development`

Definition: false()

Used by template ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1, ŧ tan:core-expansion-terse.

Does not rely upon global variables, keys, functions, or templates.

`$tan:TAN-vocabularies`

This variable has a complex definition. See stylesheet for definiton.

Used by variable $tan:TAN-feature-vocabulary, $tan:all-vocabularies, $tan:TAN-vocabularies-vocabulary, $tan:extra-vocabulary-files, $tan:token-definitions-reserved.

Used by template ŧ tan:check-referred-doc, ŧ tan:core-expansion-terse-attributes, ŧ tan:resolve-critical-dependencies-loop, ŧ tan:core-expansion-terse, ŧ tan:first-stamp-shallow-copy.

Used by function tan:update-TAN-change-log(), tan:has-vocab().

Relies upon $tan:TAN-vocabulary-files, ŧ tan:expand-standard-tan-voc.

Definition: format-date(current-date(), '[Y0001]-[M01]-[D01]')

No variables, keys, functions, or named templates depend upon this xsl:variable.

Does not rely upon global variables, keys, functions, or templates.

`$tan:today-MDY`

Definition: format-date(current-date(), '[MNn] [D], [Y0001]')

No variables, keys, functions, or named templates depend upon this xsl:variable.

Does not rely upon global variables, keys, functions, or templates.

`$tan:token-definition-default`

`$tan:xpath-regex`

Definition: \{[^\}]+?\}

No variables, keys, functions, or named templates depend upon this xsl:variable.

Does not rely upon global variables, keys, functions, or templates.

`$tan:zwj`

Used by variable $tan:special-end-div-chars.

Definition: ‍

Does not rely upon global variables, keys, functions, or templates.

`$tan:zwsp`

Used by variable $tan:special-end-div-chars.

Definition:

Does not rely upon global variables, keys, functions, or templates.

Keys

`ʞ tan:attrs-by-name`

TAN-keys-standard

`ʞ tan:tok-via-val`

TAN-keys-standard

Looks for elements matching tan:tok

Used by template ŧ tan:mark-dependencies-pass-2-for-validation.

Does not rely upon global variables, keys, functions, or templates.

Arrays

Functions

`tan:array-permutations()`

tan:array-permutations($input-array as array(*)) as array(*)

Input: any array

Output: an array whose members are sequences representing the permutations of each 
item in each member in the input array.

Example: [(1, 2), 'dog'] becomes [(1, 'dog'), (2, 'dog')]

The output array will always have a size equal to the product of the item count in each 
input array member, and the output array's members will share the exact same item count.

Related: arrays

Used by function tan:morphological-code-conversion-maps().

Does not rely upon global variables, keys, functions, or templates.

`tan:array-to-map()`

tan:array-to-map($array-to-convert as array(*)?, $use-first-items-as-keys as xs:boolean) as map(*)?

Input: an array; a boolean

Output: a map; if the boolean is true and the first item in each member of the array is 
uniquely distinct from all other first items then those first items become the key and the tail 
of each member becomes the value of the map entry. Otherwise, the constructed map has 
integers from 1 onward as keys with each array member becoming the value of the map entry.

Related: arrays, maps

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:array-to-map.

`tan:array-to-xml()`

tan:array-to-xml($arrays-to-convert as array(*)*) as element()*

Input: any items

Output: any arrays in each item serialized as XML elements; each member of the array 
will be wrapped by an <array:member> with @type specifying the item type it encloses.

Related: arrays, nodes

Used by function tan:collate-pair-of-sequences().

Relies upon ŧ tan:map-and-array-to-xml.

`tan:xml-to-array()`

tan:xml-to-array($items-to-array as item()*) as array(*)*

Input: XML tree fragments

Output: those parts that conform to the output of tan:array-to-xml() converted to 
arrays. Anything in the input tree not matching array:array or array:member will be 
skipped, unless it is a member an array:array or array:member. Anything in the array:member 
will be bound as the type assigned by the value of @type

Related: arrays, tree manipulation, nodes

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:xml-to-map-and-array.

Booleans

Functions

`tan:true()`

TAN-fn-booleans

tan:true($string as xs:string*) as xs:boolean*

Input: a sequence of strings representing truth values

Output: the same number of booleans; if the string is some approximation of y, yes, 1, 
or true, then it is true, and false otherwise

Related: binary, booleans

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Checksums

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:checksum-fletcher-16()`

Option 1 (TAN-fn-hash-and-check)

tan:checksum-fletcher-16($str as xs:string?) as xs:string?

one-parameter version of the fuller one, below

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Option 2 (TAN-fn-hash-and-check)

tan:checksum-fletcher-16($str as xs:string?, $output-hex as xs:boolean) as item()?

Input: a string, a boolean

Output: if the second parameter is true, a hexadecimal representation of the 
Fletcher 16 checksum on the string, otherwise its integer representation

Related: checksums

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:checksum-fletcher-32()`

Option 1 (TAN-fn-hash-and-check)

tan:checksum-fletcher-32($str as xs:string?) as xs:string?

one-parameter version of the fuller one, below

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Option 2 (TAN-fn-hash-and-check)

tan:checksum-fletcher-32($str as xs:string?, $output-hex as xs:boolean) as item()?

Input: a string, a boolean

Output: if the second parameter is true, a hexadecimal representation of the 
Fletcher 32 checksum on the string, otherwise its integer representation

Related: checksums

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:checksum-fletcher-64()`

Option 1 (TAN-fn-hash-and-check)

tan:checksum-fletcher-64($str as xs:string?) as xs:string?

one-parameter version of the fuller one, below

Used by template ŧ tan:diff-to-delta.

Used by function tan:get-diff-output-transpositions(), tan:apply-deltas().

Does not rely upon global variables, keys, functions, or templates.

Option 2 (TAN-fn-hash-and-check)

tan:checksum-fletcher-64($str as xs:string?, $output-hex as xs:boolean) as item()?

Input: a string, a boolean

Output: if the second parameter is true, a hexadecimal representation of the 
Fletcher 64 checksum on the string, otherwise its integer representation

Related: checksums

Used by template ŧ tan:diff-to-delta.

Used by function tan:get-diff-output-transpositions(), tan:apply-deltas().

Does not rely upon global variables, keys, functions, or templates.

`tan:md5()`

TAN-fn-hash-and-check

tan:md5($input as xs:string?) as item()*

Input: a string

Output: an MD5 checksum for the string

Related: checksums

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:md5-K, $tan:md5-a0, $tan:md5-b0, $tan:md5-c0, $tan:md5-d0, $tan:md5-shifts, $tan:pow2-64, tan:bin-to-bits, tan:bin-to-dec, tan:bits-to-bin, tan:bits-to-byte, tan:bits-to-word, tan:bitwise-and, tan:bitwise-not, tan:bitwise-or, tan:bitwise-plus, tan:bitwise-rotate, tan:bitwise-xor, tan:dec-to-bin, tan:dec-to-hex, tan:ellipses, tan:reverse-string, tan:unicode-to-eight-bit-chars.

Cross-references

Functions

`tan:get-via-q-ref()`

TAN-fn-cross-references

tan:get-via-q-ref($q-ref as xs:string*, $q-reffed-document as document-node()*) as node()*

Input: any number of q-refs, any number of q-reffed documents

Output: the elements corresponding to the q-refs

This function is used by the core validation routine, mainly to find errors in 
expanded output

Related: identifiers

Used by template ŧ tan:imitate-validation.

Does not rely upon global variables, keys, functions, or templates.

Docx

Functions

`tan:docx-to-text()`

TAN-fn-docx

tan:docx-to-text($docx-component as item()*) as xs:string?

Input: docx component as document nodes

Output: the string value of the component

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:archive-to-plain-text.

Files

Variables

`$advanced-functions-available`

Definition: function-available('file:read-binary') and function-available('arch:extract-map') and function-available('bin:encode-string')

Used by template Ŧ tan:save-archive.

Used by function tan:extract-map(), tan:save-docx(), tan:save-xlsx(), tan:open-archive(), tan:archive-available(), tan:archive-map-to-xml(), tan:open-raw-archive(), tan:entries-map(), tan:extract-archive-component(), tan:save-archive(), tan:open-archive-loop().

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:archive-available()`

Option 1 (TAN-fn-file-archive-extended)

tan:archive-available($element-with-attr-href-or-string-with-resolved-uri as item()?) as xs:boolean

Input: any element with an @href, or a string value (or something castable to a 
string)

Output: a boolean indicating whether the document is available

The input url must be resolved.

Related: files, archives

Used by function tan:xlsx-file-available(), tan:docx-file-available().

Relies upon $advanced-functions-available.

Option 2 (TAN-fn-file-archive-extended)

tan:archive-available($element-with-attr-href-or-string-with-resolved-uri as item()?) as xs:boolean

Input: any element with an @href, or a string value (or something castable to a 
string)

Output: a boolean indicating whether the document is available

Note, this version of the function, i.e., the one without advanced functions, 
cannot fetch a uri collection from an archive, so the algorithm has to be told what 
particular component to find. Because it was written for docx and xlsx files, this function 
looks only for the signature _rels/.rels.

The input url must be resolved.

We use the protocol jar: because it is recognized both by oXygen and by Saxon run on the 
command line

Related: files, archives

Used by function tan:xlsx-file-available(), tan:docx-file-available().

Relies upon $advanced-functions-available.

`tan:docx-file-available()`

tan:docx-file-available($element-with-attr-href-or-string-with-resolved-uri as item()?) as xs:boolean

Alias for the function below

tan:first-loc-available($element-with-href-in-self-or-descendants as element()?) as xs:string?

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:archive-available.

`tan:first-loc-available()`

TAN-fn-files-standard

Input: An element that is or contains one or more tan:location elements

Output: the value of the first tan:location/@href to point to a document available, 
resolved. If no location is available nothing is returned.

Related: files

Used by function tan:get-1st-doc().

Relies upon $tan:internet-available, tan:base-uri, tan:url-is-local.

`tan:get-1st-doc()`

TAN-fn-files-standard

tan:get-1st-doc($TAN-elements as element()*) as document-node()*

Input: any TAN elements naming files (e.g., <source>, <see-also>, <inclusion>, 
<vocabulary>

Output: the first document available for each element, plus any relevant error 
messages.

Used by template ŧ tan:get-and-resolve-dependency, ŧ tan:resolve-critical-dependencies-loop, ŧ tan:core-expansion-terse, ŧ tan:class-2-expansion-verbose, ŧ tan:check-referred-doc, ŧ tan:class-1-expansion-verbose-pass-1, ŧ tan:core-expansion-normal.

Used by function tan:get-1st-doc().

Relies upon $tan:internet-available, tan:base-uri, tan:catalogs, tan:element-vocabulary, tan:first-loc-available, tan:get-1st-doc(), tan:resolve-href, tan:shallow-copy, tan:uri-relative-to, tan:url-is-local, tan:xml-to-string, ŧ tan:resolve-href.

`tan:open-archive()`

Option 1 (TAN-fn-file-archive-extended)

tan:open-archive($element-with-attr-href-or-string-with-resolved-uri as item()?) as document-node()*

Input: any element with an @href, or a string value (or something castable to a 
string); a string specifying the type of file to be opened

Output: the components of the target docx or xslx file as a sequence of XML documents 
(the main .rels file first, then the document .rels, then the source content types, then 
every file ending in .xml). To facilitate the reconstruction of the Word file, every 
extracted document will be stamped with @_archive-path, with the local path and name of the 
component.

Related: files, archives

Used by function tan:open-docx(), tan:open-xlsx().

Relies upon $advanced-functions-available, tan:open-raw-archive.

Option 2 (TAN-fn-file-archive-extended)

tan:open-archive($element-with-attr-href-or-string-with-resolved-uri as item()?) as document-node()*

Input: any element with an @href, or a string value (or something castable to a 
string); a string specifying the type of file to be opened

Output: the components of the target docx or xslx file as a sequence of XML documents 
(the main .rels file first, then the document .rels, then the source content types, then 
every file ending in .xml). To facilitate the reconstruction of the Word file, every 
extracted document will be stamped with @_archive-path, with the local path and name of the 
component.

Related: files, archives

Used by function tan:open-docx(), tan:open-xlsx().

Relies upon $advanced-functions-available.

`tan:open-docx()`

tan:open-docx($element-with-attr-href-or-string-with-resolved-uri as item()?) as document-node()*

Alias for the function below, tan:open-archive()

Related: files, archives

Used by function tan:open-file().

Relies upon tan:open-archive.

`tan:open-file()`

Option 1 (TAN-fn-files-extended)

tan:open-file($resolved-urls)

1-parameter version of the main one below

Used by function tan:open-file().

Relies upon tan:open-file.

Option 2 (TAN-fn-files-extended)

tan:open-file($resolved-urls, $target-fallback-encoding as xs:string*) as document-node()*

Input: items that can be resolved as strings; a string

Output: for each resolvable string in the first parameter, if a document is 
available, the document; if it is not, but unparsed text is available, a document with the 
unparsed text wrapped in a root element; otherwise an empty document node. If unparsed text is 
not available, another attempt will be made on a fallback encoding specified by the 2nd 
parameter.

If the file is plain text that is not XML, it will be wrapped by a root element of an XML 
document. That root node will have @xml:base pointing to the source url.

If it is a .docx file, the components XML documents of the Word document will be 
returned.

Related: files

Used by function tan:open-file().

Relies upon tan:open-docx.

`tan:open-raw-archive()`

tan:open-raw-archive($element-with-attr-href-or-string-with-resolved-uri as item()?) as xs:base64Binary?

Input: an item pointing to a URI

Output: the contents of the target archive as base 64 binary

This function is basically a padded alternative to file:read-binary()

Used by function tan:open-archive(), tan:entries-map().

Relies upon $advanced-functions-available.

`tan:open-xlsx()`

tan:open-xlsx($element-with-attr-href-or-string-with-resolved-uri as item()?) as document-node()*

Alias for the function below, tan:open-archive()

Related: files, archives

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:open-archive.

`tan:save-archive()`

tan:save-archive($archive-components as document-node()*, $resolved-uri as xs:string)

surrogate function for the named template, below

Used by function tan:save-docx(), tan:save-xlsx().

Relies upon $advanced-functions-available, Ŧ tan:save-archive.

`tan:save-docx()`

tan:save-docx($archive-components as document-node()*, $resolved-uri as xs:string)

Alias for the function below

Related: files, archives, docx

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $advanced-functions-available, tan:save-archive.

`tan:save-xlsx()`

tan:save-xlsx($archive-components as document-node()*, $resolved-uri as xs:string)

Alias for the function below

tan:url-is-local($url-to-test as xs:string?) as xs:boolean

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $advanced-functions-available, tan:save-archive.

`tan:url-is-local()`

TAN-fn-files-standard

Input: a string representing a URL

Output: true if the URL syntactically appears to be local

Related: files, filenames

Used by template ŧ tan:core-expansion-terse-attributes-to-elements, ŧ tan:check-referred-doc.

Used by function tan:first-loc-available(), tan:get-1st-doc().

Does not rely upon global variables, keys, functions, or templates.

`tan:xlsx-file-available()`

tan:xlsx-file-available($element-with-attr-href-or-string-with-resolved-uri as item()?) as xs:boolean

Alias for the function below

tan:zip-uris($uris as xs:string*) as xs:anyURI*

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:archive-available.

`tan:zip-uris()`

TAN-fn-files-extended

Input: any string representing a uri

Output: the same string with 'zip:' prepended if it represents a uri to a file in an 
archive (docx, jar, zip, etc.)

Option 1 (TAN-fn-file-archive-extended)

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Templates

`Ŧ tan:save-archive`

Input: a sequence of documents that each have @_archive-path stamped in the root 
element (the result of tan:open-docx()); a resolved uri for the new Word document

Output: an archive saved at the URL specified by the second parameter

Used by template Ŧ tan:save-docx, Ŧ tan:save-xlsx.

Used by function tan:save-archive().

Relies upon $advanced-functions-available, ŧ tan:clean-up-archive.

Option 2 (TAN-fn-file-archive-extended)

Input: a sequence of documents that each have @_archive-path stamped in the root 
element (the result of tan:open-docx()); a resolved uri for the new Word document

Output: an archive saved at the URL specified by the second parameter

Ordinarily, this template would be a function, but security reasons dictate that 
<xsl:result-document> always fails in the context of a function.

In this function, the target subdirectory for the archive must already exist, or 
else you might get an error.

Used by template Ŧ tan:save-docx, Ŧ tan:save-xlsx.

Used by function tan:save-archive().

Relies upon $advanced-functions-available, ŧ tan:clean-up-archive.

`Ŧ tan:save-as`

TAN-fn-file-output

Input: any document, perhaps a target URI and target format, and a boolean 
indicating whether every top-level item should appear on its own line.

The root element's attribute @_target-uri or @save-as supplies the default value, 
which may be overwritten.

No variables, keys, functions, or named templates depend upon this xsl:template.

Relies upon ŧ tan:save-file.

`Ŧ tan:save-docx`

No variables, keys, functions, or named templates depend upon this xsl:template.

Relies upon Ŧ tan:save-archive.

`Ŧ tan:save-xlsx`

No variables, keys, functions, or named templates depend upon this xsl:template.

Relies upon Ŧ tan:save-archive.

Html

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:blend-alpha-value()`

TAN-fn-html-colors

tan:blend-alpha-value($alpha-a as xs:double, $alpha-b as xs:double, $blend-mid-point as xs:double) as xs:double?

Input: three doubles between zero and 1

Output: the blend of the first two doubles, interpreted as alpha values and the third 
interpreted as a midpoint

Related: html, colors

Used by function tan:blend-colors().

Does not rely upon global variables, keys, functions, or templates.

`tan:blend-color-channel-value()`

TAN-fn-html-colors

tan:blend-color-channel-value($color-a as xs:double, $color-b as xs:double, $blend-mid-point as xs:double) as xs:double?

Input: two integers and a double between zero and 1

Output: a double representing a blend between the first two numbers, interpreted as 
RGB values

Related: html, colors

Used by function tan:blend-color-channel-value(), tan:blend-colors().

Relies upon tan:blend-color-channel-value().

`tan:blend-colors()`

TAN-fn-html-colors

tan:blend-colors($rgb-color-1 as item()+, $rgb-color-2 as item()+, $blend-mid-point as xs:double) as xs:double*

Input: two sequences of doubles (the first three items being from 0 through 255 and 
the fourth and last between 0 and 1); a double between zero and 1

Output: a sequence of doubles representing a blend of the first two sequences, 
interpreted as RGB colors, and the last double as a desired midpoint

Related: html, colors

Used by function tan:blend-colors().

Relies upon tan:blend-alpha-value, tan:blend-color-channel-value, tan:blend-colors().

`tan:convert-to-html()`

Option 1 (TAN-fn-html-core)

tan:convert-to-html($fragment-to-convert as item()*, $parse-text-for-urls as xs:boolean) as item()*

2-param version of fuller one, below

Used by function tan:convert-to-html(), tan:diff-or-collate-to-html().

Relies upon tan:convert-to-html.

Option 2 (TAN-fn-html-core)

tan:convert-to-html($fragment-to-convert as item()*, $parse-a-hrefs as xs:boolean, $attributes-to-retain-regex as xs:string, $keep-attributes-named-after-global-html-attributes as xs:boolean) as item()*

Input: Any XML tree fragment; a boolean; a string

Output: The fragment converted to HTML (described below); if the boolean is true, 
text will be parsed for URLs and wrapped in <a href="">; if the third parameter is a valid 
regular expression, attributes whose names match the pattern will be retained unchanged.

Every element is converted to an HTML <div>, with the name of the element or attribute 
being placed inside the @class as a value: e-[NAME] for elements and a-[NAME] for 
attributes. In addition, if the element or attribute is in a namespace, the namespace is included 
as a class value, ns-[NAMESPACE PREFIX]. Comments and processing instructions are 
preserved intact.

Any element already in the HTML namespace will be left as-is, with templates 
continued to be applied to its descendants.

Some attributes are handled specially: Every @xml:* is retained, but with only the 
local name, no prefix. Every attribute in an html element is retained as-is. No attribute 
@class is rendered as an element. No attribute beginning with _ is rendered as an element, 
and it is retained as-is. (It is your responsibility to get rid of temporary attributes 
you do not want, either before or after this function runs.)

Related: html, nodes, tree manipulation

Used by function tan:convert-to-html(), tan:diff-or-collate-to-html().

Relies upon tan:get-namespace-map, ŧ tan:parse-a-hrefs, ŧ tan:tree-to-html.

`tan:diff-or-collate-to-html()`

TAN-fn-html-diff-and-collate

tan:diff-or-collate-to-html($diff-or-collate-results as element()?, $primary-version-ref as xs:string?, $primary-version-tree as element()*) as item()*

Input: the results of tan:diff() or tan:collate(), ideally when given wrapped by 
<group> along with statistics; perhaps a string; perhaps a tree structure (see below)

Output: the results converted to HTML divs, with the following provisos: 
* Any 
adjustments to the text of the diff/collate output should be run beforehand, optimally via 
tan:replace-diff() or tan:replace-collation(). 
* The second parameter points to an idref. If the main 
input is a diff, then the expected value is 'a' or 'b' (default). If it is a collation, then it 
is a label that points to tan:collation/tan:witness/@id (default: the last one, if no 
match). The resolved parameter points to the primary version. 
* The third parameter is a 
tree structure of elements with the primary version. This is structure that will become 
the primary way to view the diff/collation. The diff/collation will be chopped 
proportionally to be infused into the text nodes of the tree. This allows the HTML file to be 
structured not as a flat diff/collate, but in a hierarchy that is native to one of the versions. 
* 
Collation ids are case-sensitive; diffs, however, must be simply a or b. 
* Any notices or other 
elements must be inserted before processing.

Related: html, diff, tree manipulation

Used by function tan:diff-or-collate-to-html().

Relies upon tan:convert-to-html, tan:diff, tan:diff-or-collate-to-html(), tan:ellipses, tan:shallow-copy, tan:trim-long-tree, ŧ diff-or-collate-to-html-output-pass-1.

`tan:parse-a-hrefs()`

TAN-fn-html-core

tan:parse-a-hrefs($string-to-parse as xs:string?) as item()*

Input: a string

Output: a sequence mixing text nodes and elements, with elements being HTML <a 
href=""/> wrappers for URIs.

Related: html, strings, filenames

Used by template ŧ tan:parse-a-hrefs.

Does not rely upon global variables, keys, functions, or templates.

Language

Variables

`$languages-supported`

Definition: map:keys($tan:lang-catalog-map)

Used by function tan:lang-catalog().

Does not rely upon global variables, keys, functions, or templates.

`$tan:grc-tokens-without-accents`

Definition: doc('grc-tokens-without-accents.xml')/*/*

No variables, keys, functions, or named templates depend upon this xsl:variable.

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:convert-morphological-codes()`

tan:convert-morphological-codes($TAN-A-lm-to-convert as document-node()?, $morphology-ids-to-convert as xs:string, $morphology-code-conversion-maps as map(*)*) as document-node()?

Input: a TAN-A-lm file, a sequence of strings, maps that are the result of 
tan:morphological-code-conversion-maps()

Output: the TAN-A-lm file, with relevant <m> codes converted. This will be applied 
only to <m> whose closest @morphology is one of the strings from the second parameter, and 
codes will be converted from the source to the target according to the maps supplied.

The second parameter can be empty; If so, then the default with be the values in 
/tan:TAN-A-lm/tan:body/@morphology

This function does not change the vocabulary or @morphology codes. That must be done 
separately.

See comments at tan:morphological-code-conversion-maps() regarding 
difficulties inherent in mapping grammatical systems to each other.

Related: language, lexicomorphology

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:convert-morphological-codes.

`tan:greek-graves-to-acutes()`

tan:greek-graves-to-acutes($greek-to-change as xs:string?) as xs:string?

Input: text with Greek

Output: the same, but with grave accents changed to acutes

Related: language, Greek

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:lang-catalog()`

tan:lang-catalog($lang-codes as xs:string*) as document-node()*

Input: language codes

Output: the catalogs for those languages

Related: language

Used by function tan:lm-data().

Relies upon $languages-supported.

`tan:lang-code()`

tan:lang-code($lang-name as xs:string?) as xs:string*

Input: the name of a language

Output: the 3-letter code for the language

If no exact match is found, the parameter will be treated as a regular expression, and 
all case-insensitive matches will be returned

Related: language

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:iso-639-3.

`tan:lang-name()`

tan:lang-name($lang-code as xs:string?) as xs:string*

Input: the code of a language

Output: the name of the language

If no exact match is found, the parameter will be treated as a regular expression, and 
all case-insensitive matches will be returned

Related: language

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:iso-639-3.

`tan:lm-data()`

tan:lm-data($token-value as xs:string?, $lang-codes as xs:string*) as element()*

Input: token value; a language code

Output: <lm> data for that token value from any available resources

Related: language, lexicomorphology

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:base-uri, tan:lang-catalog, tan:search-morpheus, tan:search-results-to-claims.

`tan:morphological-code-conversion-maps()`

tan:morphological-code-conversion-maps($source-TAN-mor-resolved as document-node(), $target-TAN-mor-resolved as document-node()) as map(*)*

Input: two TAN-mor files, resolved

Output: a sequence of one or more maps, one per category in the first TAN-mor file. If 
the first TAN-mor file lacks categories, then only one map is returned. Each map's map 
entries have keys corresponding to the morphological codes allowed for that category. The 
values consists of an array. Each array member is a sequence of two items: an integer and a 
string. The integer specifies the position of the target morphological category and the 
string, the morphological code. The order of the array members corresponds to apparent 
preference.

Non-categorized morphologies can take advantage of <alias> to build complex 
grammatical features, which complicates the output of this function somewhat. Mapping from 
simple feature to simple feature is straightforward. Mapping from complex feature to 
simple feature requires a one-to-many map, and if a complex feature in the source 
morphology does not have a counterpart in the target for every simple feature that makes up the 
complex one, then no match exists and the code is not supported. It gets a bit tougher for 
mapping to a complex feature in the target morphology. Preleminary work is done to find those 
complex features, then detect every mapping of simple or complex objects that could be 
translated into that target complex feature. If the source morphology is category-based, the 
result is a regular expression to match against <m>. If the source morphology lacks 
categories, then an alphabetized list of codes becomes the key to the target complex feature. A 
map of to all target complex features is inserted in the first output map. These can be 
found simply by looking for the presence of space or the opening ^ in the key name.

Because TAN-mor was designed to enable a wide range of grammatical constructions, 
and because designers have different views on language and categories, converting 
from one morphological code system to another can be messy, with features in either the 
source or target that lack any counterpart in the other. Or there may be overlapping results 
when assessing complex features. For example, in the Perseus system for Greek, a word 
marked as a singular personal pronoun will have at least three grammatical categories that 
will result in a mapping to the Brown system for English as both NN (singular noun) and NP 
(proper noun), both of which are true. It is up to users to discern on a case-by-case basis the 
best way to resolve ambiguity and incommensurability.

Related: language, lexicomorphology

Used by function tan:morphological-code-conversion-maps().

Relies upon tan:array-permutations, tan:duplicate-items, tan:morphological-code-conversion-maps(), tan:vocabulary, ŧ tan:add-category-position.

`tan:syriac-marks-to-word-end()`

tan:syriac-marks-to-word-end($input-syriac-text as xs:string?) as xs:string?

Input: a string

Output: the string with Syriac marks placed at the end, in codepoint order

This function was written to assist in comparing Syriac words that match. Which 
letter a particular dot is placed should not matter, in most cases.

Related: language, Syriac

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Maps

Functions

`tan:map-contains()`

tan:map-contains($map-of-interest as map(*)*, $keys-of-interest as xs:anyAtomicType*) as xs:boolean

Input: a map; a sequence of items

Output: true if the map, or any map it contains, has a key identical to one of the items, 
otherwise false.

This function parallels map:contains() but permits multiple inputs and deep 
searching

Option 1 (TAN-fn-maps-extended)

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:map-entries()`

tan:map-entries($source-map as map(*)*) as map(*)*

One-param version of the full one below

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Option 2 (TAN-fn-maps-extended)

tan:map-entries($source-map as map(*)*, $keys-to-keep as xs:anyAtomicType*) as map(*)*

Input: a map

Output: one singleton map per map entry.

This function was written to support templates or functions that use predicates to 
restrict a particular map's entries to only select ones.

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:item-type.

`tan:map-invert()`

tan:map-invert($map-to-invert as map(*)) as map(*)

Input: a map

Output: a map, where the keys are all those values of the input map that are atomic 
items and each item's value are the keys in the original map that point to it.

This function was written to provide a kind of reverse lookup on any map. Any value 
that is not an atomic item will be discarded.

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:map-keys()`

tan:map-keys($map-of-interest as map(*)*) as item()*

Input: a map

Output: all map keys, both at the top level and at any depth

This function parallels map:keys() but permits recursion

Option 1 (TAN-fn-maps-extended)

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:map-keys.

`tan:map-put()`

tan:map-put($map as map(*), $put-map as map(*), $at-depth as xs:integer, $target-map-must-have-what-key as xs:anyAtomicType?) as map(*)

4-parameter version of the complete function below.

Here the 2nd parameter is simply a map, all of whose map entries are intended 
insertions. This allows the user of the function to make multiple insertions at once.

Used by function tan:map-put().

Relies upon tan:map-put.

Option 2 (TAN-fn-maps-extended)

tan:map-put($map as map(*), $key as xs:anyAtomicType, $value as item()*, $at-depth as xs:integer, $target-map-must-have-what-key as xs:anyAtomicType?) as map(*)

Input: a map; an atomic type representing a key for a new map entry; any items, 
representing the value for a new map entry; an integer, specifying the depth of map to receive the 
entry (0 or less will apply to every map); a string, specifying a key that must be present in a 
map that must receive the entry.

Output: the input map, but with a new map entry at each map of depth specified by the 
fourth parameter, provided that it has a key specified by the fifth.

If the fourth parameter is less than 0, then the entry will be placed throughout every 
map: the initial map itself and any enclosed map of any depth.

If the fifth parameter is not empty, then the target map must have a map entry with an 
identical key for it to qualify to take the new map entry; if the parameter is empty, this 
qualification is ignored.

If a key exists already in a target map, the new entry replaces the current one, 
otherwise it is added as a new map entry.

This function parallels map:put(), but allows for deep placement of entries. This 
function was written to support a more DRY-friendly approach to creating maps for 
transform(), which has submaps that might need to be altered and refactored, depending on various 
conditions.

It is presently difficult to select particular deep maps for a target action. The 
last two parameters of this function provide a bit of control over where the action is 
applied. One strategy that can be adopted, to use this function better, is to supply in each map 
a single map entry with a key corresponding to an id (perhaps via fn:generate-id()) 
with an empty value. That empty map entry then can serve as a hook equivalent to @xml:id in 
an element.

Related: maps

Used by function tan:map-put().

Relies upon tan:item-type, ŧ tan:map-put.

`tan:map-remove()`

tan:map-remove($map-of-interest as map(*), $keys as xs:anyAtomicType*) as map(*)

Input: any map, a sequence of atomic items

Output: the map, but without entries of the specified key, at any depth

This function parallels map:remove(), but affects contained maps at any depth, 
even those embedded within an array.

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:map-remove.

`tan:map-to-array()`

tan:map-to-array($map-to-convert as map(*)?, $sort-keys as xs:boolean) as array(*)?

Input: a map; a boolean

Output: the map as an array, one member of the array per map entry, with the first item 
in the member constituting the key and its second items onward the values. If the 
boolean is true, then the keys will be sorted, otherwise the order of the array is 
implementation-dependent.

Related: maps, arrays

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:map-to-xml()`

Option 1 (TAN-fn-maps-extended)

tan:map-to-xml($items-to-convert as item()*) as element()*

one-parameter version of fuller one below

Used by function tan:map-to-xml(), tan:get-diff-output-transpositions(), tan:replace-diff().

Relies upon tan:map-to-xml.

Option 2 (TAN-fn-maps-extended)

tan:map-to-xml($items-to-convert as map(*)*, $sort-keys as xs:boolean) as element()*

Input: any maps; a boolean

Output: any maps in each item serialized as XML elements; the map entries will be 
sorted lexicographically by the key's string value if the boolean is true, otherwise the 
order of map entries is implementation-dependent.

For those accustomed to handling ordinary XML nodes, maps can be frustrating to work 
with. This function allows one to change a map to XML, and do fun things with it, without 
requiring map functions.

Related: maps, nodes

Used by function tan:map-to-xml(), tan:get-diff-output-transpositions(), tan:replace-diff().

Relies upon ŧ tan:map-and-array-to-xml.

`tan:xml-to-map()`

tan:xml-to-map($items-to-map as item()*) as map(*)*

Input: XML tree fragments

Output: those parts that conform to the output of tan:map-to-xml() converted to 
maps. Anything in the input tree not matching <map:map>, <map:entry>, <map:key>, 
<map:value> will be skipped, unless it is a member of <map:key> or <map:value>. Anything in the 
key or value will be bound as the type assigned by the values of @type..

Related: maps, nodes, tree manipulation

Used by template ŧ tan:build-maps-and-arrays.

Relies upon ŧ tan:xml-to-map-and-array.

Merging

Functions

`tan:group-divs()`

TAN-fn-merging

tan:group-divs($divs-to-group as element()*) as element()*

Input: expanded <div>s

Output: those <div>s grouped in <group>s according to their <ref> values

Attempt is made to preserve original div order

Used by template ŧ tan:merge-divs.

Used by function tan:group-divs().

Relies upon tan:collate-sequences, tan:group-divs(), tan:group-elements-by-shared-node-values.

`tan:merge-divs()`

Option 1 (TAN-fn-merging)

tan:merge-divs($expanded-class-1-fragment as item()*) as item()*

one-parameter version of the fuller one below

Used by function tan:merge-divs().

Relies upon tan:merge-divs.

Option 2 (TAN-fn-merging)

tan:merge-divs($expanded-class-1-fragment as item()*, $itemize-leaf-divs as xs:boolean) as item()*

two-parameter version of the fuller one below

Used by function tan:merge-divs().

Relies upon tan:merge-divs.

Option 3 (TAN-fn-merging)

tan:merge-divs($expanded-class-1-fragment as item()*, $itemize-leaf-divs as xs:boolean, $exclude-elements-with-duplicate-values-of-what-attribute as xs:string?, $keep-last-duplicate as xs:boolean?) as item()*

Input: expanded class 1 document fragment whose individual <div>s are assumed to be 
in the proper hierarchy (result of tan:normalize-text-hierarchy()); a boolean 
indicating whether leaf divs should be itemized; an optional string representing the name of an 
attribute to be checked for duplicates

Output: the fragment with the <div>s grouped according to their <ref> values

If the 2nd parameter is true, for each leaf <div> in a group there will be a separate 
<div type="#version">; otherwise leaf divs will be merely copied

For merging multiple files normally the value should be true; if they are misfits 
from a single source, false

Used by function tan:merge-divs().

Relies upon ŧ tan:merge-divs.

`tan:merge-expanded-docs()`

TAN-fn-merging

tan:merge-expanded-docs($expanded-docs as document-node()*) as document-node()?

Input: Any TAN documents that have been expanded at least tersely

Output: A document that is a collation of the documents. There is one <head> per 
source, but only one <body>, with contents merged.

Templates will be placed in the appropriate function file, e.g., class 1 merge 
templates are in TAN-class-1-functions.xsl

Class 1 merging: All <div>s with the same <ref> values are grouped together. If the 
class 1 files are sources of a class 2 file, it is assumed that all actions in the 
<adjustments> have already been performed.

Class 2 merging: TBD

Class 3 merging: TBD

NB: Class 1 files must have their hierarchies in proper order; use reset-hierarchy 
beforehand if you're unsure

Related: merging, files

Used by template ŧ tan:class-1-expansion-verbose-pass-1.

Relies upon ŧ tan:merge-tan-docs.

Nodes

Functions

`tan:add-attributes()`

tan:add-attributes($elements-to-adjust as element()*, $attributes-to-insert as attribute()*) as element()*

Input: a sequence of elements; a sequence of attributes

Output: each element with a copy of the attributes

This function helps simplify code where one wishes merely to return a copy of an 
element with perhaps diagnostic information in an attribute

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:attr()`

tan:attr($attribute-name as xs:string?, $attribute-value as xs:string?) as attribute()?

Input: two strings

Output: an attribute by the name of the first string, with the value of the second

Related: nodes, attributes

Used by variable $tan:annotations-resolved, $tan:see-alsos-resolved, $tan:predecessors-resolved, $tan:successors-resolved, $tan:redivisions-resolved, $tan:model-resolved, $tan:sources-resolved, $tan:morphologies-resolved.

Does not rely upon global variables, keys, functions, or templates.

`tan:chop-tree()`

tan:chop-tree($tree-to-chop as item()*, $chop-points as xs:integer*) as map(xs:integer, item()*)

Input: any XML fragment; a sequence of integers

Output: a map, with the XML fragment chopped into portions supplied by the integers, 
interpreted as string positions at which to chop the tree. Thus, each map entry has a key of an 
integer and content/value consisting of the corresponding slice of the tree.

The integer 1 is always inferred, and returned. Any integers greater than the string 
length of the tree will be ignored.

For a similar, but more complex function, see tan:chop-diff-output()

Related: nodes, tree manipulation

Used by function tan:giant-diff(), tan:get-diff-output-slices(), tan:chop-tree().

Relies upon tan:chop-tree(), tan:sequence-to-tree, tan:tree-to-sequence, ŧ tan:recheck-chopped-tree.

`tan:copy-indentation()`

tan:copy-indentation($items-to-indent as item()*, $model-element as element()) as item()*

2-parameter version of fuller one below

Used by function tan:copy-indentation().

Relies upon tan:copy-indentation.

Option 2 (TAN-fn-nodes-standard)

tan:copy-indentation($items-to-indent as item()*, $model-element as element(), $tail-indentation-type as xs:string?) as item()*

Input: items that should be indented; an element whose indentation should be 
imitated; a string: 'full', 'short', or 'none'

Output: the items, indented according to the pattern

If the third parameter is 'full', the last indentation after the series will be like 
the first; if it is 'short', it will be one indentation less than full (appropriate for 
the last child of a wrapping element); if it is 'none' no final indentation will be 
supplied. This parameter affects only the topmost sequence, not the children, which are 
formatted as demanded.

Related: nodes, tree manipulation, spacing

Used by function tan:copy-indentation().

Relies upon ŧ tan:indent-items.

`tan:copy-of-except()`

tan:copy-of-except($doc-fragment as item()*, $exclude-elements-named as xs:string*, $exclude-attributes-named as xs:string*, $exclude-elements-with-attributes-named as xs:string*) as item()*

short version of the full function, below

Used by template ŧ tan:mark-reassigns, ŧ tan:apply-inclusions-and-adjust-vocabulary, ŧ tan:core-expansion-normal, ŧ tan:class-1-expansion-verbose-pass-1.

Used by function tan:copy-of-except().

Relies upon tan:copy-of-except.

Option 2 (TAN-fn-nodes-standard)

tan:copy-of-except($doc-fragment as item()*, $exclude-elements-named as xs:string*, $exclude-attributes-named as xs:string*, $exclude-elements-with-attributes-named as xs:string*, $exclude-elements-beyond-what-depth as xs:integer?, $shallow-skip-elements-named as xs:string*) as item()*

Input: any document fragment; sequences of strings specifying names of elements to 
exclude, names of attributes to exclude, and names of attributes whose parent elements 
should be excluded; an integer beyond which depth copies should not be made

Output: the same fragment, altered

This function was written primarily to service the merge of TAN-A sources, where 
realigned divs could be extracted from their source documents

Related: nodes, tree manipulation

Used by template ŧ tan:mark-reassigns, ŧ tan:apply-inclusions-and-adjust-vocabulary, ŧ tan:core-expansion-normal, ŧ tan:class-1-expansion-verbose-pass-1.

Used by function tan:copy-of-except().

Relies upon ŧ tan:copy-of-except.

`tan:data-type-check()`

tan:data-type-check($item as item()?, $data-type as xs:string) as xs:boolean

Input: an item and a string naming a data type

Output: a boolean indicating whether the item can be cast into that data type

If the first parameter doesn't match a data type, the function returns false

Related: nodes, datatypes

Used by template ŧ tan:core-expansion-terse.

Does not rely upon global variables, keys, functions, or templates.

`tan:element-fingerprint()`

tan:element-fingerprint($element as element()*) as xs:string*

Input: any elements

Output: for each element the string value of its name, its namespace, its 
attributes, and all descendant nodes

This function is useful for determining whether any number of elements are deeply 
equal

The built-in function deep-equal() works for pairs of elements; this looks for a way 
to evaluate sequences of elements

Related: nodes, identifiers

Used by function tan:restore-chopped-tree().

Relies upon ŧ tan:element-fingerprint.

`tan:get-namespace-map()`

tan:get-namespace-map($input-tree-fragment as item()*) as map(*)

Input: any XML tree fragment

Output: a map with two entries per namespace, one with the key as the prefix and value 
of the URI, the other with the two items reversed.

Items are collected deeply through the tree structure, with precedence, in case of 
contradiction, given to the namespaces closest to the root

Related: nodes, namespaces

Used by function tan:convert-to-html().

Relies upon ŧ tan:build-namespace-map.

`tan:get-ref()`

tan:get-ref($class-1-element as element()?) as xs:string*

Input: any element

Output: every possible combination of @n values from the self-and-ancestor nodes, 
string-joined by the hierarchy separator.

This function is useful for handling raw or resolved class 1 files, and you need to get 
references

Related: nodes, pointers, identifiers

Used by key ʞ tan:div-via-calculated-ref.

Relies upon $tan:separator-hierarchy.

`tan:group-elements-by-shared-node-values()`

tan:group-elements-by-shared-node-values($elements-to-group as element()*) as element()*

One-parameter version of the fuller one below.

Used by template ŧ tan:core-expansion-terse.

Used by function tan:group-elements-by-shared-node-values(), tan:group-elements-by-IRI(), tan:group-divs-by-ref(), tan:group-divs().

Relies upon tan:group-elements-by-shared-node-values.

Option 2 (TAN-fn-nodes-standard)

tan:group-elements-by-shared-node-values($elements-to-group as element()*, $regex-of-names-of-nodes-to-group-by as xs:string?) as element()*

Two-parameter version of the fuller one below

Used by template ŧ tan:core-expansion-terse.

Used by function tan:group-elements-by-shared-node-values(), tan:group-elements-by-IRI(), tan:group-divs-by-ref(), tan:group-divs().

Relies upon tan:group-elements-by-shared-node-values.

Option 3 (TAN-fn-nodes-standard)

tan:group-elements-by-shared-node-values($elements-to-group as element()*, $regex-of-names-of-nodes-to-group-by as xs:string?, $group-by-shallow-node-value as xs:boolean) as element()*

Input: a sequence of elements; an optional string representing the name of children 
in the elements

Output: the same elements, but grouped in <group> according to whether the text 
contents of the child elements specified are equal

Each <group> will have an @n stipulating the position of the first element put in the 
group. That way the results can be sorted in order of their original elements

Transitivity is assumed. Suppose elements X, Y, and Z have children values A and B; B 
and C; and C and D, respectively. All three elements will be grouped, even though Y and Z do 
not directly share children values.

Related: nodes, grouping

Used by template ŧ tan:core-expansion-terse.

Used by function tan:group-elements-by-shared-node-values(), tan:group-elements-by-IRI(), tan:group-divs-by-ref(), tan:group-divs().

Relies upon tan:duplicate-items, tan:group-elements-by-shared-node-values(), ŧ tan:build-grouping-key.

`tan:infuse-tree()`

tan:infuse-tree($string-to-infuse as xs:string?, $tree-to-infuse as item()*, $break-at-regex as xs:string) as item()*

Input: a string; an XML fragment that should be infused with the text; a string

Output: the XML fragment's text nodes replaced with the text proportionate to the 
length of each text being replaced

Before applying this function, make sure the tree you send is appropriately 
normalized. No space-normalization will occur, and infusion will occur wherever there are 
indentations. To avoid this behavior, first run tan:strip-outer-indentation() or 
tan:normalize-tree-space()

Document nodes will be ignored.

Note: if the regular expression allows breaks within words, then a word may be broken 
across two <div>s, which, because of space normalization rules, then winds up inserting a 
space that was not there before. Be sure to use a good regular expression to avoid bad 
breaks.

Related: nodes, tree manipulation

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:ellipses, tan:make-non-mixed, tan:numbers-to-portions, tan:segment-string, ŧ tan:infuse-tokenized-text.

`tan:insert-as-first-child()`

tan:insert-as-first-child($items-to-be-changed as item()*, $items-to-insert-as-first-child as item()*, $names-of-elements-to-receive-action as xs:string*) as item()*

Input: items to be changed; items to be inserted; strings representing the names of 
the elements that should receive the insertion

Output: the first items, with the second items inserted in the appropriate place

This function allows the deep insertion of content

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:insert-content.

`tan:insert-as-last-child()`

tan:insert-as-last-child($items-to-be-changed as item()*, $items-to-insert-as-last-child as item()*, $names-of-elements-to-receive-action as xs:string*) as item()*

Input: items to be changed; items to be inserted; strings representing the names of 
the elements that should receive the insertion

Output: the first items, with the second items inserted in the appropriate place

This function allows the deep insertion of content

This function was first written to aid a 2019 version of tan:vocabulary()

Related: nodes, tree manipulation

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:insert-content.

`tan:last-change-agent()`

tan:last-change-agent($TAN-doc as document-node()*) as element()*

Input: any TAN document

Output: the <person>, <organization>, or <algorithm> who made the last change

Related: nodes

Used by template ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1, ŧ tan:check-referred-doc, ŧ tan:core-expansion-terse.

Relies upon tan:get-doc-history, tan:vocabulary.

`tan:make-non-mixed()`

tan:make-non-mixed($input-to-adjust as item()*) as item()*

Input: any items that need to be converted to non-mixed content

Output: the input, but with any text nodes that have siblings and are not outer 
indentations wrapped in <_text> elements, with a @q containing the value of generate-id() for the 
text node in question. The identifier can be used to facilitate comparison with the 
original.

Used by function tan:infuse-tree().

Relies upon ŧ tan:make-non-mixed.

`tan:normalize-tree-space()`

tan:normalize-tree-space($input-tree as item()*, $remove-special-end-div-chars as xs:boolean) as item()*

Input: any XML tree; boolean

Output: the same, but space-normalized: 
- all outer indentations are removed 
- if 
an element is known to contain only non-mixed content, all inner text nodes are 
space-normalized 
- otherwise any element that contains non-space text will be space-normalized: 
- 
initial space is removed 
- in the text from the first through last non-space character 
(excluding special end-div characters) any sequence of consecutive space characters will be 
replaced by a single word space; that single word space will be placed in the first text node 
only, and any other text nodes that contain the consecutive space character block will 
have all initial space removed 
- any final space characters in the string value of the 
element will be removed 
- if the last non-space character is not a special end-div 
character, a single word space will be added at the end 
- if the 2nd parameter is true, any special 
end-div characters will be removed

Because this function attends to space normalization as a mixed-content problem, 
it will space-normalize select TEI constructions.

Expanded TAN files are space normalized via this function, so there is no sense in 
running them again. In fact, it can introduce errors (because special div-end characters 
have already been removed).

Used by variable $tan:self-resolved-plus.

Used by template ŧ tan:get-and-resolve-dependency.

Used by function tan:expand-doc().

Relies upon ŧ tan:normalize-tree-space, ŧ tan:selectively-adjust-tei-space, ŧ tan:strip-outer-indentation.

`tan:path()`

tan:path($nodes as node()*) as xs:string*

Input: any nodes

Output: the path of each node

Does not rely upon global variables, keys, functions, or templates.

`tan:pluck()`

tan:pluck($fragment as item()*, $pluck-beyond-level as xs:integer, $keep-short-branch-leaves as xs:boolean) as item()*

Input: any document fragment or element; a number indicating a level in the 
hierarchy of the fragment; a boolean indicating whether leaf elements that fall short of the 
previous parameter should be included

Output: the fragment of the tree that is beyond the point indicated, and perhaps 
(depending upon the third parameter) with other leafs that are not quite at that level

This function was written primarily to serve 
tan:convert-ref-to-div-fragment(), to get a slice of divs that correspond to a range, without the ancestry of those divs

Option 1 (TAN-fn-nodes-extended)

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:pluck.

`tan:remove-duplicate-siblings()`

tan:remove-duplicate-siblings($items-to-process as item()*) as item()*

one-parameter version of larger one, below

Used by function tan:remove-duplicate-siblings().

Relies upon tan:remove-duplicate-siblings.

Option 2 (TAN-fn-nodes-extended)

tan:remove-duplicate-siblings($items-to-process as document-node()*, $element-names-to-check as xs:string*) as item()*

Input: any items

Output: the same documents after removing duplicate elements whose names match the 
second parameter.

This function is applied during document resolution, to prune duplicate elements 
that might have been included

Related: nodes, tree manipulation

Used by function tan:remove-duplicate-siblings().

Relies upon ŧ tan:remove-duplicate-siblings.

`tan:replace-expanded-class-1-body()`

tan:replace-expanded-class-1-body($expanded-class-1-file as document-node()?, $new-body-text as xs:string?) as document-node()?

Input: An expanded class-1 file; a string

Output: the class-1 file, but with the body text replaced with the string, allocated 
according to tan:diff()

This function was written to replace a text with a very similar version of itself, 
perhaps altered via normalization, or selective changes.

Related: nodes, diff

Used by function tan:replace-expanded-class-1-body().

Relies upon tan:diff, tan:replace-expanded-class-1-body(), ŧ tan:replace-expanded-class-1.

`tan:restore-chopped-tree()`

tan:restore-chopped-tree($tree-slices as item()*) as item()*

Input: a sequence of items

Output: sequence that attempts to restore the items in a single tree

This function reverses the effects of tan:chop-tree(), but does so on the basis of 
the chopped fragments, not a map. By default, adjacent items of the same node type are 
fused into a single node of the same type, except for elements, which must have the same 
name, namespace, and attributes for them to be fused.

Related: nodes, tree manipulation

Used by function tan:restore-chopped-tree().

Relies upon tan:element-fingerprint, tan:item-type, tan:restore-chopped-tree, tan:shallow-copy.

`tan:sequence-to-tree()`

tan:sequence-to-tree($sequence-to-reconstruct as item()*) as item()*

One-parameter version of the more complete one below

Used by template ŧ tan:normalize-tree-space.

Used by function tan:sequence-to-tree(), tan:chop-tree().

Relies upon tan:sequence-to-tree.

Option 2 (TAN-fn-nodes-standard)

tan:sequence-to-tree($sequence-to-reconstruct as item()*, $fix-orphan-text as xs:boolean) as item()*

Input: a result of tan:tree-to-sequence(); a boolean

Output: the original tree; if the boolean is true, then any first children that 
precede the next level will be wrapped in an element like the first child element.

If a given opening tag has a corresponding <_close-at> then what is between will 
become the children of the element, and what comes after its following siblings.

This is the inverse of the function tan:tree-to-sequence(). That is, 
tan:sequence-to-tree$i) => tan:tree-to-sequence() should result in a copy of $i..

This function is especially helpful for a raw text transcription that needs to be 
converted to a class-1 body via the inline numerical references. The technique is to replace 
the numerical references with empty <div>s, each one with @n and @type correctly 
assessed based on the match, and a @_level to specify where in the hierarchy it should sit.

You may wish to run the results of this output through 
tan:consolidate-identical-adjacent-divs()

Related: nodes, tree manipulation

Used by template ŧ tan:normalize-tree-space.

Used by function tan:sequence-to-tree(), tan:chop-tree().

Relies upon ŧ tan:sequence-to-tree.

`tan:shallow-copy()`

tan:shallow-copy($items as item()*) as item()*

one-parameter version of the fuller one, below

Used by template ŧ tan:get-and-resolve-dependency, ŧ tan:mark-dependencies-pass-1, ŧ tan:dependency-adjustments-pass-2, ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1, ŧ tan:dependency-adjustments-pass-1, ŧ tan:resolve-critical-dependencies-loop, ŧ tan:check-referred-doc, ŧ tan:mark-dependencies-for-validation, ŧ tan:core-expansion-terse, ŧ tan:class-1-expansion-verbose-pass-2, ŧ tan:first-stamp-shallow-skip, ŧ tan:mark-reassigns, ŧ tan:trim-long-tree, ŧ tan:resolve-href tan:expand-standard-tan-voc, ŧ diff-or-collate-to-html-output-pass-1.

Used by function tan:shallow-copy(), tan:restore-chopped-tree(), tan:attribute-vocabulary(), tan:get-1st-doc(), tan:error(), tan:diff-or-collate-to-html().

Relies upon tan:shallow-copy.

Option 2 (TAN-fn-nodes-standard)

tan:shallow-copy($items as item()*, $depth as xs:integer) as item()*

Input: any document fragment; boolean indicating whether attributes should be 
kept

Output: a shallow copy of the fragment

Attributes will be preserved in a shallow-copied element.

Maps and arrays will be discarded.

This function was written to truncate large trees for output to messages and 
diagnostic result trees.

Related: nodes, tree manipulation

Used by function tan:shallow-copy(), tan:restore-chopped-tree(), tan:attribute-vocabulary(), tan:get-1st-doc(), tan:error(), tan:diff-or-collate-to-html().

Relies upon ŧ tan:fn-shallow-copy.

`tan:sort-change-log()`

Option 1 (TAN-fn-nodes-extended)

tan:sort-change-log($TAN-fragment as item()*) as item()*

one-parameter version of the fuller one, below

Used by function tan:sort-change-log().

Relies upon tan:sort-change-log.

Option 2 (TAN-fn-nodes-extended)

tan:sort-change-log($TAN-fragment as item()*, $sort-by-time-then-agent as xs:boolean?, $sort-ascending as xs:boolean?) as item()*

Input: a TAN fragment; two booleans

Output: the TAN fragment but with the change log sorted, either by time or agent (1st 
boolean) and either ascending or descending (2nd boolean)

Related: nodes, versioning

Used by function tan:sort-change-log().

Relies upon ŧ tan:sort-change-log.

`tan:stamp-q-id()`

tan:stamp-q-id($items-to-stamp as item()*) as item()*

1-param version of the full one below

Used by template ŧ tan:core-expansion-terse-attributes-to-elements.

Used by function tan:stamp-q-id().

Relies upon tan:stamp-q-id.

Option 2 (TAN-fn-nodes-standard)

tan:stamp-q-id($items-to-stamp as item()*, $stamp-shallowly as xs:boolean) as item()*

Input: any XML fragments

Output: the fragments with @q added to each element via generate-id()

Related: nodes, identifiers

Used by template ŧ tan:core-expansion-terse-attributes-to-elements.

Used by function tan:stamp-q-id().

Relies upon ŧ tan:stamp-q-id.

`tan:strip-outer-indentation()`

tan:strip-outer-indentation($tree-fragment as item()*) as item()*

Input: any XML fragment

Output: the same, but without outer indentation

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:strip-outer-indentation.

`tan:tree-to-sequence()`

tan:tree-to-sequence($xml-fragment as item()*) as item()*

Input: any XML fragment

Output: a flattened sequence of XML nodes representing the original fragment. Each 
element is given a new @_level specifying the level of hierarchy the element had in the 
original. Closing tags are specified by <_close-at id=""/> with a corresponding @_close-at 
in the opening tag. Empty elements are retained as-is.

Used by template ŧ tan:normalize-tree-space.

Used by function tan:chop-tree().

Relies upon ŧ tan:tree-to-sequence.

`tan:trim-long-text()`

tan:trim-long-text($xml-fragment as item()*, $too-long as xs:integer) as item()*

Input: an XML fragment; an integer

Output: the fragment with text nodes longer than the integer value abbreviated with 
an ellipsis

Used by function tan:diff-courtyard(), tan:collate(), tan:diff-loop().

Relies upon ŧ tan:trim-long-text.

`tan:trim-long-tree()`

tan:trim-long-tree($tree-to-trim as item()*, $shallow-copy-point as xs:integer, $deep-skip-point as xs:integer) as item()*

Input: an XML tree, two integers

Output: the tree, anything beyond the shallow-copy point will be shallow-copied 
and anything beyond the deep skip point will be deep-skipped. Comments will always 
indicate how many nodes were shallow-copied or deep-skipped.

This function was written to truncate large diagnostic output

Option 1 (TAN-fn-nodes-TAN-output)

Used by template ŧ diff-or-collate-to-html-output-pass-1.

Used by function tan:apply-deltas(), tan:diff-or-collate-to-html().

Relies upon ŧ tan:trim-long-tree.

`tan:update-TAN-change-log()`

tan:update-TAN-change-log($TAN-file as document-node()?) as document-node()?

one-parameter version of fuller one, below

Used by function tan:update-TAN-change-log().

Relies upon $tan:doc-uri, tan:update-TAN-change-log.

Option 2 (TAN-fn-nodes-TAN-output)

tan:update-TAN-change-log($TAN-file as document-node()?, $agent-IRIs as xs:string+, $agent-names as xs:string+, $agent-base-uri-resolved as xs:string?, $agent-type as xs:string, $agent-responsibility as xs:string, $change-message as xs:string, $source-base-uri as xs:string) as document-node()?

Input: a TAN file; assorted parameters pertaining to the agent that created or 
changed the file

Output: The TAN file with appropriate credit/blame given

It is presumed that the TAN file is in its raw state, and that indentation should be 
respected.

If an agent type is not recognized, the default will be algorithm.

Related: nodes, versioning

Used by function tan:update-TAN-change-log().

Relies upon $tan:TAN-vocabularies, tan:has-vocab, tan:normalize-name, tan:resolve-doc, tan:update-TAN-change-log(), tan:uri-relative-to, tan:vocabulary, ŧ tan:update-TAN-change-log.

`tan:wrap-text-nodes()`

tan:wrap-text-nodes($input-to-adjust as item()*) as item()*

Input: any items where the text should be wrapped

Output: the items with text nodes wrapped in <_text> with a @q containing the value of 
generate-id() for the text node in question.

This function is similar to tan:make-non-mixed() but applies wrapping 
universally

Related: nodes, tree manipulation

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:wrap-text-nodes.

`tan:xml-to-string()`

tan:xml-to-string($fragment as item()*) as xs:string?

one-parameter version of the fuller one, below

Used by template ŧ tan:mark-dependencies-pass-1, ŧ tan:class-1-expansion-verbose-pass-3, ŧ tan:mark-dependencies-for-validation, ŧ tan:core-expansion-normal.

Used by function tan:xml-to-string(), tan:expand-doc(), tan:get-1st-doc().

Relies upon tan:xml-to-string.

Option 2 (TAN-fn-nodes-standard)

tan:xml-to-string($fragment as item()*, $ignore-whitespace-text-nodes as xs:boolean) as xs:string?

Input: any fragment of XML; boolean indicating whether whitespace nodes should be 
ignored

Output: a string representation of the fragment

This function is a proxy of serialize(), used to represent XML fragments in plain 
text, useful in validation reports or in generating guidelines

Related: nodes, serialization, strings

Used by template ŧ tan:mark-dependencies-pass-1, ŧ tan:class-1-expansion-verbose-pass-3, ŧ tan:mark-dependencies-for-validation, ŧ tan:core-expansion-normal.

Used by function tan:xml-to-string(), tan:expand-doc(), tan:get-1st-doc().

Relies upon ŧ tan:fragment-to-text.

Numerals

Variables

`$tan:alphabet-numeral-key`

This variable has a complex definition. See stylesheet for definiton.

Used by function tan:letter-to-number().

Does not rely upon global variables, keys, functions, or templates.

`$tan:arabic-indic-numeral-regex`

`$tan:n-type`

Definition: ('i', '1', '1a', 'a', 'a1', 'α', '$', 'i-or-a')

Used by template ŧ tan:string-to-numerals.

Does not rely upon global variables, keys, functions, or templates.

`$tan:n-type-label`

Definition: ('Roman numerals', 'Arabic numerals', 'Arabic numerals + alphabet numeral', 'alphabet numeral', 'alphabet numeral + Arabic numeral', 'non-Latin-alphabet numeral', 'string', 'Roman or alphabet numeral')

No variables, keys, functions, or named templates depend upon this xsl:variable.

Does not rely upon global variables, keys, functions, or templates.

`$tan:n-type-regex`

This variable has a complex definition. See stylesheet for definiton.

Used by template ŧ tan:string-to-numerals.

Relies upon $tan:latin-letter-numeral-regex, $tan:nonlatin-letter-numeral-regex, $tan:roman-numeral-regex.

`$tan:nonlatin-letter-numeral-regex`

Definition: string-join(($tan:arabic-indic-numeral-regex, $tan:greek-letter-numeral-regex, $tan:syriac-letter-numeral-pattern), '|')

Used by variable $tan:n-type-regex.

Relies upon $tan:arabic-indic-numeral-regex, $tan:greek-letter-numeral-regex, $tan:syriac-letter-numeral-pattern.

`$tan:roman-numeral-regex`

Definition: m{0,4}(cm|cd|d?c{0,3})(xc|xl|l?x{0,3})(im|ic|il|ix|iv|v?i{0,3})

Used by variable $tan:n-type-regex.

Used by function tan:rom-to-int().

Does not rely upon global variables, keys, functions, or templates.

`$tan:syriac-hundreds-regex`

Definition: ܬ?[ܩܪܫܬ]|[ܢܣܥܦܨ]

Used by variable $tan:syriac-letter-numeral-pattern.

Does not rely upon global variables, keys, functions, or templates.

`$tan:syriac-letter-numeral-pattern`

Definition: $tan:syriac-unit-regex || '?\p{Mc}?(' || $tan:syriac-hundreds-regex || '\p{Mc})?\p{Mc}?' || $tan:syriac-tens-regex || '?\p{Mc}?' || $tan:syriac-unit-regex || '\p{Mc}?|' || $tan:syriac-unit-regex || '?\p{Mc}?(' || $tan:syriac-hundreds-regex || '\p{Mc})?\p{Mc}?' || $tan:syriac-tens-regex || '\p{Mc}?' || $tan:syriac-unit-regex || '?\p{Mc}?|' || $tan:syriac-unit-regex || '?\p{Mc}?(' || $tan:syriac-hundreds-regex || '\p{Mc})\p{Mc}?' || $tan:syriac-tens-regex || '?\p{Mc}?' || $tan:syriac-unit-regex || '?\p{Mc}?'

Used by variable $tan:nonlatin-letter-numeral-regex.

Relies upon $tan:syriac-hundreds-regex, $tan:syriac-tens-regex, $tan:syriac-unit-regex.

`$tan:syriac-tens-regex`

Definition: [ܝܟܠܡܢܣܥܦܨ]

Used by variable $tan:syriac-letter-numeral-pattern.

Does not rely upon global variables, keys, functions, or templates.

`$tan:syriac-unit-regex`

Definition: [ܐܒܓܕܗܘܙܚܛ]

Used by variable $tan:syriac-letter-numeral-pattern.

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:aaa-to-int()`

tan:aaa-to-int($arg as xs:string*) as xs:integer*

Input: any numerals in the supported letter numeral system

Output: the integer equivalent

Sequence goes a, b, c, ... z, aa, bb, ..., aaa, bbb, .... E.g., 'ccc' - > 55

Used by template ŧ tan:string-to-numerals.

Relies upon $tan:latin-letter-numeral-regex.

`tan:ara-to-int()`

tan:ara-to-int($arabic-indic-numerals as xs:string*) as xs:integer*

Input: Arabic-indic numerals

Output: Integer values, if the input conforms to the correct pattern

Related: numerals, Arabic, numerics

Used by function tan:letter-to-number().

Relies upon $tan:arabic-indic-numeral-regex.

`tan:cardinal()`

tan:cardinal($integer-to-convert as xs:integer?) as xs:string?

Input: an integer

Output: the English term for the number

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:chop-string.

`tan:grc-to-int()`

tan:grc-to-int($greek-numerals as xs:string*) as xs:integer*

Input: Greek letters that represent numerals

Output: the numerical value of the letters

NB, this does not take into account the use of letters representing numbers 1000 and 
greater

Related: numerals, numerics, Greek

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:letter-to-number.

`tan:int-to-aaa()`

tan:int-to-aaa($integers as xs:integer*) as xs:string*

Input: any integers

Output: the alphabetic representation of those numerals

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:int-to-grc()`

tan:int-to-grc($integers as xs:integer*) as xs:string*

Input: any integers

Output: the integers expressed as lowercase Greek alphabetic numerals, with 
numeral marker(s)

Related: numerals, numerics, Greek

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:chop-string.

`tan:integers-to-expression()`

tan:integers-to-expression($input-integers as xs:integer*) as xs:string?

Input: any integers

Output: a string that compactly expresses those integers, sorted

Example: (1, 3, 6, 1, 2) - > "1-3, 6"

Related: numerals, numerics, sequences

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:integers-to-expression.

`tan:letter-to-number()`

tan:letter-to-number($numerical-letters as xs:anyAtomicType*) as xs:integer*

Input: any sequence of strings that represent alphabetic numerals

Output: those numerals as integers

Works only for letter patterns that have been defined; anything else produces null 
results

Used by template ŧ tan:string-to-numerals.

Used by function tan:grc-to-int(), tan:syr-to-int().

Relies upon $tan:alphabet-numeral-key, $tan:arabic-indic-numeral-regex, tan:ara-to-int.

`tan:ordinal()`

tan:ordinal($in as xs:integer*) as xs:string*

Input: one or more numerals

Output: one or more strings with the English form of the ordinal form of the input 
number

Example: (1, 4, 17) -> ('first', 'fourth', '17th')

Used by template ŧ tan:class-2-expansion-terse tan:class-2-expansion-terse-for-validation.

Does not rely upon global variables, keys, functions, or templates.

`tan:rom-to-int()`

tan:rom-to-int($arg as xs:string*) as xs:integer*

Input: any roman numeral less than 5000

Output: the numeral converted to an integer

Related: numerals, numerics, Latin

Used by template ŧ tan:string-to-numerals.

Relies upon $tan:roman-numeral-regex.

`tan:string-to-numerals()`

Option 1 (TAN-fn-numerals-standard)

tan:string-to-numerals($string-to-analyze as xs:string?) as xs:string*

one-parameter version of the function below

Used by template ŧ tan:check-and-expand-ranges, ŧ tan:resolve-numerals, ŧ tan:class-1-expansion-verbose-pass-2.

Used by function tan:string-to-numerals(), tan:analyze-sequence(), tan:string-to-int().

Relies upon tan:string-to-numerals.

Option 2 (TAN-fn-numerals-standard)

tan:string-to-numerals($string-to-analyze as xs:string?, $ambig-is-roman as xs:boolean?, $return-only-numerals as xs:boolean?, $n-alias-items as element()*, $numeral-exceptions as xs:string*) as xs:string*

Input: a string thought to contain numerals of some type (e.g., Roman); a boolean 
indicating whether ambiguous letters should be treated as Roman numerals or letter numerals; a 
boolean indicating whether only numeral matches should be returned

Output: the string with parts that look like numerals converted to Arabic numerals

Does not take into account requests for help

Related: numerals, strings

Used by template ŧ tan:check-and-expand-ranges, ŧ tan:resolve-numerals, ŧ tan:class-1-expansion-verbose-pass-2.

Used by function tan:string-to-numerals(), tan:analyze-sequence(), tan:string-to-int().

Does not rely upon global variables, keys, functions, or templates.

`tan:syr-to-int()`

tan:syr-to-int($syriac-numerals as xs:string*) as xs:integer*

Input: Syriac letters that represent numerals

Output: the numerical value of the letters

NB, this does not take into account the use of letters representing numbers 1000 and 
greater

Related: numerals, numerics, Syriac

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:letter-to-number.

Numerics

Variables

`$tan:binary-error-key`

This variable has a complex definition. See stylesheet for definiton.

Used by variable $tan:error-key.

Used by function tan:pad-bits(), tan:bitwise-xor(), tan:bits-to-eight-bit-chars(), tan:bitwise-or(), tan:bitwise-and(), tan:bits-to-octets(), tan:eight-bit-chars-to-hexBinary(), tan:octets-to-hexBinary().

Does not rely upon global variables, keys, functions, or templates.

`$tan:numeric-conversion-error-key`

This variable has a complex definition. See stylesheet for definiton.

Used by variable $tan:error-key.

Used by function tan:base64-to-base64Binary(), tan:dec-to-n(), tan:hex-to-base64Binary(), tan:hex-to-hexBinary(), tan:n-to-dec(), tan:bin-to-bits().

Does not rely upon global variables, keys, functions, or templates.

`$tan:octet-error-key`

This variable has a complex definition. See stylesheet for definiton.

Used by variable $tan:error-key.

Used by function tan:utf-8-octets-to-string().

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:base26-to-dec()`

tan:base26-to-dec($in as xs:string?) as xs:integer?

Input: a string representation of a base-26 number

Output: an integer representing the base-10 value of the input

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:n-to-dec.

`tan:base64-to-base64Binary()`

tan:base64-to-base64Binary($in as xs:string?) as xs:base64Binary?

Input: a base-64 string

Output: the string cast to xs:base64Binary, if possible

base64Binary is not the same as a base 64 number, because it represents a 
redistribution of bits. For example, decimal/base-64 F = hex 05 = binary 00000101 whose bits must 
redistributed into the 4-digit base64binary as follows: 000001 01[0000] [padding] [padding]

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:TAN-namespace, $tan:numeric-conversion-error-key, tan:base64-to-hex, tan:hex-to-hexBinary.

`tan:base64-to-bin()`

tan:base64-to-bin($in as xs:string?) as xs:string?

Input: a string representation of a base-64 number

Output: a string representing the datum in binary code

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:base64-to-dec, tan:dec-to-bin, tan:fill.

`tan:base64-to-dec()`

tan:base64-to-dec($in as xs:string?) as xs:integer?

Input: a string representation of a base-64 number

Output: an integer representing the base-10 value of the input

Used by function tan:base64-to-bin(), tan:base64-to-hex().

Relies upon tan:n-to-dec.

`tan:base64-to-hex()`

tan:base64-to-hex($in as xs:string?) as xs:string?

Input: a string representation of a base-64 number

Output: a string representing the datum in hexadecimal

Used by function tan:base64-to-base64Binary().

Relies upon tan:base64-to-dec, tan:dec-to-hex, tan:fill.

`tan:base64Binary-to-base64()`

tan:base64Binary-to-base64($in as xs:base64Binary?) as xs:string?

Input: a base64Binary

Output: the item as a base-64 number

The output should have no more initial zeroes (A) than the input

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:hex-to-base64.

`tan:base64Binary-to-bin()`

tan:base64Binary-to-bin($in as xs:base64Binary?) as xs:string?

Input: a base64Binary

Output: a string with the value in base 2

Used by function tan:base64Binary-to-bits().

Relies upon tan:hex-to-bin.

`tan:base64binary-to-bin()`

tan:base64binary-to-bin($in as xs:base64Binary?) as xs:string?

Input: a base64binary

Output: the number converted to a base 2 binary string

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:hex-to-bin.

`tan:base64Binary-to-bits()`

tan:base64Binary-to-bits($in as xs:base64Binary?) as xs:boolean*

Input: a base64Binary

Output: the value in bits (booleans)

Because base64Binary works in bytes, the output will be a multiple of 8

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:base64Binary-to-bin, tan:bin-to-bits.

`tan:base64Binary-to-eight-bit-chars()`

tan:base64Binary-to-eight-bit-chars($in as xs:base64Binary?) as xs:string?

Input: a base64 binary

Output: the same, converted to an 8-bit character string

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:hexBinary-to-eight-bit-chars.

`tan:base64Binary-to-hex()`

tan:base64Binary-to-hex($in as xs:base64Binary?) as xs:string?

Input: a base64Binary

Output: a string with the value in hexadecimal

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:base64Binary-to-octets()`

tan:base64Binary-to-octets($in as xs:base64Binary?) as xs:integer*

Input: a base64Binary

Output: a sequence of integers between 0 and 255 representing the base64Binary 
value

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:hexBinary-to-octets.

`tan:bin-to-base64()`

tan:bin-to-base64($in as xs:string?) as xs:string?

Input: a string representing a base 2 binary

Output: a string representing the number in base 64

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:bin-to-dec, tan:dec-to-base64, tan:fill.

`tan:bin-to-base64Binary()`

tan:bin-to-base64Binary($in as xs:string?) as xs:base64Binary?

Input: a string representing base-2 binary

Output: the number as xs:base64Binary

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:bin-to-hex, tan:hex-to-hexBinary.

`tan:bin-to-bits()`

tan:bin-to-bits($base-2-binary as xs:string?) as xs:boolean*

Input: any string representing base-2 binary

Output: a sequence of booleans representing the bits of the binary

Used by function tan:md5(), tan:hexBinary-to-bits(), tan:base64Binary-to-bits(), tan:hex-to-bits().

Relies upon $tan:TAN-namespace, $tan:numeric-conversion-error-key.

`tan:bin-to-dec()`

tan:bin-to-dec($in as xs:string?) as xs:integer?

Input: a binary

Output: the number in decimal form, as an integer

Input is assumed to be big-endian

Used by function tan:le-bits-to-int-and-neg(), tan:md5(), tan:bin-to-hex(), tan:bin-to-base64(), tan:bits-to-octets(), tan:utf-8-octets-to-string().

Relies upon tan:n-to-dec.

`tan:bin-to-hex()`

tan:bin-to-hex($in as xs:string?) as xs:string?

Input: a string representing a base 2 binary

Output: a string representing the number in hexadecimal

Used by function tan:bin-to-base64Binary(), tan:bin-to-hexBinary(), tan:bits-to-hex().

Relies upon tan:bin-to-dec, tan:dec-to-hex, tan:fill.

`tan:bin-to-hexBinary()`

tan:bin-to-hexBinary($in as xs:string?) as xs:hexBinary?

Input: a string representing base-2 binary

Output: the number as xs:hexBinary

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:bin-to-hex, tan:hex-to-hexBinary.

`tan:bits-to-base64Binary()`

tan:bits-to-base64Binary($input-bits as xs:boolean*, $big-endian as xs:boolean) as xs:base64Binary?

Input: a sequence of bits (booleans); a boolean specifying whether the bits are 
big-endian or not

Output: the bits as a base64Binary

Because a base64Binary is interchangeable with a hexBinary, which is eight bits, 
the input bits are cast to bytes. For defective byte input, little/big endian options 
will likely result in different output. For whole bytes, the results should be the same, 
since the base64Binary will preserve the endianness of the input. Trailing = are padding 
characters that are neither 0 nor 1

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:bits-to-hexBinary.

`tan:bits-to-bin()`

tan:bits-to-bin($bits as xs:boolean*) as xs:string?

Input: a sequence of booleans

Output: a base-2 binary representation of the sequence

Example: false, true, true > '011'

Used by function tan:le-bits-to-int-and-neg(), tan:md5(), tan:bitwise-rotate(), tan:bits-to-octets(), tan:bits-to-hex().

Does not rely upon global variables, keys, functions, or templates.

`tan:bits-to-byte()`

tan:bits-to-byte($input-bits as xs:boolean*, $big-endian as xs:boolean) as xs:boolean*

Input: a sequence of bits (booleans); a boolean

Output: the same sequence, but extended to a multiple of 8 bits (a byte). If the 2nd 
param is true, it is big endian and the padding takes place at the beginning, otherwise, at 
the end.

Used by function tan:md5(), tan:bits-to-hexBinary().

Relies upon tan:pad-bits.

`tan:bits-to-eight-bit-chars()`

tan:bits-to-eight-bit-chars($in as xs:boolean*) as xs:string?

Input: a sequence of bits (booleans)

Output: a string of 8-bit characters (characters corresponding to codepoints 
1-255, and character 0 converted to U+2400 SYMBOL FOR NULL)

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:TAN-namespace, $tan:binary-error-key, tan:bits-to-hex, tan:hexBinary-to-eight-bit-chars.

`tan:bits-to-hex()`

tan:bits-to-hex($in as xs:boolean*) as xs:string?

Input: a sequence of booleans

Output: a base-2 binary representation of the sequence

Used by function tan:bits-to-hexBinary(), tan:bits-to-eight-bit-chars().

Relies upon tan:bin-to-hex(), tan:bits-to-bin.

`tan:bits-to-hexBinary()`

tan:bits-to-hexBinary($input-bits as xs:boolean*, $big-endian as xs:boolean) as xs:hexBinary?

Input: a sequence of bits (booleans); a boolean specifying whether the bits are 
big-endian or not

Output: the bits as a hexBinary

Because a hexBinary is eight bits, the input bits are cast to bytes. For defective 
byte input, little/big endian options will likely result in different output. For whole 
bytes, the results should be the same, since the hexBinary will preserve the endianness of 
the input.

Used by function tan:bits-to-base64Binary().

Relies upon tan:bits-to-byte, tan:bits-to-hex, tan:hex-to-hexBinary.

`tan:bits-to-octets()`

tan:bits-to-octets($in as xs:boolean*) as xs:integer*

Input: a sequence of bits (booleans)

Output: a sequence of integers between 0 and 255 representing the Binary value

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:TAN-namespace, $tan:binary-error-key, tan:bin-to-dec, tan:bits-to-bin.

`tan:bits-to-word()`

tan:bits-to-word($input-bits as xs:boolean*, $big-endian as xs:boolean) as xs:boolean*

Input: a sequence of bits (booleans); a boolean

Output: the same sequence, but extended to a multiple of 32 bits (a "word"). If the 2nd 
param is true, it is big endian and the padding takes place at the beginning, otherwise, at 
the end.

Used by function tan:md5().

Relies upon tan:pad-bits.

`tan:bitwise-and()`

tan:bitwise-and($bit-sequence-a as xs:boolean*, $bit-sequence-b as xs:boolean*) as xs:boolean*

Input: two sequences of booleans

Output: a single sequence as long as the longest input sequence, with pairwise AND 
computed.

Used by function tan:md5().

Relies upon $tan:TAN-namespace, $tan:binary-error-key.

`tan:bitwise-not()`

tan:bitwise-not($boolean as xs:boolean*) as xs:boolean*

Input: a boolean sequence

Output: the bitwise complement of the sequence

e.g., false, true > true, false

Used by function tan:md5().

Does not rely upon global variables, keys, functions, or templates.

`tan:bitwise-or()`

tan:bitwise-or($bit-sequence-a as xs:boolean*, $bit-sequence-b as xs:boolean*) as xs:boolean*

Input: two sequences of booleans

Output: a single sequence as long as the longest input sequence, with pairwise OR 
computed.

Used by function tan:md5().

Relies upon $tan:TAN-namespace, $tan:binary-error-key.

`tan:bitwise-plus()`

tan:bitwise-plus($bit-sequence-a as xs:boolean*, $bit-sequence-b as xs:boolean*, $big-endian as xs:boolean) as xs:boolean*

Input: two sequences of booleans, and a boolean

Output: a sequence of booleans representing the sum of the input, as if base-2 
binary.

Unlike most bitwise operations, where the length of input and output are expected to 
be the same, that is definitely not the case here, which means that a declaration must be 
made whether the operation is big-endian (most significant byte first) or 
little-endian (most significant byte last)

If one input is longer than the other, each unpaired boolean at the most significant 
part of the longest series will be assessed against an assumed counterpart of false.

Used by function tan:md5().

Does not rely upon global variables, keys, functions, or templates.

`tan:bitwise-rotate()`

tan:bitwise-rotate($bit-sequence as xs:boolean*, $rotate-left as xs:integer) as xs:boolean*

Input: a boolean sequence; an integer

Output: the sequence, circularly shifted left the number of places specified by the 
integer; if the integer is negative, it will be shifted right.

It is up to the user to consider whether the bits are big- or little-endian as to the 
meaning of "left".

Used by function tan:md5(), tan:bitwise-rotate().

Relies upon tan:bits-to-bin, tan:bitwise-rotate().

`tan:bitwise-xor()`

tan:bitwise-xor($bit-sequence-a as xs:boolean*, $bit-sequence-b as xs:boolean*) as xs:boolean*

Input: two sequences of booleans

Output: a single sequence as long as the longest input sequence, with pairwise XOR 
computed.

Used by function tan:md5().

Relies upon $tan:TAN-namespace, $tan:binary-error-key.

`tan:counts-to-lasts()`

tan:counts-to-lasts($seq as xs:integer*) as xs:integer*

Input: sequence of numbers representing counts of items.

Output: sequence of numbers representing the last position of each item within the 
total count. E.g., (4, 12, 0, 7) - > (4, 16, 16, 23)

Related: numerics, sequences

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:dec-to-base26()`

tan:dec-to-base26($in as xs:integer?) as xs:string?

Input: xs:integer

Output: the base 26 equivalent as a string, e.g., 31 - > 'BF'

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:dec-to-n.

`tan:dec-to-base64()`

tan:dec-to-base64($in as xs:integer?) as xs:string?

Input: xs:integer

Output: the base 64 equivalent as a string, e.g., 31 - > 'f'

Used by function tan:bin-to-base64(), tan:hex-to-base64().

Relies upon tan:dec-to-n.

`tan:dec-to-bin()`

tan:dec-to-bin($in as xs:integer?) as xs:string?

Input: an integer

Output: the number in binary form, as a string

Input is assumed to be big-endian

Used by function tan:md5(), tan:hex-to-bin(), tan:base64-to-bin(), tan:utf-8-octets-to-string().

Relies upon tan:dec-to-n.

`tan:dec-to-hex()`

tan:dec-to-hex($in as xs:integer?) as xs:string?

Input: xs:integer

Output: the hexadecimal equivalent as a string, e.g., 31 - > '1F'

Used by template ŧ tan:core-expansion-normal.

Used by function tan:md5(), tan:checksum-fletcher(), tan:bin-to-hex(), tan:base64-to-hex(), tan:eight-bit-chars-to-hexBinary(), tan:octets-to-hexBinary().

Relies upon tan:dec-to-n.

`tan:dec-to-n()`

tan:dec-to-n($in as xs:integer?, $base as xs:integer) as xs:string?

Input: two integers

Output: a string that represents the first numeral in base N, where N is the second 
numeral (must be 2-16, 26, or 64)

No padding is performed on the output (e.g., = in base-64, or initial zeroes in 
hexadecimal)

Used by function tan:dec-to-hex(), tan:dec-to-base26(), tan:dec-to-base64(), tan:dec-to-bin(), tan:dec-to-n().

Relies upon $tan:TAN-namespace, $tan:base26-key, $tan:base64-key, $tan:hex-key, $tan:numeric-conversion-error-key, tan:dec-to-n.

`tan:eight-bit-chars-to-base64Binary()`

tan:eight-bit-chars-to-base64Binary($in as xs:string?) as xs:base64Binary?

Input: a string that is encoded in eight-bit chars; a boolean

Output: the string as a sequence of hexBinary values, one per character

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:eight-bit-chars-to-hexBinary.

`tan:eight-bit-chars-to-bits()`

tan:eight-bit-chars-to-bits($in as xs:string*) as xs:boolean*

Input: a sequence of eight-bit-chars (integers in the range 0-255)

Output: the eight-bit-chars as sequence of bits (booleans)

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:eight-bit-chars-to-hexBinary, tan:hexBinary-to-bits.

`tan:eight-bit-chars-to-hexBinary()`

tan:eight-bit-chars-to-hexBinary($in as xs:string?) as xs:hexBinary?

Input: a string that is encoded in eight-bit chars; a boolean

Output: the string as a sequence of hexBinary values, one per character

Used by function tan:eight-bit-chars-to-bits(), tan:eight-bit-chars-to-base64Binary().

Relies upon $tan:TAN-namespace, $tan:binary-error-key, tan:dec-to-hex.

`tan:hex-to-base64()`

tan:hex-to-base64($in as xs:string?) as xs:string?

Input: a string representing a hexadecimal number

Output: a string representing the number in base 64

Used by function tan:base64Binary-to-base64().

Relies upon tan:dec-to-base64, tan:fill, tan:hex-to-dec.

`tan:hex-to-base64Binary()`

tan:hex-to-base64Binary($in as xs:string?) as xs:base64Binary?

Input: a hexadecimal string

Output: the string cast to xs:base64Binary, if possible

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:TAN-namespace, $tan:numeric-conversion-error-key, tan:fill.

`tan:hex-to-bin()`

tan:hex-to-bin($in as xs:string?) as xs:string?

Input: a string representation of a hexadecimal number

Output: a string representing the datum in binary code

Used by function tan:base64binary-to-bin(), tan:hexBinary-to-bin(), tan:base64Binary-to-bin(), tan:hex-to-bits().

Relies upon tan:dec-to-bin, tan:fill, tan:hex-to-dec.

`tan:hex-to-bits()`

tan:hex-to-bits($in as xs:string?) as xs:boolean*

Input: any string representing base-2 binary

Output: a sequence of booleans representing the bits of the binary

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:bin-to-bits(), tan:hex-to-bin.

`tan:hex-to-dec()`

tan:hex-to-dec($in as xs:string?) as xs:integer?

Input: a string representing a hexadecimal number

Output: the integer value, e.g., '1F' - > 31

Used by function tan:hex-to-bin(), tan:hex-to-base64(), tan:string-to-utf-8-octets(), tan:hexBinary-to-octets(), tan:hexBinary-to-eight-bit-chars().

Relies upon tan:n-to-dec.

`tan:hex-to-hexBinary()`

tan:hex-to-hexBinary($in as xs:string?) as xs:hexBinary?

Input: a hexadecimal string

Output: the string cast to xs:hexBinary, if possible

Used by function tan:bits-to-hexBinary(), tan:base64-to-base64Binary(), tan:bin-to-base64Binary(), tan:bin-to-hexBinary().

Relies upon $tan:TAN-namespace, $tan:numeric-conversion-error-key, tan:fill.

`tan:hexBinary-to-bin()`

tan:hexBinary-to-bin($in as xs:hexBinary?) as xs:string?

Input: a hexBinary

Output: a string with the value in base 2

Used by function tan:hexBinary-to-bits().

Relies upon tan:hex-to-bin.

`tan:hexBinary-to-bits()`

tan:hexBinary-to-bits($in as xs:hexBinary?) as xs:boolean*

Input: a hexBinary

Output: the value in bits (booleans)

Because hexBinary works in bytes, the output will be a multiple of 8

Used by function tan:octets-to-bits(), tan:eight-bit-chars-to-bits().

Relies upon tan:bin-to-bits, tan:hexBinary-to-bin.

`tan:hexBinary-to-eight-bit-chars()`

tan:hexBinary-to-eight-bit-chars($hexBinary as xs:hexBinary?) as xs:string?

Input: a hexBinary

Output: the hexBinary converted to 8-bit characters (characters corresponding to 
codepoints 1-255, and character 0 converted to U+2400 SYMBOL FOR NULL)

Used by function tan:bits-to-eight-bit-chars(), tan:base64Binary-to-eight-bit-chars().

Relies upon tan:hex-to-dec.

`tan:hexBinary-to-hex()`

tan:hexBinary-to-hex($in as xs:hexBinary?) as xs:string?

Input: a base64Binary

Output: a string with the value in hexadecimal

Used by function tan:hexBinary-to-octets().

Does not rely upon global variables, keys, functions, or templates.

`tan:hexBinary-to-octets()`

tan:hexBinary-to-octets($in as xs:hexBinary?) as xs:integer*

Input: a hexBinary

Output: a sequence of integers between 0 and 255 representing the hexBinary value

Used by function tan:base64Binary-to-octets().

Relies upon tan:hex-to-dec, tan:hexBinary-to-hex.

`tan:integer-groups()`

tan:integer-groups($integers-to-group as xs:integer*) as array(xs:integer+)?

Input: any integers

Output: an array, with each member containing a sequence of integers that are 
collectively contiguous

Array members and their contents will be sorted; duplicates will be ignored

Related: numerics, grouping

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:last-32-bits()`

tan:last-32-bits($bit-sequence as xs:boolean*) as xs:boolean*

Input: a sequence of booleans

Output: the last 32

Used as a way of doing modulo 2 ^ 32, usually on big-endian bits; little-endian modulo 
2 ^ 32 is easy with subsequence(X, 1, 32)

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:lengths-to-positions()`

tan:lengths-to-positions($seq as xs:integer*) as xs:integer*

Input: sequence of numbers representing legnths of items.

Output: sequence of numbers representing the first position of each input item, if 
the sequence concatenated. E.g., (4, 12, 0, 7) - > (1, 5, 17, 17)

Related: numerics, sequences

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:log2()`

TAN-fn-numerics-standard

tan:log2($arg as xs:double?) as xs:double?

Input: any double

Output: the binary logarithm of the value

Used by function tan:common-start-or-end-string().

Does not rely upon global variables, keys, functions, or templates.

`tan:n-to-dec()`

tan:n-to-dec($input as xs:string?, $base as xs:integer) as xs:integer?

Input: string representation of some number; an integer

Output: an integer representing the first parameter in the base system of the 2nd 
parameter

Used by function tan:hex-to-dec(), tan:base26-to-dec(), tan:base64-to-dec(), tan:bin-to-dec(), tan:n-to-dec().

Relies upon $tan:TAN-namespace, $tan:base26-key, $tan:base64-key, $tan:hex-key, $tan:numeric-conversion-error-key, tan:n-to-dec().

`tan:number-sort()`

tan:number-sort($numbers as xs:anyAtomicType*) as xs:double*

Input: any sequence of items

Output: the same sequence, sorted with string numerals converted to numbers

TAN-fn-numerics-standard

Used by function tan:outliers().

Does not rely upon global variables, keys, functions, or templates.

`tan:numbers-to-portions()`

tan:numbers-to-portions($numbers as item()*) as xs:decimal*

Input: a sequence of numbers, representing a sequence of quantities of all the parts 
of a whole

Output: one double per number, from 0 to 1, reflecting where each finishes in the 
sequence proportionate to the sum of the whole. The last item always returns 1. Anything not 
castable to a double will be given the empty sequence.

Used by function tan:infuse-tree().

Does not rely upon global variables, keys, functions, or templates.

`tan:octets-to-base64Binary()`

tan:octets-to-base64Binary($in as xs:integer*) as xs:base64Binary?

Input: a sequence of octets (integers in the range 0-255)

Output: the octets as base64Binary

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:octets-to-hexBinary.

`tan:octets-to-bits()`

tan:octets-to-bits($in as xs:integer*) as xs:boolean*

Input: a sequence of octets (integers in the range 0-255)

Output: the octets as sequence of bits (booleans)

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:hexBinary-to-bits, tan:octets-to-hexBinary.

`tan:octets-to-hexBinary()`

tan:octets-to-hexBinary($in as xs:integer*) as xs:hexBinary?

Input: a sequence of octets (integers in the range 0-255)

Output: the octets as hexBinary

Used by function tan:octets-to-bits(), tan:octets-to-base64Binary().

Relies upon $tan:TAN-namespace, $tan:binary-error-key, tan:dec-to-hex.

`tan:pad-bits()`

tan:pad-bits($input-bits as xs:boolean*, $big-endian as xs:boolean, $item-size as xs:integer) as xs:boolean*

Input: bits as booleans; a boolean; an integer

Output: the input padded with enough 0 bits (false booleans) at the front or back 
(depends on 2nd parameter) to make the output as long as the third integer

Used by function tan:bits-to-byte(), tan:bits-to-word().

Relies upon $tan:TAN-namespace, $tan:binary-error-key.

`tan:product()`

tan:product($numbers as xs:anyAtomicType*) as xs:anyAtomicType?

Input: a sequence of numbers

Output: the product of those numbers

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:string-to-utf-8-octets()`

tan:string-to-utf-8-octets($str as xs:string) as xs:integer*

Input: a string

Output: integer values of the string, after conversion to UTF-8 bytes (0..255)

This function was written to ensure that checksums of Unicode values do not cause 
repeating values.

Anything below codepoint 128 will be simply the output of string-to-codepoints()

Related: numerics, codepoints

Used by function tan:unicode-to-eight-bit-chars(), tan:checksum-fletcher().

Relies upon tan:hex-to-dec.

`tan:unicode-to-eight-bit-chars()`

tan:unicode-to-eight-bit-chars($unicode-string as xs:string?) as xs:string?

Input: any Unicode string

Output: the string, with upper characters (greater than dec 126, ~) converted to 
8-bit-bytes

Related: numerics, codepoints

Used by function tan:md5().

Relies upon tan:string-to-utf-8-octets.

`tan:utf-8-octets-to-string()`

tan:utf-8-octets-to-string($in as xs:integer*) as xs:string?

Input: a sequence of octets (integers in the range 0-255)

Output: the octets converted into a Unicode string.

Related: numerics, codepoints

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:TAN-namespace, $tan:octet-error-key, tan:bin-to-dec, tan:dec-to-bin.

Resolution

Functions

`tan:resolve-doc()`

Option 1 (TAN-fn-resolve-files)

tan:resolve-doc($TAN-document as document-node()?) as document-node()?

One-parameter version of fuller one below

Used by variable $tan:annotations-resolved, $tan:see-alsos-resolved, $tan:predecessors-resolved, $tan:successors-resolved, $tan:self-resolved, $tan:redivisions-resolved, $tan:model-resolved, $tan:sources-resolved, $tan:morphologies-resolved.

Used by template ŧ tan:get-and-resolve-dependency, ŧ tan:check-referred-doc, ŧ tan:core-expansion-terse, ŧ tan:class-1-expansion-verbose-pass-1, ŧ tan:core-expansion-verbose.

Used by function tan:resolve-doc(), tan:update-TAN-change-log(), tan:resolve-doc-loop().

Relies upon tan:resolve-doc.

Option 2 (TAN-fn-resolve-files)

tan:resolve-doc($TAN-document as document-node()?, $add-q-ids as xs:boolean, $attributes-to-add-to-root-element as attribute()*) as document-node()?

Input: any TAN document; a boolean indicating whether each element should be 
stamped with a unique id in @q; attributes that should be added to the root element

Output: the TAN document, resolved, as explained in the associated loop function 
below

Related: resolution, files

Used by template ŧ tan:get-and-resolve-dependency, ŧ tan:check-referred-doc, ŧ tan:core-expansion-terse, ŧ tan:class-1-expansion-verbose-pass-1, ŧ tan:core-expansion-verbose.

Used by function tan:resolve-doc(), tan:update-TAN-change-log(), tan:resolve-doc-loop().

Does not rely upon global variables, keys, functions, or templates.

`tan:resolve-href()`

Option 1 (TAN-fn-resolve-files)

tan:resolve-href($xml-node as node()?) as node()?

One-parameter version of the full one, below

Used by function tan:resolve-href(), tan:get-1st-doc().

Relies upon tan:resolve-href.

Option 2 (TAN-fn-resolve-files)

tan:resolve-href($xml-node as node()?, $add-q-ids as xs:boolean) as node()?

Two-parameter version of the full one, below

Used by function tan:resolve-href(), tan:get-1st-doc().

Relies upon tan:base-uri, tan:resolve-href.

Option 3 (TAN-fn-resolve-files)

tan:resolve-href($xml-node as node()?, $add-q-ids as xs:boolean, $this-base-uri as xs:string) as node()?

Input: any XML node, a boolean, a string

Output: the same node, but with @href in itself and all descendant elements resolved 
to absolute form, with @orig-href inserted preserving the original if there is a 
change

The second parameter is provided because this function works closely with 
tan:resolve-doc().

Related: resolution, uris, filenames

Used by function tan:resolve-href(), tan:get-1st-doc().

Relies upon ŧ tan:resolve-href.

Search

Variables

`$morpheus-map`

This variable has a complex definition. See stylesheet for definiton.

Used by template ŧ tan:build-morpheus-ana tan:build-morpheus-lex.

Does not rely upon global variables, keys, functions, or templates.

`$search-services`

Definition: doc('search-services.xml')

Used by function tan:search-for-entities().

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:search-for-entities()`

tan:search-for-entities($server-idref as xs:string, $params as element()+) as item()*

Input: a sequence of strings (search keywords), a string (options: loc), a string 
(options: marcxml, dc, mods), a positive integer

Output: up to N records (N = integer parameter) in the protocol of the 3rd paramater, 
using the SRU protocol of the library catalog specified in the 2nd parameter based on 
search words in the 1st

Related: search, lexicomorphology

Used by function tan:search-for-entities(), tan:search-for-scripta(), tan:search-for-persons(), tan:search-wikipedia(), tan:search-morpheus().

Relies upon $search-services, $tan:internet-available, tan:search-for-entities().

`tan:search-for-persons()`

tan:search-for-persons($search-expression as xs:string?, $max-records as xs:integer) as item()*

Input: a search expression, an integer indicating the number of records requested

Output: that number of records using the search expression in the Virtual 
International Authority File

Related: search, vocabulary

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:search-for-entities.

`tan:search-for-scripta()`

tan:search-for-scripta($search-expression as xs:string?, $max-records as xs:integer) as item()*

Input: a search expression, an integer indicating the number of records requested

Output: that number of records using the search expression in the Library of 
Congress

Related: search, vocabulary

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:search-for-entities.

`tan:search-morpheus()`

tan:search-morpheus($search-expression as xs:string?) as document-node()?

Input: a token in Greek or Latin

Output: lexico-morphological data using Morpheus's service

Related: search, lexicomorphology

Used by function tan:lm-data().

Relies upon tan:item-type, tan:search-for-entities.

`tan:search-results-to-claims()`

tan:search-results-to-claims($search-results as item()*, $results-vendor as xs:string) as item()*

Input: XML representing a search result that is a claim; a string indicating which 
vendor supplied the results

Output: the claim represented in TAN elements

This experimental function, so far only supporting results from 
tan:search-morpheus()

Related: search, lexicomorphology

Used by function tan:lm-data().

Relies upon ŧ tan:claims-morpheus.

`tan:search-results-to-IRI-name-pattern()`

Option 1 (TAN-fn-search-extended)

tan:search-results-to-IRI-name-pattern($search-results as item()*) as item()*

One-parameter version of the fuller one, below

Used by function tan:search-results-to-IRI-name-pattern().

Relies upon tan:search-results-to-IRI-name-pattern.

Option 2 (TAN-fn-search-extended)

tan:search-results-to-IRI-name-pattern($search-results as item()*, $format-results as xs:boolean) as item()*

Input: search results from tan:search-for-entities()

Output: for every entity found, an <item> with <IRI>, <name>, and perhaps <desc>

Note, this is intended to format results from searches that result in identifiers 
and descriptions of entities, not claims.

Related: search, vocabulary

Used by function tan:search-results-to-IRI-name-pattern().

Relies upon ŧ tan:get-IRI-name.

`tan:search-wikipedia()`

tan:search-wikipedia($search-expression as xs:string?, $max-records as xs:integer) as item()*

Input: a search expression, an integer indicating the number of records requested

Output: that number of records using the search expression in Wikipedia

Related: search, vocabulary

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:search-for-entities.

Sequences

Functions

`tan:collate-pair-of-sequences()`

tan:collate-pair-of-sequences($string-sequence-1 as xs:string*, $string-sequence-2 as xs:string*) as element()

Input: two sequences of strings

Output: an element sequence that collates the two sequences as a single sequence, 
attempting to preserve the longest common subsequence.

This function has been written for two different scenarios: 
1. @n values in two sets 
of <div>s that must be collated; 
2. pre-processing two long strings that need to be 
compared. Although the primary context is two sets of unique string-sequences, one could 
imagine situations where one or both input strings have repetition, in which case it is best 
to retain information about the sequence. Hence the output is a sequence of elements, 
with @p1, @p2, or both signifying the position of the original input. The transformation 
is lossless, and the original input can be reconstructed if needed.

Related: grouping, sequences, strings, diff

Used by function tan:diff-courtyard(), tan:diff-loop(), tan:collate-pair-of-sequences(), tan:collate-sequence-loop().

Relies upon tan:array-to-xml, tan:collate-pair-of-sequences(), tan:longest-ascending-subsequence.

`tan:collate-sequences()`

tan:collate-sequences($elements-with-elements as element()*) as xs:string*

Input: a sequence of elements, each with a sequence of child elements

Output: a series of strings that is a collation of the text sequences of the input

Example: Given input: <a><t>apple</t><t>banana</t><t>carrot</t></a> 
<b><t>apple</t><t>carrot</t><t>dessert</t></b> <c><t>apple</t><t>dessert</t></c> Output will be: ('apple', 'banana', 
'carrot', 'dessert')

Related: nodes, sequences

Used by function tan:collate-sequences(), tan:group-divs().

Relies upon tan:collate-sequences().

`tan:distinct-items()`

tan:distinct-items($items as item()*) as item()*

Input: any sequence of items

Output: Those items that are not deeply equal to any other item in the sequence

This function is parallel to distinct-values(), but handles non-string input

Related: items, nodes

Used by template ŧ tan:merge-tan-docs, ŧ tan:infuse-diff-and-collate-stats, ŧ tan:core-expansion-terse-attributes, ŧ tan:check-referred-doc, ŧ tan:core-expansion-terse.

Used by function tan:vocabulary(), tan:merge-anas(), tan:attribute-vocabulary().

Does not rely upon global variables, keys, functions, or templates.

`tan:duplicate-items()`

tan:duplicate-items($sequence as item()*) as item()*

Input: any sequence of items

Output: those items that appear in the sequence more than once

This function parallels the standard fn:distinct-values()

Related: items, nodes

Used by variable $tan:duplicate-head-iris.

Used by template ŧ tan:dependency-adjustments-pass-2, ŧ tan:array-to-map, ŧ tan:core-expansion-terse-attributes, ŧ tan:class-2-expansion-terse tan:class-2-expansion-terse-for-validation, ŧ tan:catalog-expansion-terse, ŧ tan:core-expansion-terse.

Used by function tan:duplicate-values(), tan:morphological-code-conversion-maps(), tan:group-elements-by-shared-node-values().

Relies upon tan:item-type.

`tan:duplicate-values()`

tan:duplicate-values($sequence as item()*) as item()*

surrogate function for tan:duplicate-items()

Used by template ŧ tan:dependency-adjustments-pass-1 tan:core-expansion-terse, ŧ tan:core-expansion-normal, ŧ tan:convert-morphological-codes, ŧ tan:core-expansion-terse-attributes-to-elements.

Relies upon tan:duplicate-items.

`tan:expand-numerical-expression()`

tan:expand-numerical-expression($selector as xs:string?, $max as xs:integer?) as xs:integer*

Input: a string representing a TAN selector (used by @pos, @chars), and an integer 
defining the value of 'last'

Output: a sequence of numbers representing the positions selected, unsorted, and 
retaining duplicate values. Example: ("2 - 4, last-5 - last, 36", 50) -> (2, 3, 4, 45, 46, 47, 48, 
49, 50, 36) Errors will be flagged as follows: 0 = value that falls below 1; -1 = value that 
surpasses the value of $max; -2 = ranges that call for negative steps, e.g., '4 - 2'.

This function assumes that all numerals are Arabic.

Related: sequences, numerics, numerals

Used by template ŧ tan:core-expansion-terse-attributes-to-elements, ŧ tan:check-and-expand-ranges, ŧ tan:mark-dependencies-pass-2-for-validation, ŧ tan:evaluate-conditions.

Does not rely upon global variables, keys, functions, or templates.

`tan:item-type()`

tan:item-type($xml-items as item()*) as xs:string*

Input: any XML items

Output: the type of each item

Related: items, datatypes, nodes

Used by template ŧ tan:map-put, ŧ tan:array-to-map, ŧ tan:map-remove, ŧ tan:map-and-array-to-xml.

Used by function tan:map-entries(), tan:stamp-tree-with-text-data(), tan:restore-chopped-tree(), tan:duplicate-items(), tan:search-morpheus(), tan:map-put().

Does not rely upon global variables, keys, functions, or templates.

`tan:longest-ascending-subsequence()`

tan:longest-ascending-subsequence($integer-sequence as item()*) as array(xs:integer+)?

Input: a sequence of items. Each item is either an integer, an array of integer 
sequences, or a sequence of integers serialized as text nodes (within child elements)

Output: An array. Each member of the array is a sequence of two integers. The first 
represents the position of the output integer, and the second is the integer itself that is a 
member of the longest ascending subsequence. The positional first integer allows one to 
disambiguate repetitions in the input.

Although this function claims by its name to find the longest subsequence, in the 
interests of efficiency, it applies the so-called Patience method of finding the string, 
which may return only a very long string, not the longest possible string. Such an approach 
allows the number of operations to be directly proportionate to the number of input values 
(backtracking would be computationally intensive on long sequences). The routine does 
"remember" gaps. If, given a set of integers, there is no increment available in candidate 
sequences, the sequences are retained, but a check is made backward for a subsequence that would 
account for the smallest of the new integers.

The input allows a sequence of elements, along with integers, because this function 
has been written to support tan:collate-pairs-of-sequences(), which requires 
choice options. That is, you may have a situation where you are comparing two sequences, 
either of which may have values that repeat, e.g., (a, b, c, b, d) and (c, b, d). The first 
sequence is converted (1, 2, 3, 4, 5). In finding a corresponding sequence of integers for the 
second set, b must be allowed to be either 2 or 4, i.e., the array [3, (2, 4), 5]. Both items of 
input would ideally be expressed as arrays of integers, but this function serves an XSLT 
2.0 library (where arrays are not recognized), and arrays are not as easy to construct 
and extract in XSLT 3.0 as maps are.

If an input array member consists of the empty sequence, its position impacts the 
positions that are returned in the output, but not the corresponding values (obviously).

Related: items, sequences, numerics

Used by function tan:longest-ascending-subsequence(), tan:collate-pair-of-sequences().

Relies upon tan:longest-ascending-subsequence(), ŧ tan:build-integer-arrays.

`tan:most-common-item()`

TAN-fn-sequences-extended

tan:most-common-item($sequence as item()*) as item()?

Input: any sequence of items

Output: the one item that appears most frequently

If two or more items appear equally frequently, only the first is returned

Related: sequences, items

Used by variable $tan:most-common-indentations.

Does not rely upon global variables, keys, functions, or templates.

`tan:most-common-item-count()`

tan:most-common-item-count($sequence as item()*) as xs:integer?

Input: any sequence of items

Output: the count of the first item that appears most frequently

If two or more items appear equally frequently, only the first is returned

Written to help group <u> elements in tan:collate()

Related: items, sequences

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Statistics

Functions

`tan:median()`

TAN-fn-statistics-extended

tan:median($numbers as xs:anyAtomicType*) as xs:anyAtomicType?

Input: any sequence of numbers

Output: the median value

It is assumed that the input has already been sorted by tan:numbers-sorted() vel sim

Related: statistics

Used by function tan:outliers().

Does not rely upon global variables, keys, functions, or templates.

`tan:no-outliers()`

TAN-fn-statistics-extended

tan:no-outliers($numbers as xs:anyAtomicType*) as xs:anyAtomicType*

Input: any sequence of numbers

Output: the same sequence, without outliers

Related: statistics

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:outliers.

`tan:outliers()`

TAN-fn-statistics-extended

tan:outliers($numbers as xs:anyAtomicType*) as xs:anyAtomicType*

Input: any sequence of numbers

Output: outliers in the sequence

Related: statistics

Used by function tan:no-outliers(), tan:outliers().

Relies upon tan:median, tan:number-sort, tan:outliers().

Strings

Used by function tan:nested-phrase-loop().

Does not rely upon global variables, keys, functions, or templates.

Functions

`tan:acronym()`

tan:acronym($string-input as xs:string?) as xs:string?

Input: any strings

Output: the acronym of those strings (initial letters joined without spaces)

Example: "The Cat in the Hat" - > "TCitH"

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:adjust-diff()`

tan:adjust-diff($diff-output as element(tan:diff)*) as element()*

Input: any output <diff>s from tan:diff()

Output: the output adjusted, with <a> and <b>s shifted if there are more optimal 
divisions

Multiple inputs are presumed to be tan:diff() results that should be concatenated.

This function is helpful for cases where the common element needs to be adjusted to 
better respect word or phrase boundaries.

Related: strings, diff

Used by function tan:collate(), tan:replace-diff(), tan:adjust-diff().

Relies upon tan:adjust-diff(), tan:common-end-string, tan:common-start-string, ŧ tan:trim-or-add-text.

`tan:apply-deltas()`

Option 1 (TAN-fn-strings-diff-extended)

tan:apply-deltas($string-to-convert as xs:string?, $deltas as document-node()*) as xs:string?

2-parameter version of the full one, below

Used by function tan:apply-deltas().

Relies upon tan:apply-deltas.

Option 2 (TAN-fn-strings-diff-extended)

tan:apply-deltas($string-to-convert as xs:string?, $deltas as document-node()*, $input-is-string-a as xs:boolean?) as xs:string?

Input: a string, a series of delta documents, perhaps a boolean

Output: another string, after any applicable deltas have been successively 
applied

Each delta will be applied only once. If any deltas are left over, a warning will be 
returned.

Output will be verified; if its checksum does not match what is in the given delta, a 
warning will be returned

Related: strings, diff

Used by function tan:apply-deltas().

Relies upon tan:apply-deltas, tan:checksum-fletcher-64, tan:ellipses, tan:trim-long-tree.

`tan:atomize-string()`

tan:atomize-string($input as xs:string?) as xs:string*

surrogate function for tan:chop-string()

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:chop-string.

`tan:batch-replace()`

tan:batch-replace($string-to-replace as xs:string?, $replace-elements as element()*) as xs:string?

Input: a string, a sequence of: <[ANY NAME] pattern="" replacement="" [flags=""] 
[message=""]>

Output: the string, after those replaces are processed in order

Used by function tan:batch-replace().

Relies upon tan:batch-replace().

`tan:batch-replace-advanced()`

tan:batch-replace-advanced($items-with-strings as item()*, $replace-elements as element()*) as item()*

Input: any items; a sequence of elements: <[ANY NAME] pattern="" [flags=""] 
[message=""] [exclude-pattern=""]>[ANY CONTENT]</[ANY NAME]>

Output: a sequence of items, with instances of @pattern replaced by the content of 
the elements

This is a more advanced form of tan:batch-replace(), in that it allows text to be 
replaced by elements. It also allows for exclusion of matches via @exclude-pattern.. That is, 
if a span of text matches that value, the match will be ignored.

The function was devised to convert raw text into TAN-T. Textual references can be 
turned into <div n=""/> anchors, and the result can then be changed into a traditional 
hierarchy.

Related: strings, tree manipulation, nodes

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:batch-replace-advanced-pass-1.

`tan:chop-diff-output()`

tan:chop-diff-output($diff-output as element(tan:diff)?, $chop-points as xs:integer*, $use-string-a as xs:boolean, $chop-other-at-regex as xs:string?) as map(xs:integer, item()*)

Input: diff output; a sequence of integers; a boolean; a string

Output: a map whose constituent map entries consist of the input chopped into parts 
according to the input sequence of integers. If the boolean is true, then chops will be made 
according to string a, with chops on b made proportionally, respecting the boundaries defined 
by the fourth parameter.

Each map entry have as its value a <diff> wrapping the fragment <a>, <b>, <common>s.

If the input diff output already has @_pos-a and the like already inside, those 
figures will be respected, otherwise string data will be stamped into the input, and will be 
preserved in the output.

The numeral 1 will be automatically added to the chop points, and duplicates will be 
removed.

If the chop regex for the other string is missing, the chops will occur on individual 
characters.

This function was written primarily to support verbose validation of class 1 files, 
and to drive the application that synchronizes a class 1 file with a given redivision.

This function provides a more complex approach to the generic one supported by 
tan:chop-tree()

Related: strings, tree manipulation

Used by template ŧ tan:class-1-expansion-verbose-pass-3.

Used by function tan:chop-diff-output().

Relies upon $tan:char-regex, tan:chop-diff-output(), tan:stamp-diff-with-text-data, ŧ tan:split-diff-components-1.

`tan:chop-string()`

tan:chop-string($input as xs:string?) as xs:string*

Input: any string

Output: that string chopped into a sequence of individual characters, following 
TAN rules (modifying characters always join their preceding base character)

Related: strings, sequences

Used by template ŧ tan:core-expansion-terse-attributes-to-elements, ŧ tan:split-diff-components-1, ŧ tan:mark-dependencies-pass-2, ŧ tan:split-diff-components-2.

Used by function tan:atomize-string(), tan:chop-string(), tan:string-length(), tan:diff-loop(), tan:segment-string(), tan:int-to-grc(), tan:cardinal().

Relies upon $tan:char-regex.

Option 2 (TAN-fn-strings-standard)

tan:chop-string($input as xs:string?, $chop-after-regex as xs:string) as xs:string*

Input: any string

Output: that string chopped into a sequence of individual characters, following 
TAN rules (modifying characters always join their preceding base character)

Related: strings, sequences

Used by template ŧ tan:core-expansion-terse-attributes-to-elements, ŧ tan:split-diff-components-1, ŧ tan:mark-dependencies-pass-2, ŧ tan:split-diff-components-2.

Used by function tan:atomize-string(), tan:chop-string(), tan:string-length(), tan:diff-loop(), tan:segment-string(), tan:int-to-grc(), tan:cardinal().

Does not rely upon global variables, keys, functions, or templates.

Option 3 (TAN-fn-strings-standard)

tan:chop-string($input as xs:string?, $chop-after-regex as xs:string) as xs:string*

2-param version of the full one below

Used by template ŧ tan:core-expansion-terse-attributes-to-elements, ŧ tan:split-diff-components-1, ŧ tan:mark-dependencies-pass-2, ŧ tan:split-diff-components-2.

Used by function tan:atomize-string(), tan:chop-string(), tan:string-length(), tan:diff-loop(), tan:segment-string(), tan:int-to-grc(), tan:cardinal().

Relies upon tan:chop-string.

Option 4 (TAN-fn-strings-standard)

tan:chop-string($input as xs:string?, $chop-after-regex as xs:string, $preserve-nested-clauses as xs:boolean) as xs:string*

Input: any string, a regular expression, a boolean

Output: the input string cut into a sequence of strings using the regular expression 
as the cut marker

If the last boolean is true, then nested clauses (parentheses, direct quotations, 
etc.) will be preserved.

This function differs from the 1-parameter version in that it is used to chop the 
string not into individual characters but into words, clauses, sentences, etc.

Related: strings

Used by template ŧ tan:core-expansion-terse-attributes-to-elements, ŧ tan:split-diff-components-1, ŧ tan:mark-dependencies-pass-2, ŧ tan:split-diff-components-2.

Used by function tan:atomize-string(), tan:chop-string(), tan:string-length(), tan:diff-loop(), tan:segment-string(), tan:int-to-grc(), tan:cardinal().

Does not rely upon global variables, keys, functions, or templates.

`tan:collate()`

Option 1 (TAN-fn-strings-collate-standard)

tan:collate($strings-to-collate as xs:string*, $string-labels as xs:string*, $preoptimize-string-order as xs:boolean) as element()?

3-parameter version of fuller one, below

Used by template ŧ tan:clean-up-collation-pass-1.

Used by function tan:collate().

Relies upon tan:collate.

Option 2 (TAN-fn-strings-collate-standard)

tan:collate($strings-to-collate as xs:string*, $string-labels as xs:string*, $preoptimize-string-order as xs:boolean, $adjust-diffs-during-preoptimization as xs:boolean, $clean-up-collation as xs:boolean) as element()?

5-parameter version of fuller one, below

Used by template ŧ tan:clean-up-collation-pass-1.

Used by function tan:collate().

Relies upon tan:collate.

Option 3 (TAN-fn-strings-collate-standard)

Input: a sequence of strings to be collated; a sequence of strings that label each 
string; a boolean indicating whether the sequence of input strings should be optimized; a 
boolean indicating whether the results of tan:diff() should be processed and weighed; a 
boolean indicating whether the collation should be cleaned up; a boolean whether diffs 
should be processed word for word or not.

Output: a <collation> with (1) one <witness> per string (and if the last parameter is 
true, then a sequence of children <commonality>s, signifying how close that string is 
with every other, and (2) a sequence of <c>s and <u>s, each with a <txt> and one or more <wit 
ref="" pos=""/>, indicating which string witness attests to the [c]ommon or [u]nique 
reading, and what position in that string the particular text fragment starts at.

If there are not enough labels (2nd parameter) for the input strings, the numerical 
position of the input string will be used as the string label / witness id.

If the third parameter is true, then tan:diff() will be performed against each pair 
of strings. Each diff output will be weighed by closeness of the two texts, and sorted 
accordingly. The results of this operation will be stored in collation/witness/commonality. 
This requires (n-1)! operations, so should be efficient for a few input strings, but will 
grow progressively longer according to the number and size of the input strings. 
Preoptimizing strings will likely produces greater congruence in the <u> fragments.

If the last parameter is true, then cleanup will not be performed. This parameter was 
introduced because the cleanup process itself invokes tan:collate() and one does not want to 
get into an endless loop because of a mishmash of differences that can never be 
reconciled or brought closer together.

This version of tan:collate was written in XSLT 3.0 to take advantage of 
xsl:iterate, and has an arity of 3, 5, or 6 parameters, unlike its XSLT 2.0 predecessors, which also 
applied a different approach to collation.

Changes in output from previous version of tan:collate(): 
- @w is now <wit> with 
@ref and @pos 
- the text node of <u> or <c> is now wrapped in <txt> 
- @length is ignored (the 
value is easily calculated) With these changes, any witness can be easily reconstructed 
with the XPath expression tan:collation/()

Related: strings, diff

Used by template ŧ tan:clean-up-collation-pass-1.

Used by function tan:collate().

Relies upon tan:adjust-diff, tan:collate(), tan:diff-cache, tan:diff-to-collation, tan:trim-long-text, ŧ tan:clean-up-collation-pass-1, ŧ tan:clean-up-collation-pass-2.

`tan:commas-and-ands()`

Option 1 (TAN-fn-strings-extended)

tan:commas-and-ands($input-strings as xs:string*) as xs:string?

One-parameter version of the full one below

Used by function tan:commas-and-ands().

Relies upon tan:commas-and-ands.

Option 2 (TAN-fn-strings-extended)

tan:commas-and-ands($input-strings as xs:string*, $oxford-comma as xs:boolean) as xs:string?

Input: sequences of strings

Output: the strings joined together with , and 'and'

Related: strings

Used by function tan:commas-and-ands().

Does not rely upon global variables, keys, functions, or templates.

`tan:common-end-string()`

tan:common-end-string($strings as xs:string*) as xs:string?

1-parameter version of fuller function below

Used by template ŧ tan:adjust-horizontal-search.

Used by function tan:adjust-diff().

Relies upon tan:common-start-or-end-string.

`tan:common-start-or-end-string()`

tan:common-start-or-end-string($strings as xs:string*, $find-common-start as xs:boolean) as xs:string?

2-parameter version of fuller function below

This one deals with many strings; the full one, with pairs of them

Used by function tan:common-start-string(), tan:common-end-string(), tan:common-start-or-end-string().

Relies upon tan:common-start-or-end-string.

Option 2 (TAN-fn-strings-standard)

tan:common-start-or-end-string($string-a as xs:string?, $string-b as xs:string?, $find-common-start as xs:boolean) as xs:string?

Input: two strings; a boolean

Output: the longest common start (param 2 is true) or end (param 2 is false) portion of 
the two strings.

Related: strings

Used by function tan:common-start-string(), tan:common-end-string(), tan:common-start-or-end-string().

Relies upon tan:common-start-or-end-string(), tan:ellipses, tan:log2.

`tan:common-start-string()`

tan:common-start-string($strings as xs:string*) as xs:string?

1-parameter version of fuller function below

Used by template ŧ tan:adjust-horizontal-search.

Used by function tan:adjust-diff().

Relies upon tan:common-start-or-end-string.

`tan:contains-only-once()`

tan:contains-only-once($arg1 as xs:string?, $arg2 as xs:string?) as xs:boolean

Input: any two strings

Output: true() if and only if the first string contains the second, only one time

This function was introduced to support tan:diff(), to ensure that unique common 
tokens between two strings are not substrings of any other unique common tokens.

Related: strings

Used by function tan:diff-courtyard(), tan:diff-loop().

Does not rely upon global variables, keys, functions, or templates.

`tan:diff()`

Option 1 (TAN-fn-strings-diff-standard)

tan:diff($string-a as xs:string?, $string-b as xs:string?) as element()

2-param version of fuller one below

Used by template ŧ tan:class-1-expansion-verbose-pass-1, ŧ tan:core-expansion-normal.

Used by function tan:diff(), tan:diff-cache(), tan:diff-courtyard(), tan:giant-diff(), tan:replace-collation(), tan:get-diff-output-transpositions(), tan:replace-diff(), tan:diff-loop(), tan:replace-expanded-class-1-body(), tan:diff-or-collate-to-html().

Relies upon tan:diff.

Option 2 (TAN-fn-strings-diff-standard)

tan:diff($string-a as xs:string?, $string-b as xs:string?, $snap-to-word as xs:boolean) as element()

3-param version of fuller one below

Used by template ŧ tan:class-1-expansion-verbose-pass-1, ŧ tan:core-expansion-normal.

Relies upon tan:diff.

Option 3 (TAN-fn-strings-diff-standard)

tan:diff($string-a as xs:string?, $string-b as xs:string?, $snap-to-word as xs:boolean, $preprocess-long-strings as xs:boolean) as element()

Input: any two strings; boolean indicating whether results should snap to nearest 
word; boolean indicating whether long strings should be pre-processed

Output: an element with <a>, <b>, and <common> children showing where strings a and b 
match and depart

This function was written to assist the validation of <redivision>s quickly find 
differences between any two strings. The function has been tested on pairs of strings up to 
combined lengths of 9M characters. At that scale, the only way to efficiently process the 
diffs is by chaining smaller diffs, which are still large, optimally about 350K in length.

This function prepares strings for 5-arity tan:diff-engine(), primarily by 
tending to input strings that are large or really large (giant). Large pairs of strings are 
parsed to find common characters that might be used to find pairwise congruence of large 
segments. Giant pairs of strings are passed to tan:giant-diff().

Related: strings, diff

Used by template ŧ tan:class-1-expansion-verbose-pass-1, ŧ tan:core-expansion-normal.

Relies upon tan:diff(), tan:ellipses.

`tan:diff-cache()`

tan:diff-cache($string-a as xs:string?, $string-b as xs:string?, $snap-to-word as xs:boolean, $preprocess-long-strings as xs:boolean) as element()

4-param version of fuller one below This is a shadow function for tan:diff(). It uses 
XSLT 3.0 @cache, so that tan:collate() can avoid repeating diffs. Works only if the 
processor supports advanced features (e.g., Saxon PE, EE, not HE)

Used by function tan:collate().

Relies upon tan:diff.

`tan:diff-to-collation()`

tan:diff-to-collation($diff-output as element()?, $diff-text-a-label as xs:string?, $diff-text-b-label as xs:string?) as element()

Input: any single output of tan:diff(), two strings for the labels of diff strings a 
and b

Output: the output converted to the output of tan:collate(), namely, a <collation> 
with <u> and <c> children, wrapping <txt>, <wit>.

This function was written to support the XSLT 3.0 version of tan:collate(), to allow 
tan:diff() to be merged with tan:collate() output

Related: strings, diff

We leave a marker for both witnesses in every <a> or <b>, but marking one as <wit> and 
another as <x>. This will facilitate the grouping of collations.

Used by function tan:collate().

Does not rely upon global variables, keys, functions, or templates.

`tan:diff-to-delta()`

tan:diff-to-delta($diff-output as element(tan:diff)?) as document-node()?

Input: any output from tan:diff()

Output: a document node registering only the difference between strings a and b

Delta files are structured to support two-way conversion. That is, they are 
designed such that b can be reconstituted from a or vice versa. See tan:apply-deltas() for 
documentation.

Related: diff, strings

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:diff-to-delta.

`tan:ellipses()`

tan:ellipses($strings-to-truncate as xs:string*, $string-length-to-retain as xs:integer) as xs:string*

2-arity version of the fuller one, below

Used by template ŧ tan:adjust-horizontal-search, ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1, ŧ tan:ellipses.

Used by function tan:ellipses(), tan:diff-courtyard(), tan:giant-diff(), tan:get-diff-output-transpositions(), tan:md5(), tan:common-start-or-end-string(), tan:diff-loop(), tan:infuse-tree(), tan:diff(), tan:apply-deltas(), tan:checksum-fletcher(), tan:diff-or-collate-to-html().

Relies upon tan:ellipses.

Option 2 (TAN-fn-strings-standard)

tan:ellipses($strings-to-truncate as xs:string*, $string-length-to-retain as xs:integer, $terminal-string-length-to-retain as xs:integer) as xs:string*

3-arity version of the fuller one, below

Used by template ŧ tan:adjust-horizontal-search, ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1, ŧ tan:ellipses.

Relies upon tan:ellipses.

Option 3 (TAN-fn-strings-standard)

tan:ellipses($strings-to-truncate as xs:string*, $initial-string-length-to-retain as xs:integer, $terminal-string-length-to-retain as xs:integer, $indicate-number-of-characters-elided as xs:boolean) as xs:string*

Input: any sequence of strings; two integers; a boolean

Output: the sequence of strings, but with any initial substring beyond the first 
requested length and any terminal substring beyond the last requested length replaced by 
ellipses. If the boolean is true, then two sets of ellipses will be provided, surrounding in 
square brackets the number of characters removed.

If the elision is less than the length of the replacement, then no elision will take 
place.

Examples: "abcd", 1, 1, false > "a…d" "abcd", 1, 1, true > "abcd" "abcdefghijk", 1, 1, 
true > "a…[9]…k"

Related: strings

Used by template ŧ tan:adjust-horizontal-search, ŧ tan:core-expansion-terse tan:dependency-adjustments-pass-1, ŧ tan:ellipses.

Relies upon tan:ellipses().

`tan:fill()`

tan:fill($string-to-fill as xs:string?, $times-to-repeat as xs:integer) as xs:string?

Input: a string, an integer

Output: a string with the first parameter repeated the number of times specified by 
the integer

This function was written to facilitate indentation

Related: strings, spacing

Used by template ŧ tan:indent-items.

Used by function tan:checksum-fletcher(), tan:bin-to-hex(), tan:hex-to-bin(), tan:bin-to-base64(), tan:base64-to-bin(), tan:hex-to-base64(), tan:base64-to-hex(), tan:hex-to-base64Binary(), tan:hex-to-hexBinary().

Does not rely upon global variables, keys, functions, or templates.

`tan:get-collate-stats()`

TAN-fn-strings-collate-extended

tan:get-collate-stats($collate-input as element()?, $include-venns as xs:boolean) as element()?

Input: any output from tan:collate(); boolean

Output: the output, wrapped in a <group> and preceded by statistics. If the boolean 
is true, then 3-way venn statistics will be included.

For details, see comments at tan:infuse-diff-and-collate-stats().

Related: strings

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:get-diff-stats.

`tan:get-diff-output-transpositions()`

tan:get-diff-output-transpositions($diff-output as element(tan:diff), $minimum-transposition-length as xs:integer, $minimum-commonality as xs:decimal) as element()

Input: output from tan:diff(); an integer; a decimal (from 0 to 1)

Output: a <transpositions> element, wrapping the following: (1) a <checksums> 
element that contains the checksums for strings a and b of the input; (2) a <parameters> 
element that contains the settings specified; (3) zero or more <transposition> elements 
wrapping the portion of the input diff output that is at least as long as the integer, and whose 
commonality is greater than or equal to the percent specified by the decimal.

This function looks within likely sections of the results of tan:diff() for 
passages that may represent a transposition. What constitutes a transposition differs 
greatly from one situation to the next. In large stretches of running prose, a safe minimum 
length might be 20 and a corresponding commonality 0.95, to accommodate very occasional 
changes. The lower the commonality number, the more results, but they may include on the edges 
material that is not part of the actual transposition.

<transposition> has attributes that point to the absolute position of the start of 
the a and b fragments within the original diff output. These values can be used as points 
at which to chop the diff result tree, if you wish to synthesize, combine, etc. it with 
the transposition slices.

Transpositions can be a difficult topic, with many-to-many assignments between 
the two texts, or with assignments in the same text that overlap. This is normal, and 
reflects normal editing habits. For example, an editor may take two sentences from different 
parts of a text and merge them at a third spot. This function, with enough leeway in the 
parameters, would catch both of the transpositions. It is up to you to interpret those 
transpositions and use them as you see fit.

Related: strings, diff

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:checksum-fletcher-64, tan:diff, tan:ellipses, tan:map-to-xml, tan:stamp-diff-with-text-data, ŧ tan:strip-text-data-stamps.

`tan:get-diff-stats()`

tan:get-diff-stats($diff-input as element()?) as element()?

Input: any output from tan:diff()

Output: the output, wrapped in a <group> and preceded by statistics.

For details, see comments at tan:infuse-diff-and-collate-stats().

Related: diff, statistics

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:get-diff-stats.

`tan:glob-to-regex()`

tan:glob-to-regex($globs as xs:string*) as xs:string*

Input: any strings that follow a glob-like syntax

Output: the strings converted to regular expressions

Related: strings, filenames

Used by function tan:uri-collection-from-pattern().

Does not rely upon global variables, keys, functions, or templates.

`tan:initial-upper-case()`

tan:initial-upper-case($strings as xs:string*) as xs:string*

Input: any strings

Output: each string with the initial letters capitalized and the rest set 
lower-case

Used by template ŧ tan:title-case.

Used by function tan:title-case().

Does not rely upon global variables, keys, functions, or templates.

`tan:lcs-distance()`

tan:lcs-distance($diff-output as element(tan:diff)?) as xs:integer?

Input: results of tan:diff()

Output: the longest common subsequence distance of the output

LCS distance assigns 1 point per character deletion and insertion

Related: strings, diff

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:levenshtein-distance()`

tan:levenshtein-distance($diff-output as element(tan:diff)?) as xs:integer?

Input: results of tan:diff()

Output: the Levenstein distance of the output

Levenstein distance assigns 1 point per character deletion, insertion, or 
substitution

Related: strings, diff

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:levenshtein-distance.

`tan:namespace()`

tan:namespace($prefix-or-uri as xs:string*) as xs:string*

Input: any strings representing a namespace prefix or uri

Output: the corresponding prefix or uri whenever a match is found in the global 
variable

Related: strings, namespaces

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:namespaces-and-prefixes.

`tan:normalize-div-text()`

tan:normalize-div-text($single-leaf-div-text-nodes as xs:string*) as xs:string*

One-parameter version of the fuller one, below.

Used by template ŧ tan:tokenize-div, ŧ tan:text-join.

Used by function tan:normalize-div-text().

Relies upon tan:normalize-div-text.

Option 2 (TAN-fn-strings-standard)

tan:normalize-div-text($single-leaf-div-text-nodes as xs:string*, $remove-special-div-end-chars as xs:boolean) as xs:string*

Input: any sequence of strings, presumed to be text nodes of a single leaf div; a 
boolean indicating whether special div-end characters should be retained or not

Output: the same sequence, normalized according to TAN rules. Each item in the 
sequence is space normalized and then if its end matches one of the special div-end 
characters, ZWJ U+200D or SOFT HYPHEN U+AD, the character is removed; otherwise a space is added 
at the end. Zero-length strings are skipped.

This function is designed specifically for TAN's commitment to nonmixed content. 
That is, every TAN element contains either elements or non-space text but not both, which 
also means that space-only text nodes are effectively ignored. It is assumed that every 
TAN element is followed by a notional space.

The second parameter is important, because output will be used to normalize and 
repopulate leaf <div>s (where special div-end characters should be retained) or to 
concatenate leaf <div> text (where those characters should be deleted)

Related: strings

Used by template ŧ tan:tokenize-div, ŧ tan:text-join.

Used by function tan:normalize-div-text().

Relies upon $tan:special-end-div-chars-regex, tan:normalize-div-text().

`tan:normalize-name()`

tan:normalize-name($text as xs:string*) as xs:string*

one-parameter version of fuller one, below

Used by template ŧ tan:first-stamp-shallow-copy, ŧ tan:core-expansion-terse-attributes, ŧ tan:first-stamp-shallow-skip, ŧ tan:core-expansion-terse, ŧ tan:core-expansion-normal.

Used by function tan:vocabulary(), tan:update-TAN-change-log(), tan:has-vocab(), tan:resolve-doc-loop(), tan:attribute-vocabulary().

Relies upon tan:normalize-text.

`tan:normalize-text()`

tan:normalize-text($text as xs:string*) as xs:string*

one-parameter version of full function below

Used by template ŧ tan:check-referred-doc.

Used by function tan:normalize-text(), tan:normalize-name().

Relies upon tan:normalize-text.

Option 2 (TAN-fn-strings-standard)

tan:normalize-text($text as xs:string*, $treat-as-name-values as xs:boolean) as xs:string*

Input: any sequence of strings; a boolean indicating whether the results should be 
name-normalized

Output: that sequence, with each item's space normalized, and removal of any help 
requested

In name-normalization, the string is converted to lower-case, and spaces replace 
hyphens, underscores, and illegal characters.

Special end div characters are not removed in this operation, nor is tail-end space 
adjusted according to TAN rules; for that, see tan:normalize-div-text().

Related: strings

Used by template ŧ tan:check-referred-doc.

Used by function tan:normalize-text(), tan:normalize-name().

Relies upon $tan:help-trigger-regex, $tan:regex-characters-not-permitted, $tan:regex-name-space-characters.

`tan:normalize-unicode()`

tan:normalize-unicode($input as item()*) as item()*

Input: any items

Output: the same items, but with all unicode normalized

This is a surrogate to fn:normalize-unicode(), extending functionality to any 
item

Related: strings, tree manipulation

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:normalize-unicode.

`tan:replace-collation()`

TAN-fn-strings-collate-extended

tan:replace-collation($original-witness-string as xs:string?, $original-witness-id as xs:string?, $collate-output-to-replace as element()?) as element()?

Input: two strings; the output of tan:collate()

Output: the output, but an attempt is made to change every <c> and every <u> with the 
chosen witness id (param 2) into the original string form (param 1).

This is a companion function to tan:replace-diff(), but it has some inherent 
limitations. Diffs of 3 or more sources can be messy, and any attempt to replace every <u> with a 
particular version proves to be confusing to interpret. Furthermore, tan:replace-diff() 
adjusts the output so that newly inserted characters are not repeated if they are applied 
equally to coordinate <a>s and <b>s. That is not possible for collate because of how chaotic 
the results can be. So the fallback method is to focus on getting the first witness right, 
and not worrying about the others.

If the 2nd parameter is empty or doesn't match a particular witness id, then the first 
witness will be chosen. Intentionally supplying a bad 2nd parameter can be a good idea, if you 
are interested in only the dominant source, since tan:collate() by default places at 
the top the witness with the least amount of divergence.

Because only one witness is being recalibrated, it is possible to update the 
position values. But the other witness values will not be updated, so that the results can be 
correlated with the other witness texts if needed. Further, if a replacement involves that 
witness no longer attesting to that fragment, then it is changed to a <u> (or the <u> is 
retained) and the <wit> is dropped.

Related: strings, diff

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:diff, ŧ tan:replace-collation.

`tan:replace-diff()`

tan:replace-diff($original-string-a as xs:string?, $original-string-b as xs:string?, $diff-to-replace as element()?, $prioritize-a-over-b as xs:boolean) as element()?

Input: the results of tan:diff(); the original a and b strings; a boolean

Output: the output, but with each <a>, and <b> replaced by the original strings. 
<common> follows the a string, not b.

This function was made to support a more relaxed approach to tan:diff(), one that 
avoids changes that should be ignored. For example, if you are comparing "Gray" (=$a) and 
"greys" (=$b) and for your purposes, alternate spellings and case should be ignored, then 
make appropriate changes to the strings (=$a2, $b2) then tan:reconcile-diff($a, $b, 
tan:diff$a2, $b2)) will result in <diff><common>Gray</common><b>s</b></diff>

Related: strings, diff

Used by function tan:replace-diff().

Relies upon tan:adjust-diff, tan:diff, tan:map-to-xml, tan:replace-diff(), tan:stamp-diff-with-text-data, ŧ tan:replace-diff, ŧ tan:shallow-skip-diff-add.

`tan:reverse-string()`

tan:reverse-string($string-to-reverse as xs:string?) as xs:string?

Input: any string

Output: the string in reverse order

Used by function tan:le-bits-to-int-and-neg(), tan:md5().

Does not rely upon global variables, keys, functions, or templates.

`tan:satisfies-regex()`

tan:satisfies-regex($string-to-test as xs:string?, $string-must-match-regex as xs:string?) as xs:boolean

2-param version of fuller one, below

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:satisfies-regexes.

`tan:satisfies-regexes()`

Option 1 (TAN-fn-strings-extended)

tan:satisfies-regexes($string-to-test as xs:string?, $string-must-match-regex as xs:string?, $string-must-not-match-regex as xs:string?) as xs:boolean

3-param version of fuller one, below

Used by function tan:satisfies-regex(), tan:filename-satisfies-regex(), tan:satisfies-regexes(), tan:filename-satisfies-regexes().

Relies upon tan:satisfies-regexes.

Option 2 (TAN-fn-strings-extended)

tan:satisfies-regexes($string-to-test as xs:string?, $string-must-match-regex as xs:string?, $string-must-not-match-regex as xs:string?, $flags as xs:string?) as xs:boolean

Input: a string value; an optional regex the string must match; an optional regex the 
string must not match

Output: whether the string satisfies the two regex conditions; if either regex is 
empty, true will be returned

If the input string is less than zero length, the function returns false

Related: strings, regular expressions

Used by function tan:satisfies-regex(), tan:filename-satisfies-regex(), tan:satisfies-regexes(), tan:filename-satisfies-regexes().

Does not rely upon global variables, keys, functions, or templates.

`tan:segment-string()`

Option 1 (TAN-fn-strings-extended)

tan:segment-string($string-to-segment as xs:string?, $segment-portions as xs:decimal*) as xs:string*

2-arity version of the more complete function, below

Used by function tan:segment-string(), tan:infuse-tree().

Relies upon tan:segment-string.

Option 2 (TAN-fn-strings-extended)

tan:segment-string($string-to-segment as xs:string?, $segment-portions as xs:decimal*, $break-at-regex as xs:string) as xs:string*

Input: a string, a sequence of doubles from 0 through 1, a regular expression

Output: the string divided into segments proportionate to the doubles, with 
divisions allowed only by the regular expression

Related: strings, sequences

Used by function tan:segment-string(), tan:infuse-tree().

Relies upon tan:chop-string.

`tan:stamp-diff-with-text-data()`

tan:stamp-diff-with-text-data($diff-result as element(tan:diff)?) as item()*

Input: any output from tan:diff()

Output: each <diff> child stamped with @_len, @_pos-a, @_pos-b indicating length 
and the starting positions for a and b

This function produces output analogous to tan:stamp-tree-with-text-data()

Used by template ŧ tan:infuse-diff-and-collate-stats, ŧ tan:class-1-expansion-verbose-pass-1, ŧ diff-or-collate-to-html-output-pass-1.

Used by function tan:diff-a-map(), tan:get-diff-output-transpositions(), tan:replace-diff(), tan:chop-diff-output(), tan:get-diff-output-slices().

Relies upon ŧ tan:stamp-diff-with-text-data.

`tan:string-length()`

tan:string-length($input as xs:string?) as xs:integer

Input: any string

Output: the number of characters in the string, as defined by TAN (i.e., modifiers 
are counted with the preceding base character)

Used by template ŧ tan:split-diff-components-2.

Used by function tan:stamp-tree-with-text-data().

Relies upon tan:chop-string.

`tan:substring-after()`

tan:substring-after($arg1 as xs:string?, $arg2 as xs:string?, $return-first-match as xs:boolean) as xs:string

Input: two strings; a boolean

Output: if the last parameter is true: the substring of the value of $arg1 that 
follows in the value of $arg1 the first occurrence of the value of $arg2 . if false: the last 
occurrence

This function provides extra flexibility not available in fn:substring-before()

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:substring-before()`

tan:substring-before($arg1 as xs:string?, $arg2 as xs:string?, $return-first-match as xs:boolean) as xs:string

Input: two strings; a boolean

Output: if the last parameter is true: the substring of the value of $arg1 that 
precedes in the value of $arg1 the first occurrence of the value $arg2 . if false: the last 
occurrence

This function provides extra flexibility not available in fn:substring-before()

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:text-join()`

tan:text-join($items as item()*) as xs:string?

one-parameter version of the full function below

Used by template ŧ tan:text-join, ŧ tan:merge-divs, ŧ tan:class-1-expansion-verbose-pass-1.

Used by function tan:text-join().

Relies upon tan:text-join.

Option 2 (TAN-fn-strings-standard)

tan:text-join($items as item()*, $set-divs-on-new-line as xs:boolean) as xs:string?

Input: any document fragment of a TAN class 1 body, whether raw or resolved

Output: a single string that joins and normalizes the leaf div text according to TAN 
rules

All special leaf-div-end characters will be stripped including the last

Do not apply this function to class-1 files that have been expanded, because 
normalization will have already occurred.

Do not apply this function to TEI elements within leaf divs.

Related: strings, nodes

Used by template ŧ tan:text-join, ŧ tan:merge-divs, ŧ tan:class-1-expansion-verbose-pass-1.

Used by function tan:text-join().

Relies upon ŧ tan:text-join.

`tan:title-case()`

tan:title-case($string-to-convert as xs:string*) as xs:string*

Input: a sequence of strings

Output: each string set in title case, following the conventions of English (one of 
the only languages that bother with title-case)

According to Chicago rules of title casing, the first and last words are always 
capitalized, and interior words are capitalized unless they are a preposition or article

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:english-articles, $tan:english-prepositions, tan:initial-upper-case, ŧ tan:title-case.

`tan:tokenize-div()`

tan:tokenize-div($input as item()*, $token-definitions as element(tan:token-definition)) as item()*

Input: any items, a <token-definition>

Output: the items with <div>s in tokenized form

Related: strings

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:tokenize-div.

`tan:tokenize-text()`

tan:tokenize-text($text as xs:string*) as element()*

one-parameter version of the function below

Used by template ŧ tan:dependency-adjustments-pass-2, ŧ tan:mark-dependencies-for-validation, ŧ tan:tokenize-div, ŧ tan:mark-dependencies-pass-1, ŧ tan:dependency-expansion-normal, ŧ tan:dependency-expansion-verbose.

Used by function tan:tokenize-text().

Relies upon $tan:token-definition-default, tan:tokenize-text.

Option 2 (TAN-fn-strings-standard)

tan:tokenize-text($text as xs:string*, $token-definition as element(tan:token-definition)?, $count-toks as xs:boolean?) as element()*

three-parameter version of the function below

Used by function tan:tokenize-text().

Relies upon tan:tokenize-text.

Option 3 (TAN-fn-strings-standard)

tan:tokenize-text($text as xs:string*, $token-definition as element(tan:token-definition)?, $count-toks as xs:boolean?, $add-attr-q as xs:boolean?, $add-attr-pos as xs:boolean?) as element()*

Input: any number of strings; a <token-definition>; a boolean indicating whether 
tokens should be counted and labeled.

Output: a <result> for each string, tokenized into <tok> and <non-tok>, 
respectively. If the counting option is turned on, the <result> contains @tok-count and 
@non-tok-count, and each <tok> and <non-tok> have an @n indicating which <tok> group it belongs to.

Related: strings, sequences

Used by function tan:tokenize-text().

Relies upon $tan:token-definition-default, tan:tokenize-text(), ŧ tan:add-tok-pos, ŧ tan:first-stamp-shallow-copy.

`tan:unique-char()`

tan:unique-char($context-strings as xs:string*) as xs:string?

Input: any sequence of strings

Output: a single character that is not to be found in those strings

This function, written to support tan:collate-sequences(), provides unique way 
to join any sequence strings in such a way that it can later be tokenized.

Related: strings

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

Templates

`Ŧ tan:regex-group-count`

Related: strings, regular expressions

Input: perhaps a parameter specifying how many blank entries are permitted before 
stopping the iteration.

Output: the number of groups of regular expressions in the current context.

Most often in the TAN function library, a function is preferred over a named 
template. In this case, we have a named template, because the function severs the context of 
regex-groups()

Used by template ŧ tan:batch-replace-advanced-pass-1, ŧ tan:batch-replace-advanced-pass-2.

Does not rely upon global variables, keys, functions, or templates.

Time

Functions

`tan:get-doc-history()`

TAN-fn-time

tan:get-doc-history($TAN-doc as document-node()*) as element()*

Input: any TAN document

Output: a sequence of elements with @when, @ed-when, @accessed-when, 
@claim-when, sorted from most recent to least; each element includes @when-sort, a decimal that 
represents the value of the most recent time-date stamp in that element

Related: versioning

Used by variable $tan:doc-history.

Used by template ŧ tan:check-referred-doc, ŧ tan:core-expansion-normal.

Used by function tan:last-change-agent().

Relies upon ŧ tan:get-doc-history.

Uris

Functions

`tan:absolutize-hrefs()`

tan:absolutize-hrefs($items-to-resolve as item()*, $items-base-uri as xs:string) as item()*

Input: any items that should have urls converted to absolute URIs; a string 
representing the base uri

Output: the items with each @href (also in processing instructions) and html:*/src 
resolved against the input base uri

Related: uris, filenames, tree manipulation

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon ŧ tan:revise-hrefs.

`tan:base-uri()`

tan:base-uri($any-node as node()?) as xs:anyURI

Input: any node

Output: the base uri of the node's document

An explicit @xml:base has the highest priority over any native base-uri(). If the 
node is a fragment and has no declared or detected base uri, the static-base-uri() will be 
returned

Used by template ŧ tan:resolve-critical-dependencies-loop, ŧ tan:check-referred-doc, ŧ tan:resolve-href tan:expand-standard-tan-voc, ŧ tan:resolve-href tan:first-stamp-shallow-copy.

Used by function tan:lm-data(), tan:resolve-href(), tan:resolve-doc-loop(), tan:TAN-A-lm-hrefs(), tan:collection(), tan:catalog-uris(), tan:first-loc-available(), tan:attribute-vocabulary(), tan:cfn(), tan:cfne(), tan:get-1st-doc().

Does not rely upon global variables, keys, functions, or templates.

`tan:catalog-uris()`

tan:catalog-uris($input-node as node()?) as xs:string*

Input: a node from an XML file

Output: URLs for locally available TAN catalog files, beginning with the immediate 
subdirectory and proceeding rootward

Used by variable $tan:doc-catalog-uris.

Used by function tan:catalogs().

Relies upon tan:base-uri.

`tan:catalogs()`

tan:catalogs($input-node as node()?, $strip-bad-hrefs as xs:boolean) as document-node()*

Input: a node from an XML file; a boolean indicating whether bad @hrefs should be 
stripped

Output: the TAN catalog documents available, beginning with the most local path and 
proceeding rootward

Used by variable $tan:doc-catalogs.

Used by template ŧ tan:core-expansion-verbose.

Used by function tan:get-1st-doc().

Relies upon tan:catalog-uris, ŧ tan:cut-faulty-hrefs.

`tan:cfn()`

tan:cfn($item as item()*) as xs:string*

Input: any items

Output: the Current File Name, without extension, of the host document node of each 
item, or of the input string if detected as a uri

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:base-uri, tan:cfne.

`tan:cfne()`

tan:cfne($item as item()*) as xs:string*

Input: any items

Output: the Current File Name, with Extension, of the host document node of each 
item, or of the input string if detected as a uri

Option 1 (TAN-fn-uris-standard)

Used by variable $tan:doc-filename.

Used by function tan:cfn().

Relies upon tan:base-uri.

`tan:collection()`

tan:collection($catalog-docs as document-node()*) as document-node()*

One-parameter version of the master one, below

Used by template ŧ tan:core-expansion-verbose.

Used by function tan:collection().

Relies upon tan:collection.

Option 2 (TAN-fn-uris-standard)

tan:collection($catalog-docs as document-node()*, $root-names as xs:string*, $id-matches as xs:string?, $href-matches as xs:string?) as document-node()*

Input: one or more catalog.tan.xml files; filtering parameters

Output: documents that are available

Related: uris, filenames

Used by template ŧ tan:core-expansion-verbose.

Used by function tan:collection().

Relies upon tan:base-uri.

`tan:doc-available()`

tan:doc-available($uri as xs:string?) as xs:boolean

Input: a string

Output: true if an XML document is available at the URI, false otherwise

This is a surrogate function to fn:doc-available, and behaves exactly the same, but 
avoids the possibility of read conflicts, so a file can be overwritten.

An alternative to this is to make sure that when writing a secondary result document 
the last / is doubled; the string will not be recognized as a duplicate of what was read.

Related: files, uris

No variables, keys, functions, or named templates depend upon this xsl:function.

Does not rely upon global variables, keys, functions, or templates.

`tan:get-uuid()`

Option 1 (TAN-fn-uris-extended)

tan:get-uuid()

zero-param version of the full one below

Used by function tan:get-uuid().

Relies upon tan:get-uuid.

Option 2 (TAN-fn-uris-extended)

tan:get-uuid($quantity as xs:integer) as xs:string*

Input: a digit

Output: that digit's quantity of UUIDs

Code courtesy D. Novatchev, 
https://stackoverflow.com/questions/8126963/xslt-generate-uuid/64792196#64792196

Related: uris

Used by function tan:get-uuid().

Does not rely upon global variables, keys, functions, or templates.

`tan:is-valid-uri()`

tan:is-valid-uri($uri-to-check as xs:string?) as xs:boolean?

Input: a string

Output: a boolean indicating whether the string is syntactically a valid uri

This assumes not only absolute but relative uris will be checked, which means that a 
wide variety of characters could be fed in, but not ones disallowed in pathnames, and the 
string must not be zero length.

Used by function tan:uri-relative-to().

Does not rely upon global variables, keys, functions, or templates.

`tan:parse-urls()`

tan:parse-urls($input-strings as xs:string*) as element()*

Input: any sequence of strings

Output: one element per string, parsed into children <non-url> and <url>

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon $tan:url-regex.

`tan:relativize-hrefs()`

tan:relativize-hrefs($input-items as item()*, $target-base-uri-resolved as xs:string) as item()*

Input: any items; a resolved base uri (target)

Output: the items, with links in standard attributes such as @href changed so as to be 
relative to the target base uri.

This function is intended to serve output that is going to a particular destination, 
and that needs to have links to nearby resources revised to their relative form.

Related: uris, filenames, tree manipulation

No variables, keys, functions, or named templates depend upon this xsl:function.

Relies upon tan:uri-is-relative, ŧ tan:relativize-hrefs.

`tan:revise-hrefs()`

tan:revise-hrefs($items-to-resolve as item()?, $items-original-url as xs:string, $items-destination-url as xs:string) as item()*

Input: an item that should have urls resolved; the original url of the item; the 
target url (the item's destination)

Output: the item with each @href (including those in processing instructions) and 
html:*/@src resolved

Related: uris, filenames, tree manipulation

Used by function tan:revise-hrefs().

Relies upon tan:revise-hrefs(), ŧ tan:revise-hrefs.

`tan:uri-collection-from-pattern()`

tan:uri-collection-from-pattern($resolved-patterned-uri as xs:string?) as xs:anyURI*

Input: a string representing a resolved uri, with patterns

Output: a uri collection based on the string as an input pattern

This function was written to support glob-like patterns for files.

Used by function tan:uri-collection-from-pattern().

Relies upon tan:glob-to-regex, tan:uri-collection-from-pattern().

`tan:uri-directory()`

tan:uri-directory($uris as xs:string*) as xs:string*

Input: any URIs, as strings

Output: the file path

NB, this function does not assume any URIs have been resolved; its only action is 
syntactic, ensuring that each URI specifies a directory path, i.e., has a trailing slash.

Used by variable $tan:doc-parent-directory.

Does not rely upon global variables, keys, functions, or templates.

`tan:uri-is-relative()`

tan:uri-is-relative($uri-to-test as xs:string?) as xs:boolean?

Input: a string representing a URI

Output: a boolean indicating whether it is relative

Used by function tan:relativize-hrefs().

Relies upon tan:uri-is-resolved.

`tan:uri-is-resolved()`

tan:uri-is-resolved($uri-to-test as xs:string?) as xs:boolean?

Input: a string representing a URI

Output: a boolean indicating whether it is resolved