Source: lib/util/tXml.js

  1. /*! @license
  2.  * tXml
  3.  * Copyright 2015 Tobias Nickel
  4.  * SPDX-License-Identifier: MIT
  5.  */
  7. goog.provide('shaka.util.TXml');
  9. goog.require('shaka.util.ObjectUtils');
  10. goog.require('shaka.util.StringUtils');
  11. goog.require('shaka.log');
  13. /**
  14.  * This code is a modified version of the tXml library.
  15.  *
  16.  * @author: Tobias Nickel
  17.  * created: 06.04.2015
  18.  * https://github.com/TobiasNickel/tXml
  19.  */
  21. /**
  22.  * Permission is hereby granted, free of charge, to any person obtaining a copy
  23.  * of this software and associated documentation files (the "Software"), to deal
  24.  * in the Software without restriction, including without limitation the rights
  25.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  26.  * copies of the Software, and to permit persons to whom the Software is
  27.  * furnished to do so, subject to the following conditions:
  28.  *
  29.  * The above copyright notice and this permission notice shall be included in
  30.  * all copies or substantial portions of the Software.
  31.  *
  32.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  33.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  34.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  35.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  36.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  37.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  38.  * SOFTWARE.
  39.  */
  42. shaka.util.TXml = class {
  43.   /**
  44.    * Parse some data
  45.    * @param {BufferSource} data
  46.    * @param {string=} expectedRootElemName
  47.    * @param {boolean=} includeParent
  48.    * @return {shaka.extern.xml.Node | null}
  49.    */
  50.   static parseXml(data, expectedRootElemName, includeParent = false) {
  51.     const xmlString = shaka.util.StringUtils.fromBytesAutoDetect(data);
  52.     return shaka.util.TXml.parseXmlString(
  53.         xmlString, expectedRootElemName, includeParent);
  54.   }
  56.   /**
  57.    * Parse some data
  58.    * @param {string} xmlString
  59.    * @param {string=} expectedRootElemName
  60.    * @return {shaka.extern.xml.Node | null}
  61.    */
  62.   static parseXmlString(xmlString, expectedRootElemName,
  63.       includeParent = false) {
  64.     const result = shaka.util.TXml.parse(xmlString, includeParent);
  65.     if (!expectedRootElemName && result.length) {
  66.       return result[0];
  67.     }
  68.     const rootNode = result.find((n) =>
  69.       expectedRootElemName.split(',').includes(n.tagName));
  70.     if (rootNode) {
  71.       return rootNode;
  72.     }
  74.     shaka.log.error('parseXml root element not found!');
  75.     return null;
  76.   }
  78.   /**
  79.    * Get namespace based on schema
  80.    * @param {string} schema
  81.    * @return {string}
  82.    */
  83.   static getKnownNameSpace(schema) {
  84.     if (shaka.util.TXml.uriToNameSpace_.has(schema)) {
  85.       return shaka.util.TXml.uriToNameSpace_.get(schema);
  86.     }
  87.     return '';
  88.   }
  90.   /**
  91.    * Get schema based on namespace
  92.    * @param {string} NS
  93.    * @return {string}
  94.    */
  95.   static getKnownSchema(NS) {
  96.     if (shaka.util.TXml.nameSpaceToUri_.has(NS)) {
  97.       return shaka.util.TXml.nameSpaceToUri_.get(NS);
  98.     }
  99.     return '';
  100.   }
  102.   /**
  103.    * Sets NS <-> schema bidirectional mapping
  104.    * @param {string} schema
  105.    * @param {string} NS
  106.    */
  107.   static setKnownNameSpace(schema, NS) {
  108.     shaka.util.TXml.uriToNameSpace_.set(schema, NS);
  109.     shaka.util.TXml.nameSpaceToUri_.set(NS, schema);
  110.   }
  112.   /**
  113.    * parseXML / html into a DOM Object,
  114.    * with no validation and some failure tolerance
  115.    * @param {string} S your XML to parse
  116.    * @param {boolean} includeParent
  117.    * @return {Array.<shaka.extern.xml.Node>}
  118.    */
  119.   static parse(S, includeParent) {
  120.     let pos = 0;
  122.     const openBracket = '<';
  123.     const openBracketCC = '<'.charCodeAt(0);
  124.     const closeBracket = '>';
  125.     const closeBracketCC = '>'.charCodeAt(0);
  126.     const minusCC = '-'.charCodeAt(0);
  127.     const slashCC = '/'.charCodeAt(0);
  128.     const exclamationCC = '!'.charCodeAt(0);
  129.     const singleQuoteCC = '\''.charCodeAt(0);
  130.     const doubleQuoteCC = '"'.charCodeAt(0);
  131.     const openCornerBracketCC = '['.charCodeAt(0);
  133.     /**
  134.      * parsing a list of entries
  135.      */
  136.     function parseChildren(tagName, preserveSpace = false) {
  137.       /** @type {Array.<shaka.extern.xml.Node | string>} */
  138.       const children = [];
  139.       while (S[pos]) {
  140.         if (S.charCodeAt(pos) == openBracketCC) {
  141.           if (S.charCodeAt(pos + 1) === slashCC) {
  142.             const closeStart = pos + 2;
  143.             pos = S.indexOf(closeBracket, pos);
  145.             const closeTag = S.substring(closeStart, pos);
  146.             let indexOfCloseTag = closeTag.indexOf(tagName);
  147.             if (indexOfCloseTag == -1) {
  148.               // handle VTT closing tags like <c.lime></c>
  149.               const indexOfPeriod = tagName.indexOf('.');
  150.               if (indexOfPeriod > 0) {
  151.                 const shortTag = tagName.substring(0, indexOfPeriod);
  152.                 indexOfCloseTag = closeTag.indexOf(shortTag);
  153.               }
  154.             }
  155.             // eslint-disable-next-line no-restricted-syntax
  156.             if (indexOfCloseTag == -1) {
  157.               const parsedText = S.substring(0, pos).split('\n');
  158.               throw new Error(
  159.                   'Unexpected close tag\nLine: ' + (parsedText.length - 1) +
  160.                             '\nColumn: ' +
  161.                             (parsedText[parsedText.length - 1].length + 1) +
  162.                             '\nChar: ' + S[pos],
  163.               );
  164.             }
  166.             if (pos + 1) {
  167.               pos += 1;
  168.             }
  170.             return children;
  171.           } else if (S.charCodeAt(pos + 1) === exclamationCC) {
  172.             if (S.charCodeAt(pos + 2) == minusCC) {
  173.               while (pos !== -1 && !(S.charCodeAt(pos) === closeBracketCC &&
  174.                   S.charCodeAt(pos - 1) == minusCC &&
  175.                   S.charCodeAt(pos - 2) == minusCC &&
  176.                   pos != -1)) {
  177.                 pos = S.indexOf(closeBracket, pos + 1);
  178.               }
  179.               if (pos === -1) {
  180.                 pos = S.length;
  181.               }
  182.             } else if (
  183.               S.charCodeAt(pos + 2) === openCornerBracketCC &&
  184.                         S.charCodeAt(pos + 8) === openCornerBracketCC &&
  185.                         S.substr(pos + 3, 5).toLowerCase() === 'cdata'
  186.             ) {
  187.               // cdata
  188.               const cdataEndIndex = S.indexOf(']]>', pos);
  189.               if (cdataEndIndex == -1) {
  190.                 children.push(S.substr(pos + 9));
  191.                 pos = S.length;
  192.               } else {
  193.                 children.push(S.substring(pos + 9, cdataEndIndex));
  194.                 pos = cdataEndIndex + 3;
  195.               }
  196.               continue;
  197.             }
  198.             pos++;
  199.             continue;
  200.           }
  201.           const node = parseNode(preserveSpace);
  202.           children.push(node);
  203.           if (typeof node === 'string') {
  204.             return children;
  205.           }
  206.           if (node.tagName[0] === '?' && node.children) {
  207.             children.push(...node.children);
  208.             node.children = [];
  209.           }
  210.         } else {
  211.           const text = parseText();
  212.           if (preserveSpace) {
  213.             if (text.length > 0) {
  214.               children.push(text);
  215.             }
  216.           } else if (children.length &&
  217.               text.length == 1 && text[0] == '\n') {
  218.             children.push(text);
  219.           } else {
  220.             const trimmed = text.trim();
  221.             if (trimmed.length > 0) {
  222.               children.push(text);
  223.             }
  224.           }
  225.           pos++;
  226.         }
  227.       }
  228.       return children;
  229.     }
  231.     /**
  232.      *    returns the text outside of texts until the first '<'
  233.      */
  234.     function parseText() {
  235.       const start = pos;
  236.       pos = S.indexOf(openBracket, pos) - 1;
  237.       if (pos === -2) {
  238.         pos = S.length;
  239.       }
  240.       return S.slice(start, pos + 1);
  241.     }
  242.     /**
  243.      *    returns text until the first nonAlphabetic letter
  244.      */
  245.     const nameSpacer = '\r\n\t>/= ';
  247.     /**
  248.      * Parse text in current context
  249.      * @return {string}
  250.      */
  251.     function parseName() {
  252.       const start = pos;
  253.       while (nameSpacer.indexOf(S[pos]) === -1 && S[pos]) {
  254.         pos++;
  255.       }
  256.       return S.slice(start, pos);
  257.     }
  259.     /**
  260.      * Parse text in current context
  261.      * @param {boolean} preserveSpace Preserve the space between nodes
  262.      * @return {shaka.extern.xml.Node | string}
  263.      */
  264.     function parseNode(preserveSpace) {
  265.       pos++;
  266.       const tagName = parseName();
  267.       const attributes = {};
  268.       let children = [];
  270.       // parsing attributes
  271.       while (S.charCodeAt(pos) !== closeBracketCC && S[pos]) {
  272.         const c = S.charCodeAt(pos);
  273.         // abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
  274.         if ((c > 64 && c < 91) || (c > 96 && c < 123)) {
  275.           const name = parseName();
  276.           // search beginning of the string
  277.           let code = S.charCodeAt(pos);
  278.           while (code && code !== singleQuoteCC && code !== doubleQuoteCC &&
  279.                 !((code > 64 && code < 91) || (code > 96 && code < 123)) &&
  280.                 code !== closeBracketCC) {
  281.             pos++;
  282.             code = S.charCodeAt(pos);
  283.           }
  284.           let value = parseString();
  285.           if (code === singleQuoteCC || code === doubleQuoteCC) {
  286.             if (pos === -1) {
  287.               /** @type {shaka.extern.xml.Node} */
  288.               const node = {
  289.                 tagName,
  290.                 attributes,
  291.                 children,
  292.                 parent: null,
  293.               };
  294.               if (includeParent) {
  295.                 for (let i = 0; i < children.length; i++) {
  296.                   if (typeof children[i] !== 'string') {
  297.                     children[i].parent = node;
  298.                   }
  299.                 }
  300.               }
  301.               return node;
  302.             }
  303.           } else {
  304.             value = null;
  305.             pos--;
  306.           }
  307.           if (name.startsWith('xmlns:')) {
  308.             const segs = name.split(':');
  309.             shaka.util.TXml.setKnownNameSpace(
  310.                 /** @type {string} */ (value), segs[1]);
  311.           }
  312.           if (tagName === 'tt' &&
  313.               name === 'xml:space' &&
  314.               value === 'preserve') {
  315.             preserveSpace = true;
  316.           }
  317.           attributes[name] = value;
  318.         }
  319.         pos++;
  320.       }
  322.       if (S.charCodeAt(pos - 1) !== slashCC) {
  323.         pos++;
  324.         const contents = parseChildren(tagName, preserveSpace);
  325.         children = contents;
  326.       } else {
  327.         pos++;
  328.       }
  329.       /** @type {shaka.extern.xml.Node} */
  330.       const node = {
  331.         tagName,
  332.         attributes,
  333.         children,
  334.         parent: null,
  335.       };
  336.       const childrenLength = children.length;
  337.       for (let i = 0; i < childrenLength; i++) {
  338.         const childrenValue = children[i];
  339.         if (typeof childrenValue !== 'string') {
  340.           if (includeParent) {
  341.             childrenValue.parent = node;
  342.           }
  343.         } else if (i == childrenLength - 1 && childrenValue == '\n') {
  344.           children.pop();
  345.         }
  346.       }
  347.       return node;
  348.     }
  350.     /**
  351.      * Parse string in current context
  352.      * @return {string}
  353.      */
  354.     function parseString() {
  355.       const startChar = S[pos];
  356.       const startpos = pos + 1;
  357.       pos = S.indexOf(startChar, startpos);
  358.       return S.slice(startpos, pos);
  359.     }
  361.     return parseChildren('');
  362.   }
  364.   /**
  365.    * Verifies if the element is a TXml node.
  366.    * @param {!shaka.extern.xml.Node} elem The XML element.
  367.    * @return {!boolean} Is the element a TXml node
  368.    */
  369.   static isNode(elem) {
  370.     return !!(elem.tagName);
  371.   }
  373.   /**
  374.    * Checks if a node is of type text.
  375.    * @param {!shaka.extern.xml.Node | string} elem The XML element.
  376.    * @return {boolean} True if it is a text node.
  377.    */
  378.   static isText(elem) {
  379.     return typeof elem === 'string';
  380.   }
  382.   /**
  383.    * gets child XML elements.
  384.    * @param {!shaka.extern.xml.Node} elem The parent XML element.
  385.    * @return {!Array.<!shaka.extern.xml.Node>} The child XML elements.
  386.    */
  387.   static getChildNodes(elem) {
  388.     const found = [];
  389.     if (!elem.children) {
  390.       return [];
  391.     }
  392.     for (const child of elem.children) {
  393.       if (typeof child !== 'string') {
  394.         found.push(child);
  395.       }
  396.     }
  397.     return found;
  398.   }
  400.   /**
  401.    * Finds child XML elements.
  402.    * @param {!shaka.extern.xml.Node} elem The parent XML element.
  403.    * @param {string} name The child XML element's tag name.
  404.    * @return {!Array.<!shaka.extern.xml.Node>} The child XML elements.
  405.    */
  406.   static findChildren(elem, name) {
  407.     const found = [];
  408.     if (!elem.children) {
  409.       return [];
  410.     }
  411.     for (const child of elem.children) {
  412.       if (child.tagName === name) {
  413.         found.push(child);
  414.       }
  415.     }
  416.     return found;
  417.   }
  419.   /**
  420.    * Gets inner text.
  421.    * @param {!shaka.extern.xml.Node | string} node The XML element.
  422.    * @return {?string} The text contents, or null if there are none.
  423.    */
  424.   static getTextContents(node) {
  425.     const StringUtils = shaka.util.StringUtils;
  426.     if (typeof node === 'string') {
  427.       return StringUtils.htmlUnescape(node);
  428.     }
  429.     const textContent = node.children.reduce(
  430.         (acc, curr) => (typeof curr === 'string' ? acc + curr : acc),
  431.         '',
  432.     );
  433.     if (textContent === '') {
  434.       return null;
  435.     }
  436.     return StringUtils.htmlUnescape(textContent);
  437.   }
  439.   /**
  440.    * Gets the text contents of a node.
  441.    * @param {!shaka.extern.xml.Node} node The XML element.
  442.    * @return {?string} The text contents, or null if there are none.
  443.    */
  444.   static getContents(node) {
  445.     if (!Array.from(node.children).every(
  446.         (n) => typeof n === 'string' )) {
  447.       return null;
  448.     }
  450.     // Read merged text content from all text nodes.
  451.     let text = shaka.util.TXml.getTextContents(node);
  452.     if (text) {
  453.       text = text.trim();
  454.     }
  455.     return text;
  456.   }
  458.   /**
  459.    * Finds child XML elements recursively.
  460.    * @param {!shaka.extern.xml.Node} elem The parent XML element.
  461.    * @param {string} name The child XML element's tag name.
  462.    * @param {!Array.<!shaka.extern.xml.Node>} found accumulator for found nodes
  463.    * @return {!Array.<!shaka.extern.xml.Node>} The child XML elements.
  464.    */
  465.   static getElementsByTagName(elem, name, found = []) {
  466.     if (elem.tagName === name) {
  467.       found.push(elem);
  468.     }
  469.     if (elem.children) {
  470.       for (const child of elem.children) {
  471.         shaka.util.TXml.getElementsByTagName(child, name, found);
  472.       }
  473.     }
  474.     return found;
  475.   }
  477.   /**
  478.    * Finds a child XML element.
  479.    * @param {!shaka.extern.xml.Node} elem The parent XML element.
  480.    * @param {string} name The child XML element's tag name.
  481.    * @return {shaka.extern.xml.Node | null} The child XML element,
  482.    *   or null if a child XML element
  483.    *   does not exist with the given tag name OR if there exists more than one
  484.    *   child XML element with the given tag name.
  485.    */
  486.   static findChild(elem, name) {
  487.     const children = shaka.util.TXml.findChildren(elem, name);
  488.     if (children.length != 1) {
  489.       return null;
  490.     }
  491.     return children[0];
  492.   }
  494.   /**
  495.    * Finds a namespace-qualified child XML element.
  496.    * @param {!shaka.extern.xml.Node} elem The parent XML element.
  497.    * @param {string} ns The child XML element's namespace URI.
  498.    * @param {string} name The child XML element's local name.
  499.    * @return {shaka.extern.xml.Node | null} The child XML element, or null
  500.    *   if a child XML element
  501.    *   does not exist with the given tag name OR if there exists more than one
  502.    *   child XML element with the given tag name.
  503.    */
  504.   static findChildNS(elem, ns, name) {
  505.     const children = shaka.util.TXml.findChildrenNS(elem, ns, name);
  506.     if (children.length != 1) {
  507.       return null;
  508.     }
  509.     return children[0];
  510.   }
  512.   /**
  513.    * Parses an attribute by its name.
  514.    * @param {!shaka.extern.xml.Node} elem The XML element.
  515.    * @param {string} name The attribute name.
  516.    * @param {function(string): (T|null)} parseFunction A function that parses
  517.    *   the attribute.
  518.    * @param {(T|null)=} defaultValue The attribute's default value, if not
  519.    *   specified, the attibute's default value is null.
  520.    * @return {(T|null)} The parsed attribute on success, or the attribute's
  521.    *   default value if the attribute does not exist or could not be parsed.
  522.    * @template T
  523.    */
  524.   static parseAttr(elem, name, parseFunction, defaultValue = null) {
  525.     let parsedValue = null;
  527.     const value = elem.attributes[name];
  528.     if (value != null) {
  529.       parsedValue = parseFunction(value);
  530.     }
  531.     return parsedValue == null ? defaultValue : parsedValue;
  532.   }
  534.   /**
  535.    * Gets a namespace-qualified attribute.
  536.    * @param {!shaka.extern.xml.Node} elem The element to get from.
  537.    * @param {string} ns The namespace URI.
  538.    * @param {string} name The local name of the attribute.
  539.    * @return {?string} The attribute's value, or null if not present.
  540.    */
  541.   static getAttributeNS(elem, ns, name) {
  542.     const schemaNS = shaka.util.TXml.getKnownNameSpace(ns);
  543.     // Think this is equivalent
  544.     const attribute = elem.attributes[`${schemaNS}:${name}`];
  545.     return attribute || null;
  546.   }
  548.   /**
  549.    * Finds namespace-qualified child XML elements.
  550.    * @param {!shaka.extern.xml.Node} elem The parent XML element.
  551.    * @param {string} ns The child XML element's namespace URI.
  552.    * @param {string} name The child XML element's local name.
  553.    * @return {!Array.<!shaka.extern.xml.Node>} The child XML elements.
  554.    */
  555.   static findChildrenNS(elem, ns, name) {
  556.     const schemaNS = shaka.util.TXml.getKnownNameSpace(ns);
  557.     const found = [];
  558.     if (elem.children) {
  559.       for (const child of elem.children) {
  560.         if (child && child.tagName === `${schemaNS}:${name}`) {
  561.           found.push(child);
  562.         }
  563.       }
  564.     }
  565.     return found;
  566.   }
  568.   /**
  569.    * Gets a namespace-qualified attribute.
  570.    * @param {!shaka.extern.xml.Node} elem The element to get from.
  571.    * @param {!Array.<string>} nsList The lis of namespace URIs.
  572.    * @param {string} name The local name of the attribute.
  573.    * @return {?string} The attribute's value, or null if not present.
  574.    */
  575.   static getAttributeNSList(elem, nsList, name) {
  576.     for (const ns of nsList) {
  577.       const attr = shaka.util.TXml.getAttributeNS(
  578.           elem, ns, name,
  579.       );
  580.       if (attr) {
  581.         return attr;
  582.       }
  583.     }
  584.     return null;
  585.   }
  588.   /**
  589.    * Parses an XML date string.
  590.    * @param {string} dateString
  591.    * @return {?number} The parsed date in seconds on success; otherwise, return
  592.    *   null.
  593.    */
  594.   static parseDate(dateString) {
  595.     if (!dateString) {
  596.       return null;
  597.     }
  599.     // Times in the manifest should be in UTC. If they don't specify a timezone,
  600.     // Date.parse() will use the local timezone instead of UTC.  So manually add
  601.     // the timezone if missing ('Z' indicates the UTC timezone).
  602.     // Format: YYYY-MM-DDThh:mm:ss.ssssss
  603.     if (/^\d+-\d+-\d+T\d+:\d+:\d+(\.\d+)?$/.test(dateString)) {
  604.       dateString += 'Z';
  605.     }
  607.     const result = Date.parse(dateString);
  608.     return isNaN(result) ? null : (result / 1000.0);
  609.   }
  612.   /**
  613.    * Parses an XML duration string.
  614.    * Negative values are not supported. Years and months are treated as exactly
  615.    * 365 and 30 days respectively.
  616.    * @param {string} durationString The duration string, e.g., "PT1H3M43.2S",
  617.    *   which means 1 hour, 3 minutes, and 43.2 seconds.
  618.    * @return {?number} The parsed duration in seconds on success; otherwise,
  619.    *   return null.
  620.    * @see {@link http://www.datypic.com/sc/xsd/t-xsd_duration.html}
  621.    */
  622.   static parseDuration(durationString) {
  623.     if (!durationString) {
  624.       return null;
  625.     }
  627.     const re = '^P(?:([0-9]*)Y)?(?:([0-9]*)M)?(?:([0-9]*)D)?' +
  628.         '(?:T(?:([0-9]*)H)?(?:([0-9]*)M)?(?:([0-9.]*)S)?)?$';
  629.     const matches = new RegExp(re).exec(durationString);
  631.     if (!matches) {
  632.       shaka.log.warning('Invalid duration string:', durationString);
  633.       return null;
  634.     }
  636.     // Note: Number(null) == 0 but Number(undefined) == NaN.
  637.     const years = Number(matches[1] || null);
  638.     const months = Number(matches[2] || null);
  639.     const days = Number(matches[3] || null);
  640.     const hours = Number(matches[4] || null);
  641.     const minutes = Number(matches[5] || null);
  642.     const seconds = Number(matches[6] || null);
  644.     // Assume a year always has 365 days and a month always has 30 days.
  645.     const d = (60 * 60 * 24 * 365) * years +
  646.         (60 * 60 * 24 * 30) * months +
  647.         (60 * 60 * 24) * days +
  648.         (60 * 60) * hours +
  649.         60 * minutes +
  650.         seconds;
  651.     return isFinite(d) ? d : null;
  652.   }
  655.   /**
  656.    * Parses a range string.
  657.    * @param {string} rangeString The range string, e.g., "101-9213".
  658.    * @return {?{start: number, end: number}} The parsed range on success;
  659.    *   otherwise, return null.
  660.    */
  661.   static parseRange(rangeString) {
  662.     const matches = /([0-9]+)-([0-9]+)/.exec(rangeString);
  664.     if (!matches) {
  665.       return null;
  666.     }
  668.     const start = Number(matches[1]);
  669.     if (!isFinite(start)) {
  670.       return null;
  671.     }
  673.     const end = Number(matches[2]);
  674.     if (!isFinite(end)) {
  675.       return null;
  676.     }
  678.     return {start: start, end: end};
  679.   }
  682.   /**
  683.    * Parses an integer.
  684.    * @param {string} intString The integer string.
  685.    * @return {?number} The parsed integer on success; otherwise, return null.
  686.    */
  687.   static parseInt(intString) {
  688.     const n = Number(intString);
  689.     return (n % 1 === 0) ? n : null;
  690.   }
  693.   /**
  694.    * Parses a positive integer.
  695.    * @param {string} intString The integer string.
  696.    * @return {?number} The parsed positive integer on success; otherwise,
  697.    *   return null.
  698.    */
  699.   static parsePositiveInt(intString) {
  700.     const n = Number(intString);
  701.     return (n % 1 === 0) && (n > 0) ? n : null;
  702.   }
  705.   /**
  706.    * Parses a non-negative integer.
  707.    * @param {string} intString The integer string.
  708.    * @return {?number} The parsed non-negative integer on success; otherwise,
  709.    *   return null.
  710.    */
  711.   static parseNonNegativeInt(intString) {
  712.     const n = Number(intString);
  713.     return (n % 1 === 0) && (n >= 0) ? n : null;
  714.   }
  717.   /**
  718.    * Parses a floating point number.
  719.    * @param {string} floatString The floating point number string.
  720.    * @return {?number} The parsed floating point number on success; otherwise,
  721.    *   return null. May return -Infinity or Infinity.
  722.    */
  723.   static parseFloat(floatString) {
  724.     const n = Number(floatString);
  725.     return !isNaN(n) ? n : null;
  726.   }
  729.   /**
  730.    * Parses a boolean.
  731.    * @param {string} booleanString The boolean string.
  732.    * @return {boolean} The boolean
  733.    */
  734.   static parseBoolean(booleanString) {
  735.     if (!booleanString) {
  736.       return false;
  737.     }
  738.     return booleanString.toLowerCase() === 'true';
  739.   }
  742.   /**
  743.    * Evaluate a division expressed as a string.
  744.    * @param {string} exprString
  745.    *   The expression to evaluate, e.g. "200/2". Can also be a single number.
  746.    * @return {?number} The evaluated expression as floating point number on
  747.    *   success; otherwise return null.
  748.    */
  749.   static evalDivision(exprString) {
  750.     let res;
  751.     let n;
  752.     if ((res = exprString.match(/^(\d+)\/(\d+)$/))) {
  753.       n = Number(res[1]) / Number(res[2]);
  754.     } else {
  755.       n = Number(exprString);
  756.     }
  757.     return !isNaN(n) ? n : null;
  758.   }
  761.   /**
  762.    * Parse xPath strings for segments and id targets.
  763.    * @param {string} exprString
  764.    * @return {!Array<!shaka.util.TXml.PathNode>}
  765.    */
  766.   static parseXpath(exprString) {
  767.     const StringUtils = shaka.util.StringUtils;
  768.     const returnPaths = [];
  769.     // Split string by paths but ignore '/' in quotes
  770.     const paths = StringUtils.htmlUnescape(exprString)
  771.         .split(/\/+(?=(?:[^'"]*['"][^'"]*['"])*[^'"]*$)/);
  772.     for (const path of paths) {
  773.       const nodeName = path.match(/^([\w]+)/);
  775.       if (nodeName) {
  776.         // We only want the id attribute in which case
  777.         // /'(.*?)'/ will suffice to get it.
  778.         const idAttr = path.match(/(@id='(.*?)')/);
  779.         const tAttr = path.match(/(@t='(\d+)')/);
  780.         const numberIndex = path.match(/(@n='(\d+)')/);
  781.         const position = path.match(/\[(\d+)\]/);
  782.         returnPaths.push({
  783.           name: nodeName[0],
  784.           id: idAttr ?
  785.             idAttr[0].match(/'(.*?)'/)[0].replace(/'/gm, '') : null,
  786.           t: tAttr ?
  787.             Number(tAttr[0].match(/'(.*?)'/)[0].replace(/'/gm, '')) : null,
  788.           n: numberIndex ?
  789.             Number(numberIndex[0].match(/'(.*?)'/)[0].replace(/'/gm, '')):
  790.             null,
  791.           // position is counted from 1, so make it readable for devs
  792.           position: position ? Number(position[1]) - 1 : null,
  793.           attribute: path.split('/@')[1] || null,
  794.         });
  795.       } else if (path.startsWith('@') && returnPaths.length) {
  796.         returnPaths[returnPaths.length - 1].attribute = path.slice(1);
  797.       }
  798.     }
  799.     return returnPaths;
  800.   }
  803.   /**
  804.    * Modifies nodes in specified array by adding or removing nodes
  805.    * and updating attributes.
  806.    * @param {!Array<shaka.extern.xml.Node>} nodes
  807.    * @param {!shaka.extern.xml.Node} patchNode
  808.    */
  809.   static modifyNodes(nodes, patchNode) {
  810.     const TXml = shaka.util.TXml;
  812.     const paths = TXml.parseXpath(patchNode.attributes['sel'] || '');
  813.     if (!paths.length) {
  814.       return;
  815.     }
  816.     const lastNode = paths[paths.length - 1];
  817.     const position = patchNode.attributes['pos'] || null;
  819.     let index = lastNode.position;
  820.     if (index == null) {
  821.       if (lastNode.t !== null) {
  822.         index = TXml.nodePositionByAttribute_(nodes, 't', lastNode.t);
  823.       }
  824.       if (lastNode.n !== null) {
  825.         index = TXml.nodePositionByAttribute_(nodes, 'n', lastNode.n);
  826.       }
  827.     }
  828.     if (index === null) {
  829.       index = position === 'prepend' ? 0 : nodes.length;
  830.     } else if (position === 'prepend') {
  831.       --index;
  832.     } else if (position === 'after') {
  833.       ++index;
  834.     }
  835.     const action = patchNode.tagName;
  836.     const attribute = lastNode.attribute;
  838.     // Modify attribute
  839.     if (attribute && nodes[index]) {
  840.       TXml.modifyNodeAttribute(nodes[index], action, attribute,
  841.           TXml.getContents(patchNode) || '');
  842.     // Rearrange nodes
  843.     } else {
  844.       if (action === 'remove' || action === 'replace') {
  845.         nodes.splice(index, 1);
  846.       }
  847.       if (action === 'add' || action === 'replace') {
  848.         const newNodes = patchNode.children;
  849.         nodes.splice(index, 0, ...newNodes);
  850.       }
  851.     }
  852.   }
  855.   /**
  856.    * Search the node index by the t attribute
  857.    * and return the index. if not found return null
  858.    * @param {!Array<shaka.extern.xml.Node>} nodes
  859.    * @param {!string} attribute
  860.    * @param {!number} value
  861.    * @private
  862.    */
  863.   static nodePositionByAttribute_(nodes, attribute, value) {
  864.     let index = 0;
  865.     for (const node of nodes) {
  866.       const attrs = node.attributes;
  867.       const val = Number(attrs[attribute]);
  868.       if (val === value) {
  869.         return index;
  870.       }
  871.       index++;
  872.     }
  873.     return null;
  874.   }
  877.   /**
  878.    * @param {!shaka.extern.xml.Node} node
  879.    * @param {string} action
  880.    * @param {string} attribute
  881.    * @param {string} value
  882.    */
  883.   static modifyNodeAttribute(node, action, attribute, value) {
  884.     if (action === 'remove') {
  885.       delete node.attributes[attribute];
  886.     } else if (action === 'add' || action === 'replace') {
  887.       node.attributes[attribute] = value;
  888.     }
  889.   }
  892.   /**
  893.    * Converts a tXml node to DOM element.
  894.    * @param {shaka.extern.xml.Node} node
  895.    * @return {!Element}
  896.    */
  897.   static txmlNodeToDomElement(node) {
  898.     const TXml = shaka.util.TXml;
  899.     let namespace = '';
  900.     const parts = node.tagName.split(':');
  901.     if (parts.length > 0) {
  902.       namespace = TXml.getKnownSchema(parts[0]);
  903.     }
  904.     const element = document.createElementNS(namespace, node.tagName);
  906.     for (const k in node.attributes) {
  907.       const v = node.attributes[k];
  908.       element.setAttribute(k, v);
  909.     }
  911.     for (const child of node.children) {
  912.       let childElement;
  913.       if (typeof child == 'string') {
  914.         childElement = new Text(child);
  915.       } else {
  916.         childElement = TXml.txmlNodeToDomElement(child);
  917.       }
  918.       element.appendChild(childElement);
  919.     }
  921.     return element;
  922.   }
  924.   /**
  925.    * Clones node and its children recursively. Skips parent.
  926.    * @param {?shaka.extern.xml.Node} node
  927.    * @return {?shaka.extern.xml.Node}
  928.    */
  929.   static cloneNode(node) {
  930.     if (!node) {
  931.       return null;
  932.     }
  933.     /** @type {!shaka.extern.xml.Node} */
  934.     const clone = {
  935.       tagName: node.tagName,
  936.       attributes: shaka.util.ObjectUtils.shallowCloneObject(node.attributes),
  937.       children: [],
  938.       parent: null,
  939.     };
  940.     for (const child of node.children) {
  941.       if (typeof child === 'string') {
  942.         clone.children.push(child);
  943.       } else {
  944.         const clonedChild = shaka.util.TXml.cloneNode(child);
  945.         clonedChild.parent = clone;
  946.         clone.children.push(clonedChild);
  947.       }
  948.     }
  949.     return clone;
  950.   }
  951. };
  953. /** @private {!Map<string, string>} */
  954. shaka.util.TXml.uriToNameSpace_ = new Map();
  956. /** @private {!Map<string, string>} */
  957. shaka.util.TXml.nameSpaceToUri_ = new Map();
  960. /**
  961.  * @typedef {{
  962.  *   name: string,
  963.  *   id: ?string,
  964.  *   t: ?number,
  965.  *   n: ?number,
  966.  *   position: ?number,
  967.  *   attribute: ?string
  968.  * }}
  969.  */
  970. shaka.util.TXml.PathNode;