1451     <xsl:text>    fields: [],

  1452 </xsl:text>

  1453   </xsl:template>

  1454   <preamble:display/>

  1455   <xsl:template match="preamble:display">

  1456     <xsl:text>

  1457 </xsl:text>

  1458     <xsl:text>/* </xsl:text>

  1459     <xsl:value-of select="local-name()"/>

  1460     <xsl:text> */

  1461 </xsl:text>

  1462     <xsl:text>

  1463 </xsl:text>

  1464     <xsl:text>/* https://github.com/alexei/sprintf.js/blob/master/src/sprintf.js */

  1465 </xsl:text>

  1466     <xsl:text>/* global window, exports, define */

  1467 </xsl:text>

  1468     <xsl:text>

  1469 </xsl:text>

  1470     <xsl:text>!function() {

  1471 </xsl:text>

  1472     <xsl:text>    'use strict'

  1473 </xsl:text>

  1474     <xsl:text>

  1475 </xsl:text>

  1476     <xsl:text>    var re = {

  1477 </xsl:text>

  1478     <xsl:text>        not_string: /[^s]/,

  1479 </xsl:text>

  1480     <xsl:text>        not_bool: /[^t]/,

  1481 </xsl:text>

  1482     <xsl:text>        not_type: /[^T]/,

  1483 </xsl:text>

  1484     <xsl:text>        not_primitive: /[^v]/,

  1485 </xsl:text>

  1486     <xsl:text>        number: /[diefg]/,

  1487 </xsl:text>

  1488     <xsl:text>        numeric_arg: /[bcdiefguxX]/,

  1489 </xsl:text>

  1490     <xsl:text>        json: /[j]/,

  1491 </xsl:text>

  1492     <xsl:text>        not_json: /[^j]/,

  1493 </xsl:text>

  1494     <xsl:text>        text: /^[^%]+/,

  1495 </xsl:text>

  1496     <xsl:text>        modulo: /^%{2}/,

  1497 </xsl:text>

  1498     <xsl:text>        placeholder: /^%(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,

  1499 </xsl:text>

  1500     <xsl:text>        key: /^([a-z_][a-z_\d]*)/i,

  1501 </xsl:text>

  1502     <xsl:text>        key_access: /^\.([a-z_][a-z_\d]*)/i,

  1503 </xsl:text>

  1504     <xsl:text>        index_access: /^\[(\d+)\]/,

  1505 </xsl:text>

  1506     <xsl:text>        sign: /^[+-]/

  1507 </xsl:text>

  1508     <xsl:text>    }

  1509 </xsl:text>

  1510     <xsl:text>

  1511 </xsl:text>

  1512     <xsl:text>    function sprintf(key) {

  1513 </xsl:text>

  1514     <xsl:text>        // </xsl:text>

  1515     <arguments/>

  1516     <xsl:text> is not an array, but should be fine for this call

  1517 </xsl:text>

  1518     <xsl:text>        return sprintf_format(sprintf_parse(key), arguments)

  1519 </xsl:text>

  1520     <xsl:text>    }

  1521 </xsl:text>

  1522     <xsl:text>

  1523 </xsl:text>

  1524     <xsl:text>    function vsprintf(fmt, argv) {

  1525 </xsl:text>

  1526     <xsl:text>        return sprintf.apply(null, [fmt].concat(argv || []))

  1527 </xsl:text>

  1528     <xsl:text>    }

  1529 </xsl:text>

  1530     <xsl:text>

  1531 </xsl:text>

  1532     <xsl:text>    function sprintf_format(parse_tree, argv) {

  1533 </xsl:text>

  1534     <xsl:text>        var cursor = 1, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign

  1535 </xsl:text>

  1536     <xsl:text>        for (i = 0; i &lt; tree_length; i++) {

  1537 </xsl:text>

  1538     <xsl:text>            if (typeof parse_tree[i] === 'string') {

  1539 </xsl:text>

  1540     <xsl:text>                output += parse_tree[i]

  1541 </xsl:text>

  1542     <xsl:text>            }

  1543 </xsl:text>

  1544     <xsl:text>            else if (typeof parse_tree[i] === 'object') {

  1545 </xsl:text>

  1546     <xsl:text>                ph = parse_tree[i] // convenience purposes only

  1547 </xsl:text>

  1548     <xsl:text>                if (ph.keys) { // keyword argument

  1549 </xsl:text>

  1550     <xsl:text>                    arg = argv[cursor]

  1551 </xsl:text>

  1552     <xsl:text>                    for (k = 0; k &lt; ph.keys.length; k++) {

  1553 </xsl:text>

  1554     <xsl:text>                        if (arg == undefined) {

  1555 </xsl:text>

  1556     <xsl:text>                            throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k-1]))

  1557 </xsl:text>

  1558     <xsl:text>                        }

  1559 </xsl:text>

  1560     <xsl:text>                        arg = arg[ph.keys[k]]

  1561 </xsl:text>

  1562     <xsl:text>                    }

  1563 </xsl:text>

  1564     <xsl:text>                }

  1565 </xsl:text>

  1566     <xsl:text>                else if (ph.param_no) { // positional argument (explicit)

  1567 </xsl:text>

  1568     <xsl:text>                    arg = argv[ph.param_no]

  1569 </xsl:text>

  1570     <xsl:text>                }

  1571 </xsl:text>

  1572     <xsl:text>                else { // positional argument (implicit)

  1573 </xsl:text>

  1574     <xsl:text>                    arg = argv[cursor++]

  1575 </xsl:text>

  1576     <xsl:text>                }

  1577 </xsl:text>

  1578     <xsl:text>

  1579 </xsl:text>

  1580     <xsl:text>                if (re.not_type.test(ph.type) &amp;&amp; re.not_primitive.test(ph.type) &amp;&amp; arg instanceof Function) {

  1581 </xsl:text>

  1582     <xsl:text>                    arg = arg()

  1583 </xsl:text>

  1584     <xsl:text>                }

  1585 </xsl:text>

  1586     <xsl:text>

  1587 </xsl:text>

  1588     <xsl:text>                if (re.numeric_arg.test(ph.type) &amp;&amp; (typeof arg !== 'number' &amp;&amp; isNaN(arg))) {

  1589 </xsl:text>

  1590     <xsl:text>                    throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))

  1591 </xsl:text>

  1592     <xsl:text>                }

  1593 </xsl:text>

  1594     <xsl:text>

  1595 </xsl:text>

  1596     <xsl:text>                if (re.number.test(ph.type)) {

  1597 </xsl:text>

  1598     <xsl:text>                    is_positive = arg &gt;= 0

  1599 </xsl:text>

  1600     <xsl:text>                }

  1601 </xsl:text>

  1602     <xsl:text>

  1603 </xsl:text>

  1604     <xsl:text>                switch (ph.type) {

  1605 </xsl:text>

  1606     <xsl:text>                    case 'b':

  1607 </xsl:text>

  1608     <xsl:text>                        arg = parseInt(arg, 10).toString(2)

  1609 </xsl:text>

  1610     <xsl:text>                        break

  1611 </xsl:text>

  1612     <xsl:text>                    case 'c':

  1613 </xsl:text>

  1614     <xsl:text>                        arg = String.fromCharCode(parseInt(arg, 10))

  1615 </xsl:text>

  1616     <xsl:text>                        break

  1617 </xsl:text>

  1618     <xsl:text>                    case 'd':

  1619 </xsl:text>

  1620     <xsl:text>                    case 'i':

  1621 </xsl:text>

  1622     <xsl:text>                        arg = parseInt(arg, 10)

  1623 </xsl:text>

  1624     <xsl:text>                        break

  1625 </xsl:text>

  1626     <xsl:text>                    case 'j':

  1627 </xsl:text>

  1628     <xsl:text>                        arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)

  1629 </xsl:text>

  1630     <xsl:text>                        break

  1631 </xsl:text>

  1632     <xsl:text>                    case 'e':

  1633 </xsl:text>

  1634     <xsl:text>                        arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()

  1635 </xsl:text>

  1636     <xsl:text>                        break

  1637 </xsl:text>

  1638     <xsl:text>                    case 'f':

  1639 </xsl:text>

  1640     <xsl:text>                        arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)

  1641 </xsl:text>

  1642     <xsl:text>                        break

  1643 </xsl:text>

  1644     <xsl:text>                    case 'g':

  1645 </xsl:text>

  1646     <xsl:text>                        arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)

  1647 </xsl:text>

  1648     <xsl:text>                        break

  1649 </xsl:text>

  1650     <xsl:text>                    case 'o':

  1651 </xsl:text>

  1652     <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(8)

  1653 </xsl:text>

  1654     <xsl:text>                        break

  1655 </xsl:text>

  1656     <xsl:text>                    case 's':

  1657 </xsl:text>

  1658     <xsl:text>                        arg = String(arg)

  1659 </xsl:text>

  1660     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

  1661 </xsl:text>

  1662     <xsl:text>                        break

  1663 </xsl:text>

  1664     <xsl:text>                    case 't':

  1665 </xsl:text>

  1666     <xsl:text>                        arg = String(!!arg)

  1667 </xsl:text>

  1668     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

  1669 </xsl:text>

  1670     <xsl:text>                        break

  1671 </xsl:text>

  1672     <xsl:text>                    case 'T':

  1673 </xsl:text>

  1674     <xsl:text>                        arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()

  1675 </xsl:text>

  1676     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

  1677 </xsl:text>

  1678     <xsl:text>                        break

  1679 </xsl:text>

  1680     <xsl:text>                    case 'u':

  1681 </xsl:text>

  1682     <xsl:text>                        arg = parseInt(arg, 10) &gt;&gt;&gt; 0

  1683 </xsl:text>

  1684     <xsl:text>                        break

  1685 </xsl:text>

  1686     <xsl:text>                    case 'v':

  1687 </xsl:text>

  1688     <xsl:text>                        arg = arg.valueOf()

  1689 </xsl:text>

  1690     <xsl:text>                        arg = (ph.precision ? arg.substring(0, ph.precision) : arg)

  1691 </xsl:text>

  1692     <xsl:text>                        break

  1693 </xsl:text>

  1694     <xsl:text>                    case 'x':

  1695 </xsl:text>

  1696     <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(16)

  1697 </xsl:text>

  1698     <xsl:text>                        break

  1699 </xsl:text>

  1700     <xsl:text>                    case 'X':

  1701 </xsl:text>

  1702     <xsl:text>                        arg = (parseInt(arg, 10) &gt;&gt;&gt; 0).toString(16).toUpperCase()

  1703 </xsl:text>

  1704     <xsl:text>                        break

  1705 </xsl:text>

  1706     <xsl:text>                }

  1707 </xsl:text>

  1708     <xsl:text>                if (re.json.test(ph.type)) {

  1709 </xsl:text>

  1710     <xsl:text>                    output += arg

  1711 </xsl:text>

  1712     <xsl:text>                }

  1713 </xsl:text>

  1714     <xsl:text>                else {

  1715 </xsl:text>

  1716     <xsl:text>                    if (re.number.test(ph.type) &amp;&amp; (!is_positive || ph.sign)) {

  1717 </xsl:text>

  1718     <xsl:text>                        sign = is_positive ? '+' : '-'

  1719 </xsl:text>

  1720     <xsl:text>                        arg = arg.toString().replace(re.sign, '')

  1721 </xsl:text>

  1722     <xsl:text>                    }

  1723 </xsl:text>

  1724     <xsl:text>                    else {

  1725 </xsl:text>

  1726     <xsl:text>                        sign = ''

  1727 </xsl:text>

  1728     <xsl:text>                    }

  1729 </xsl:text>

  1730     <xsl:text>                    pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '

  1731 </xsl:text>

  1732     <xsl:text>                    pad_length = ph.width - (sign + arg).length

  1733 </xsl:text>

  1734     <xsl:text>                    pad = ph.width ? (pad_length &gt; 0 ? pad_character.repeat(pad_length) : '') : ''

  1735 </xsl:text>

  1736     <xsl:text>                    output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)

  1737 </xsl:text>

  1738     <xsl:text>                }

  1739 </xsl:text>

  1740     <xsl:text>            }

  1741 </xsl:text>

  1742     <xsl:text>        }

  1743 </xsl:text>

  1744     <xsl:text>        return output

  1745 </xsl:text>

  1746     <xsl:text>    }

  1747 </xsl:text>

  1748     <xsl:text>

  1749 </xsl:text>

  1750     <xsl:text>    var sprintf_cache = Object.create(null)

  1751 </xsl:text>

  1752     <xsl:text>

  1753 </xsl:text>

  1754     <xsl:text>    function sprintf_parse(fmt) {

  1755 </xsl:text>

  1756     <xsl:text>        if (sprintf_cache[fmt]) {

  1757 </xsl:text>

  1758     <xsl:text>            return sprintf_cache[fmt]

  1759 </xsl:text>

  1760     <xsl:text>        }

  1761 </xsl:text>

  1762     <xsl:text>

  1763 </xsl:text>

  1764     <xsl:text>        var _fmt = fmt, match, parse_tree = [], arg_names = 0

  1765 </xsl:text>

  1766     <xsl:text>        while (_fmt) {

  1767 </xsl:text>

  1768     <xsl:text>            if ((match = re.text.exec(_fmt)) !== null) {

  1769 </xsl:text>

  1770     <xsl:text>                parse_tree.push(match[0])

  1771 </xsl:text>

  1772     <xsl:text>            }

  1773 </xsl:text>

  1774     <xsl:text>            else if ((match = re.modulo.exec(_fmt)) !== null) {

  1775 </xsl:text>

  1776     <xsl:text>                parse_tree.push('%')

  1777 </xsl:text>

  1778     <xsl:text>            }

  1779 </xsl:text>

  1780     <xsl:text>            else if ((match = re.placeholder.exec(_fmt)) !== null) {

  1781 </xsl:text>

  1782     <xsl:text>                if (match[2]) {

  1783 </xsl:text>

  1784     <xsl:text>                    arg_names |= 1

  1785 </xsl:text>

  1786     <xsl:text>                    var field_list = [], replacement_field = match[2], field_match = []

  1787 </xsl:text>

  1788     <xsl:text>                    if ((field_match = re.key.exec(replacement_field)) !== null) {

  1789 </xsl:text>

  1790     <xsl:text>                        field_list.push(field_match[1])

  1791 </xsl:text>

  1792     <xsl:text>                        while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {

  1793 </xsl:text>

  1794     <xsl:text>                            if ((field_match = re.key_access.exec(replacement_field)) !== null) {

  1795 </xsl:text>

  1796     <xsl:text>                                field_list.push(field_match[1])

  1797 </xsl:text>

  1798     <xsl:text>                            }

  1799 </xsl:text>

  1800     <xsl:text>                            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {

  1801 </xsl:text>

  1802     <xsl:text>                                field_list.push(field_match[1])

  1803 </xsl:text>

  1804     <xsl:text>                            }

  1805 </xsl:text>

  1806     <xsl:text>                            else {

  1807 </xsl:text>

  1808     <xsl:text>                                throw new SyntaxError('[sprintf] failed to parse named argument key')

  1809 </xsl:text>

  1810     <xsl:text>                            }

  1811 </xsl:text>

  1812     <xsl:text>                        }

  1813 </xsl:text>

  1814     <xsl:text>                    }

  1815 </xsl:text>

  1816     <xsl:text>                    else {

  1817 </xsl:text>

  1818     <xsl:text>                        throw new SyntaxError('[sprintf] failed to parse named argument key')

  1819 </xsl:text>

  1820     <xsl:text>                    }

  1821 </xsl:text>

  1822     <xsl:text>                    match[2] = field_list

  1823 </xsl:text>

  1824     <xsl:text>                }

  1825 </xsl:text>

  1826     <xsl:text>                else {

  1827 </xsl:text>

  1828     <xsl:text>                    arg_names |= 2

  1829 </xsl:text>

  1830     <xsl:text>                }

  1831 </xsl:text>

  1832     <xsl:text>                if (arg_names === 3) {

  1833 </xsl:text>

  1834     <xsl:text>                    throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')

  1835 </xsl:text>

  1836     <xsl:text>                }

  1837 </xsl:text>

  1838     <xsl:text>

  1839 </xsl:text>

  1840     <xsl:text>                parse_tree.push(

  1841 </xsl:text>

  1842     <xsl:text>                    {

  1843 </xsl:text>

  1844     <xsl:text>                        placeholder: match[0],

  1845 </xsl:text>

  1846     <xsl:text>                        param_no:    match[1],

  1847 </xsl:text>

  1848     <xsl:text>                        keys:        match[2],

  1849 </xsl:text>

  1850     <xsl:text>                        sign:        match[3],

  1851 </xsl:text>

  1852     <xsl:text>                        pad_char:    match[4],

  1853 </xsl:text>

  1854     <xsl:text>                        align:       match[5],

  1855 </xsl:text>

  1856     <xsl:text>                        width:       match[6],

  1857 </xsl:text>

  1858     <xsl:text>                        precision:   match[7],

  1859 </xsl:text>

  1860     <xsl:text>                        type:        match[8]

  1861 </xsl:text>

  1862     <xsl:text>                    }

  1863 </xsl:text>

  1864     <xsl:text>                )

  1865 </xsl:text>

  1866     <xsl:text>            }

  1867 </xsl:text>

  1868     <xsl:text>            else {

  1869 </xsl:text>

  1870     <xsl:text>                throw new SyntaxError('[sprintf] unexpected placeholder')

  1871 </xsl:text>

  1872     <xsl:text>            }

  1873 </xsl:text>

  1874     <xsl:text>            _fmt = _fmt.substring(match[0].length)

  1875 </xsl:text>

  1876     <xsl:text>        }

  1877 </xsl:text>

  1878     <xsl:text>        return sprintf_cache[fmt] = parse_tree

  1879 </xsl:text>

  1880     <xsl:text>    }

  1881 </xsl:text>

  1882     <xsl:text>

  1883 </xsl:text>

  1884     <xsl:text>    /**

  1885 </xsl:text>

  1886     <xsl:text>     * export to either browser or node.js

  1887 </xsl:text>

  1888     <xsl:text>     */

  1889 </xsl:text>

  1890     <xsl:text>    /* eslint-disable quote-props */

  1891 </xsl:text>

  1892     <xsl:text>    if (typeof exports !== 'undefined') {

  1893 </xsl:text>

  1894     <xsl:text>        exports['sprintf'] = sprintf

  1895 </xsl:text>

  1896     <xsl:text>        exports['vsprintf'] = vsprintf

  1897 </xsl:text>

  1898     <xsl:text>    }

  1899 </xsl:text>

  1900     <xsl:text>    if (typeof window !== 'undefined') {

  1901 </xsl:text>

  1902     <xsl:text>        window['sprintf'] = sprintf

  1903 </xsl:text>

  1904     <xsl:text>        window['vsprintf'] = vsprintf

  1905 </xsl:text>

  1906     <xsl:text>

  1907 </xsl:text>

  1908     <xsl:text>        if (typeof define === 'function' &amp;&amp; define['amd']) {

  1909 </xsl:text>

  1910     <xsl:text>            define(function() {

  1911 </xsl:text>

  1912     <xsl:text>                return {

  1913 </xsl:text>

  1914     <xsl:text>                    'sprintf': sprintf,

  1915 </xsl:text>

  1916     <xsl:text>                    'vsprintf': vsprintf

  1917 </xsl:text>

  1918     <xsl:text>                }

  1919 </xsl:text>

  1920     <xsl:text>            })

  1921 </xsl:text>

  1922     <xsl:text>        }

  1923 </xsl:text>

  1924     <xsl:text>    }

  1925 </xsl:text>

  1926     <xsl:text>    /* eslint-enable quote-props */

  1927 </xsl:text>

  1928     <xsl:text>}(); // eslint-disable-line    

  1929 </xsl:text>

  1930     <xsl:text>

  1931 </xsl:text>