Source: lib/text/ttml_text_parser.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.text.TtmlTextParser');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.text.Cue');
  12. goog.require('shaka.text.CueRegion');
  13. goog.require('shaka.text.TextEngine');
  14. goog.require('shaka.util.ArrayUtils');
  15. goog.require('shaka.util.Error');
  16. goog.require('shaka.util.StringUtils');
  17. goog.require('shaka.util.XmlUtils');
  20. /**
  21.  * @implements {shaka.extern.TextParser}
  22.  * @export
  23.  */
  24. shaka.text.TtmlTextParser = class {
  25.   /**
  26.    * @override
  27.    * @export
  28.    */
  29.   parseInit(data) {
  30.     goog.asserts.assert(false, 'TTML does not have init segments');
  31.   }
  33.   /**
  34.    * @override
  35.    * @export
  36.    */
  37.   parseMedia(data, time) {
  38.     const TtmlTextParser = shaka.text.TtmlTextParser;
  39.     const XmlUtils = shaka.util.XmlUtils;
  40.     const ttpNs = TtmlTextParser.parameterNs_;
  41.     const ttsNs = TtmlTextParser.styleNs_;
  42.     const str = shaka.util.StringUtils.fromUTF8(data);
  43.     const cues = [];
  45.     // dont try to parse empty string as
  46.     // DOMParser will not throw error but return an errored xml
  47.     if (str == '') {
  48.       return cues;
  49.     }
  51.     const tt = XmlUtils.parseXmlString(str, 'tt');
  52.     if (!tt) {
  53.       throw new shaka.util.Error(
  54.           shaka.util.Error.Severity.CRITICAL,
  55.           shaka.util.Error.Category.TEXT,
  56.           shaka.util.Error.Code.INVALID_XML,
  57.           'Failed to parse TTML.');
  58.     }
  60.     const body = tt.getElementsByTagName('body')[0];
  61.     if (!body) {
  62.       return [];
  63.     }
  65.     // Get the framerate, subFrameRate and frameRateMultiplier if applicable.
  66.     const frameRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRate');
  67.     const subFrameRate = XmlUtils.getAttributeNSList(
  68.         tt, ttpNs, 'subFrameRate');
  69.     const frameRateMultiplier =
  70.         XmlUtils.getAttributeNSList(tt, ttpNs, 'frameRateMultiplier');
  71.     const tickRate = XmlUtils.getAttributeNSList(tt, ttpNs, 'tickRate');
  73.     const cellResolution = XmlUtils.getAttributeNSList(
  74.         tt, ttpNs, 'cellResolution');
  75.     const spaceStyle = tt.getAttribute('xml:space') || 'default';
  76.     const extent = XmlUtils.getAttributeNSList(tt, ttsNs, 'extent');
  78.     if (spaceStyle != 'default' && spaceStyle != 'preserve') {
  79.       throw new shaka.util.Error(
  80.           shaka.util.Error.Severity.CRITICAL,
  81.           shaka.util.Error.Category.TEXT,
  82.           shaka.util.Error.Code.INVALID_XML,
  83.           'Invalid xml:space value: ' + spaceStyle);
  84.     }
  85.     const whitespaceTrim = spaceStyle == 'default';
  87.     const rateInfo = new TtmlTextParser.RateInfo_(
  88.         frameRate, subFrameRate, frameRateMultiplier, tickRate);
  90.     const cellResolutionInfo =
  91.       TtmlTextParser.getCellResolution_(cellResolution);
  93.     const metadata = tt.getElementsByTagName('metadata')[0];
  94.     const metadataElements = metadata ? XmlUtils.getChildren(metadata) : [];
  95.     const styles = Array.from(tt.getElementsByTagName('style'));
  96.     const regionElements = Array.from(tt.getElementsByTagName('region'));
  98.     const cueRegions = [];
  99.     for (const region of regionElements) {
  100.       const cueRegion =
  101.           TtmlTextParser.parseCueRegion_(region, styles, extent);
  102.       if (cueRegion) {
  103.         cueRegions.push(cueRegion);
  104.       }
  105.     }
  107.     // A <body> element should only contain <div> elements, not <p> or <span>
  108.     // elements.  We used to allow this, but it is non-compliant, and the
  109.     // loose nature of our previous parser made it difficult to implement TTML
  110.     // nesting more fully.
  111.     if (XmlUtils.findChildren(body, 'p').length) {
  112.       throw new shaka.util.Error(
  113.           shaka.util.Error.Severity.CRITICAL,
  114.           shaka.util.Error.Category.TEXT,
  115.           shaka.util.Error.Code.INVALID_TEXT_CUE,
  116.           '<p> can only be inside <div> in TTML');
  117.     }
  119.     for (const div of XmlUtils.findChildren(body, 'div')) {
  120.       // A <div> element should only contain <p>, not <span>.
  121.       if (XmlUtils.findChildren(div, 'span').length) {
  122.         throw new shaka.util.Error(
  123.             shaka.util.Error.Severity.CRITICAL,
  124.             shaka.util.Error.Category.TEXT,
  125.             shaka.util.Error.Code.INVALID_TEXT_CUE,
  126.             '<span> can only be inside <p> in TTML');
  127.       }
  128.     }
  130.     const cue = TtmlTextParser.parseCue_(
  131.         body, time, rateInfo, metadataElements, styles,
  132.         regionElements, cueRegions, whitespaceTrim,
  133.         cellResolutionInfo, /* parentCueElement= */ null,
  134.         /* isContent= */ false);
  135.     if (cue) {
  136.       // According to the TTML spec, backgrounds default to transparent.
  137.       // So default the background of the top-level element to transparent.
  138.       // Nested elements may override that background color already.
  139.       if (!cue.backgroundColor) {
  140.         cue.backgroundColor = 'transparent';
  141.       }
  142.       cues.push(cue);
  143.     }
  145.     return cues;
  146.   }
  148.   /**
  149.    * Parses a TTML node into a Cue.
  150.    *
  151.    * @param {!Node} cueNode
  152.    * @param {shaka.extern.TextParser.TimeContext} timeContext
  153.    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  154.    * @param {!Array.<!Element>} metadataElements
  155.    * @param {!Array.<!Element>} styles
  156.    * @param {!Array.<!Element>} regionElements
  157.    * @param {!Array.<!shaka.text.CueRegion>} cueRegions
  158.    * @param {boolean} whitespaceTrim
  159.    * @param {?{columns: number, rows: number}} cellResolution
  160.    * @param {?Element} parentCueElement
  161.    * @param {boolean} isContent
  162.    * @return {shaka.text.Cue}
  163.    * @private
  164.    */
  165.   static parseCue_(
  166.       cueNode, timeContext, rateInfo, metadataElements, styles, regionElements,
  167.       cueRegions, whitespaceTrim, cellResolution, parentCueElement, isContent) {
  168.     /** @type {Element} */
  169.     let cueElement;
  170.     /** @type {Element} */
  171.     let parentElement = /** @type {Element} */ (cueNode.parentNode);
  173.     if (cueNode.nodeType == Node.COMMENT_NODE) {
  174.       // The comments do not contain information that interests us here.
  175.       return null;
  176.     }
  178.     if (cueNode.nodeType == Node.TEXT_NODE) {
  179.       if (!isContent) {
  180.         // Ignore text elements outside the content. For example, whitespace
  181.         // on the same lexical level as the <p> elements, in a document with
  182.         // xml:space="preserve", should not be renderer.
  183.         return null;
  184.       }
  185.       // This should generate an "anonymous span" according to the TTML spec.
  186.       // So pretend the element was a <span>.  parentElement was set above, so
  187.       // we should still be able to correctly traverse up for timing
  188.       // information later.
  189.       const span = document.createElement('span');
  190.       span.textContent = cueNode.textContent;
  191.       cueElement = span;
  192.     } else {
  193.       goog.asserts.assert(cueNode.nodeType == Node.ELEMENT_NODE,
  194.           'nodeType should be ELEMENT_NODE!');
  195.       cueElement = /** @type {!Element} */(cueNode);
  196.     }
  197.     goog.asserts.assert(cueElement, 'cueElement should be non-null!');
  199.     let imageElement = null;
  200.     for (const nameSpace of shaka.text.TtmlTextParser.smpteNsList_) {
  201.       imageElement = shaka.text.TtmlTextParser.getElementsFromCollection_(
  202.           cueElement, 'backgroundImage', metadataElements, '#',
  203.           nameSpace)[0];
  204.       if (imageElement) {
  205.         break;
  206.       }
  207.     }
  209.     const parentIsContent = isContent;
  210.     if (cueNode.nodeName == 'p' || imageElement) {
  211.       isContent = true;
  212.     }
  214.     const spaceStyle = cueElement.getAttribute('xml:space') ||
  215.         (whitespaceTrim ? 'default' : 'preserve');
  217.     const localWhitespaceTrim = spaceStyle == 'default';
  219.     // Parse any nested cues first.
  220.     const isTextNode = (node) => {
  221.       return node.nodeType == Node.TEXT_NODE;
  222.     };
  223.     const isLeafNode = Array.from(cueElement.childNodes).every(isTextNode);
  224.     const nestedCues = [];
  225.     if (!isLeafNode) {
  226.       // Otherwise, recurse into the children.  Text nodes will convert into
  227.       // anonymous spans, which will then be leaf nodes.
  228.       for (const childNode of cueElement.childNodes) {
  229.         const nestedCue = shaka.text.TtmlTextParser.parseCue_(
  230.             childNode,
  231.             timeContext,
  232.             rateInfo,
  233.             metadataElements,
  234.             styles,
  235.             regionElements,
  236.             cueRegions,
  237.             localWhitespaceTrim,
  238.             cellResolution,
  239.             cueElement,
  240.             isContent,
  241.         );
  243.         // This node may or may not generate a nested cue.
  244.         if (nestedCue) {
  245.           nestedCues.push(nestedCue);
  246.         }
  247.       }
  248.     }
  250.     const isNested = /** @type {boolean} */ (parentCueElement != null);
  252.     // In this regex, "\S" means "non-whitespace character".
  253.     const hasTextContent = /\S/.test(cueElement.textContent);
  254.     const hasTimeAttributes =
  255.         cueElement.hasAttribute('begin') ||
  256.         cueElement.hasAttribute('end') ||
  257.         cueElement.hasAttribute('dur');
  259.     if (!hasTimeAttributes && !hasTextContent && cueElement.tagName != 'br' &&
  260.         nestedCues.length == 0) {
  261.       if (!isNested) {
  262.         // Disregards empty <p> elements without time attributes nor content.
  263.         // <p begin="..." smpte:backgroundImage="..." /> will go through,
  264.         // as some information could be held by its attributes.
  265.         // <p /> won't, as it would not be displayed.
  266.         return null;
  267.       } else if (localWhitespaceTrim) {
  268.         // Disregards empty anonymous spans when (local) trim is true.
  269.         return null;
  270.       }
  271.     }
  273.     // Get local time attributes.
  274.     let {start, end} = shaka.text.TtmlTextParser.parseTime_(
  275.         cueElement, rateInfo);
  276.     // Resolve local time relative to parent elements.  Time elements can appear
  277.     // all the way up to 'body', but not 'tt'.
  278.     while (parentElement && parentElement.nodeType == Node.ELEMENT_NODE &&
  279.         parentElement.tagName != 'tt') {
  280.       ({start, end} = shaka.text.TtmlTextParser.resolveTime_(
  281.           parentElement, rateInfo, start, end));
  282.       parentElement = /** @type {Element} */(parentElement.parentNode);
  283.     }
  285.     if (start == null) {
  286.       start = 0;
  287.     }
  288.     start += timeContext.periodStart;
  290.     // If end is null, that means the duration is effectively infinite.
  291.     if (end == null) {
  292.       end = Infinity;
  293.     } else {
  294.       end += timeContext.periodStart;
  295.     }
  297.     // Clip times to segment boundaries.
  298.     // https://github.com/shaka-project/shaka-player/issues/4631
  299.     start = Math.max(start, timeContext.segmentStart);
  300.     end = Math.min(end, timeContext.segmentEnd);
  302.     if (!hasTimeAttributes && nestedCues.length > 0) {
  303.       // If no time is defined for this cue, base the timing information on
  304.       // the time of the nested cues. In the case of multiple nested cues with
  305.       // different start times, it is the text displayer's responsibility to
  306.       // make sure that only the appropriate nested cue is drawn at any given
  307.       // time.
  308.       start = Infinity;
  309.       end = 0;
  310.       for (const cue of nestedCues) {
  311.         start = Math.min(start, cue.startTime);
  312.         end = Math.max(end, cue.endTime);
  313.       }
  314.     }
  316.     if (cueElement.tagName == 'br') {
  317.       const cue = new shaka.text.Cue(start, end, '');
  318.       cue.lineBreak = true;
  319.       return cue;
  320.     }
  322.     let payload = '';
  323.     if (isLeafNode) {
  324.       // If the childNodes are all text, this is a leaf node.  Get the payload.
  325.       payload = cueElement.textContent;
  326.       if (localWhitespaceTrim) {
  327.         // Trim leading and trailing whitespace.
  328.         payload = payload.trim();
  329.         // Collapse multiple spaces into one.
  330.         payload = payload.replace(/\s+/g, ' ');
  331.       }
  332.     }
  334.     const cue = new shaka.text.Cue(start, end, payload);
  335.     cue.nestedCues = nestedCues;
  337.     if (!isContent) {
  338.       // If this is not a <p> element or a <div> with images, and it has no
  339.       // parent that was a <p> element, then it's part of the outer containers
  340.       // (e.g. the <body> or a normal <div> element within it).
  341.       cue.isContainer = true;
  342.     }
  344.     if (cellResolution) {
  345.       cue.cellResolution = cellResolution;
  346.     }
  348.     // Get other properties if available.
  349.     const regionElement = shaka.text.TtmlTextParser.getElementsFromCollection_(
  350.         cueElement, 'region', regionElements, /* prefix= */ '')[0];
  351.     // Do not actually apply that region unless it is non-inherited, though.
  352.     // This makes it so that, if a parent element has a region, the children
  353.     // don't also all independently apply the positioning of that region.
  354.     if (cueElement.hasAttribute('region')) {
  355.       if (regionElement && regionElement.getAttribute('xml:id')) {
  356.         const regionId = regionElement.getAttribute('xml:id');
  357.         cue.region = cueRegions.filter((region) => region.id == regionId)[0];
  358.       }
  359.     }
  361.     let regionElementForStyle = regionElement;
  362.     if (parentCueElement && isNested && !cueElement.getAttribute('region') &&
  363.       !cueElement.getAttribute('style')) {
  364.       regionElementForStyle =
  365.           shaka.text.TtmlTextParser.getElementsFromCollection_(
  366.               parentCueElement, 'region', regionElements, /* prefix= */ '')[0];
  367.     }
  369.     shaka.text.TtmlTextParser.addStyle_(
  370.         cue,
  371.         cueElement,
  372.         regionElementForStyle,
  373.         imageElement,
  374.         styles,
  375.         /** isNested= */ parentIsContent, // "nested in a <div>" doesn't count.
  376.         /** isLeaf= */ (nestedCues.length == 0));
  378.     return cue;
  379.   }
  381.   /**
  382.    * Parses an Element into a TextTrackCue or VTTCue.
  383.    *
  384.    * @param {!Element} regionElement
  385.    * @param {!Array.<!Element>} styles Defined in the top of tt  element and
  386.    * used principally for images.
  387.    * @param {?string} globalExtent
  388.    * @return {shaka.text.CueRegion}
  389.    * @private
  390.    */
  391.   static parseCueRegion_(regionElement, styles, globalExtent) {
  392.     const TtmlTextParser = shaka.text.TtmlTextParser;
  393.     const region = new shaka.text.CueRegion();
  394.     const id = regionElement.getAttribute('xml:id');
  395.     if (!id) {
  396.       shaka.log.warning('TtmlTextParser parser encountered a region with ' +
  397.                         'no id. Region will be ignored.');
  398.       return null;
  399.     }
  400.     region.id = id;
  402.     let globalResults = null;
  403.     if (globalExtent) {
  404.       globalResults = TtmlTextParser.percentValues_.exec(globalExtent) ||
  405.         TtmlTextParser.pixelValues_.exec(globalExtent);
  406.     }
  407.     const globalWidth = globalResults ? Number(globalResults[1]) : null;
  408.     const globalHeight = globalResults ? Number(globalResults[2]) : null;
  410.     let results = null;
  411.     let percentage = null;
  412.     const extent = TtmlTextParser.getStyleAttributeFromRegion_(
  413.         regionElement, styles, 'extent');
  414.     if (extent) {
  415.       percentage = TtmlTextParser.percentValues_.exec(extent);
  416.       results = percentage || TtmlTextParser.pixelValues_.exec(extent);
  417.       if (results != null) {
  418.         region.width = Number(results[1]);
  419.         region.height = Number(results[2]);
  421.         if (!percentage) {
  422.           if (globalWidth != null) {
  423.             region.width = region.width * 100 / globalWidth;
  424.           }
  425.           if (globalHeight != null) {
  426.             region.height = region.height * 100 / globalHeight;
  427.           }
  428.         }
  430.         region.widthUnits = percentage || globalWidth != null ?
  431.                            shaka.text.CueRegion.units.PERCENTAGE :
  432.                            shaka.text.CueRegion.units.PX;
  434.         region.heightUnits = percentage || globalHeight != null ?
  435.                            shaka.text.CueRegion.units.PERCENTAGE :
  436.                            shaka.text.CueRegion.units.PX;
  437.       }
  438.     }
  440.     const origin = TtmlTextParser.getStyleAttributeFromRegion_(
  441.         regionElement, styles, 'origin');
  442.     if (origin) {
  443.       percentage = TtmlTextParser.percentValues_.exec(origin);
  444.       results = percentage || TtmlTextParser.pixelValues_.exec(origin);
  445.       if (results != null) {
  446.         region.viewportAnchorX = Number(results[1]);
  447.         region.viewportAnchorY = Number(results[2]);
  449.         if (!percentage) {
  450.           if (globalHeight != null) {
  451.             region.viewportAnchorY = region.viewportAnchorY * 100 /
  452.               globalHeight;
  453.           }
  454.           if (globalWidth != null) {
  455.             region.viewportAnchorX = region.viewportAnchorX * 100 /
  456.               globalWidth;
  457.           }
  458.         }
  460.         region.viewportAnchorUnits = percentage || globalWidth != null ?
  461.                   shaka.text.CueRegion.units.PERCENTAGE :
  462.                   shaka.text.CueRegion.units.PX;
  463.       }
  464.     }
  466.     return region;
  467.   }
  469.   /**
  470.    * Adds applicable style properties to a cue.
  471.    *
  472.    * @param {!shaka.text.Cue} cue
  473.    * @param {!Element} cueElement
  474.    * @param {Element} region
  475.    * @param {Element} imageElement
  476.    * @param {!Array.<!Element>} styles
  477.    * @param {boolean} isNested
  478.    * @param {boolean} isLeaf
  479.    * @private
  480.    */
  481.   static addStyle_(
  482.       cue, cueElement, region, imageElement, styles, isNested, isLeaf) {
  483.     const TtmlTextParser = shaka.text.TtmlTextParser;
  484.     const Cue = shaka.text.Cue;
  486.     // Styles should be inherited from regions, if a style property is not
  487.     // associated with a Content element (or an anonymous span).
  488.     const shouldInheritRegionStyles = isNested || isLeaf;
  490.     const direction = TtmlTextParser.getStyleAttribute_(
  491.         cueElement, region, styles, 'direction', shouldInheritRegionStyles);
  492.     if (direction == 'rtl') {
  493.       cue.direction = Cue.direction.HORIZONTAL_RIGHT_TO_LEFT;
  494.     }
  496.     // Direction attribute specifies one-dimentional writing direction
  497.     // (left to right or right to left). Writing mode specifies that
  498.     // plus whether text is vertical or horizontal.
  499.     // They should not contradict each other. If they do, we give
  500.     // preference to writing mode.
  501.     const writingMode = TtmlTextParser.getStyleAttribute_(
  502.         cueElement, region, styles, 'writingMode', shouldInheritRegionStyles);
  503.     // Set cue's direction if the text is horizontal, and cue's writingMode if
  504.     // it's vertical.
  505.     if (writingMode == 'tb' || writingMode == 'tblr') {
  506.       cue.writingMode = Cue.writingMode.VERTICAL_LEFT_TO_RIGHT;
  507.     } else if (writingMode == 'tbrl') {
  508.       cue.writingMode = Cue.writingMode.VERTICAL_RIGHT_TO_LEFT;
  509.     } else if (writingMode == 'rltb' || writingMode == 'rl') {
  510.       cue.direction = Cue.direction.HORIZONTAL_RIGHT_TO_LEFT;
  511.     } else if (writingMode) {
  512.       cue.direction = Cue.direction.HORIZONTAL_LEFT_TO_RIGHT;
  513.     }
  515.     const align = TtmlTextParser.getStyleAttribute_(
  516.         cueElement, region, styles, 'textAlign', true);
  517.     if (align) {
  518.       cue.positionAlign = TtmlTextParser.textAlignToPositionAlign_[align];
  519.       cue.lineAlign = TtmlTextParser.textAlignToLineAlign_[align];
  521.       goog.asserts.assert(align.toUpperCase() in Cue.textAlign,
  522.           align.toUpperCase() + ' Should be in Cue.textAlign values!');
  524.       cue.textAlign = Cue.textAlign[align.toUpperCase()];
  525.     } else {
  526.       // Default value is START in the TTML spec: https://bit.ly/32OGmvo
  527.       // But to make the subtitle render consitent with other players and the
  528.       // shaka.text.Cue we use CENTER
  529.       cue.textAlign = Cue.textAlign.CENTER;
  530.     }
  532.     const displayAlign = TtmlTextParser.getStyleAttribute_(
  533.         cueElement, region, styles, 'displayAlign', true);
  534.     if (displayAlign) {
  535.       goog.asserts.assert(displayAlign.toUpperCase() in Cue.displayAlign,
  536.           displayAlign.toUpperCase() +
  537.                           ' Should be in Cue.displayAlign values!');
  538.       cue.displayAlign = Cue.displayAlign[displayAlign.toUpperCase()];
  539.     }
  541.     const color = TtmlTextParser.getStyleAttribute_(
  542.         cueElement, region, styles, 'color', shouldInheritRegionStyles);
  543.     if (color) {
  544.       cue.color = color;
  545.     }
  547.     // Background color should not be set on a container.  If this is a nested
  548.     // cue, you can set the background.  If it's a top-level that happens to
  549.     // also be a leaf, you can set the background.
  550.     // See https://github.com/shaka-project/shaka-player/issues/2623
  551.     // This used to be handled in the displayer, but that is confusing.  The Cue
  552.     // structure should reflect what you want to happen in the displayer, and
  553.     // the displayer shouldn't have to know about TTML.
  554.     const backgroundColor = TtmlTextParser.getStyleAttribute_(
  555.         cueElement, region, styles, 'backgroundColor',
  556.         shouldInheritRegionStyles);
  557.     if (backgroundColor) {
  558.       cue.backgroundColor = backgroundColor;
  559.     }
  561.     const border = TtmlTextParser.getStyleAttribute_(
  562.         cueElement, region, styles, 'border', shouldInheritRegionStyles);
  563.     if (border) {
  564.       cue.border = border;
  565.     }
  567.     const fontFamily = TtmlTextParser.getStyleAttribute_(
  568.         cueElement, region, styles, 'fontFamily', shouldInheritRegionStyles);
  569.     // See https://github.com/sandflow/imscJS/blob/1.1.3/src/main/js/html.js#L1384
  570.     if (fontFamily) {
  571.       switch (fontFamily) {
  572.         case 'monospaceSerif':
  573.           cue.fontFamily = 'Courier New,Liberation Mono,Courier,monospace';
  574.           break;
  575.         case 'proportionalSansSerif':
  576.           cue.fontFamily = 'Arial,Helvetica,Liberation Sans,sans-serif';
  577.           break;
  578.         case 'sansSerif':
  579.           cue.fontFamily = 'sans-serif';
  580.           break;
  581.         case 'monospaceSansSerif':
  582.           cue.fontFamily = 'Consolas,monospace';
  583.           break;
  584.         case 'proportionalSerif':
  585.           cue.fontFamily = 'serif';
  586.           break;
  587.         default:
  588.           cue.fontFamily = fontFamily;
  589.           break;
  590.       }
  591.     }
  593.     const fontWeight = TtmlTextParser.getStyleAttribute_(
  594.         cueElement, region, styles, 'fontWeight', shouldInheritRegionStyles);
  595.     if (fontWeight && fontWeight == 'bold') {
  596.       cue.fontWeight = Cue.fontWeight.BOLD;
  597.     }
  599.     const wrapOption = TtmlTextParser.getStyleAttribute_(
  600.         cueElement, region, styles, 'wrapOption', shouldInheritRegionStyles);
  601.     if (wrapOption && wrapOption == 'noWrap') {
  602.       cue.wrapLine = false;
  603.     } else {
  604.       cue.wrapLine = true;
  605.     }
  607.     const lineHeight = TtmlTextParser.getStyleAttribute_(
  608.         cueElement, region, styles, 'lineHeight', shouldInheritRegionStyles);
  609.     if (lineHeight && lineHeight.match(TtmlTextParser.unitValues_)) {
  610.       cue.lineHeight = lineHeight;
  611.     }
  613.     const fontSize = TtmlTextParser.getStyleAttribute_(
  614.         cueElement, region, styles, 'fontSize', shouldInheritRegionStyles);
  615.     if (fontSize) {
  616.       const isValidFontSizeUnit =
  617.           fontSize.match(TtmlTextParser.unitValues_) ||
  618.           fontSize.match(TtmlTextParser.percentValue_);
  620.       if (isValidFontSizeUnit) {
  621.         cue.fontSize = fontSize;
  622.       }
  623.     }
  625.     const fontStyle = TtmlTextParser.getStyleAttribute_(
  626.         cueElement, region, styles, 'fontStyle', shouldInheritRegionStyles);
  627.     if (fontStyle) {
  628.       goog.asserts.assert(fontStyle.toUpperCase() in Cue.fontStyle,
  629.           fontStyle.toUpperCase() +
  630.                           ' Should be in Cue.fontStyle values!');
  631.       cue.fontStyle = Cue.fontStyle[fontStyle.toUpperCase()];
  632.     }
  634.     if (imageElement) {
  635.       // According to the spec, we should use imageType (camelCase), but
  636.       // historically we have checked for imagetype (lowercase).
  637.       // This was the case since background image support was first introduced
  638.       // in PR #1859, in April 2019, and first released in v2.5.0.
  639.       // Now we check for both, although only imageType (camelCase) is to spec.
  640.       const backgroundImageType =
  641.           imageElement.getAttribute('imageType') ||
  642.           imageElement.getAttribute('imagetype');
  643.       const backgroundImageEncoding = imageElement.getAttribute('encoding');
  644.       const backgroundImageData = imageElement.textContent.trim();
  645.       if (backgroundImageType == 'PNG' &&
  646.           backgroundImageEncoding == 'Base64' &&
  647.           backgroundImageData) {
  648.         cue.backgroundImage = 'data:image/png;base64,' + backgroundImageData;
  649.       }
  650.     }
  652.     const textOutline = TtmlTextParser.getStyleAttribute_(
  653.         cueElement, region, styles, 'textOutline', shouldInheritRegionStyles);
  654.     if (textOutline) {
  655.       // tts:textOutline isn't natively supported by browsers, but it can be
  656.       // mostly replicated using the non-standard -webkit-text-stroke-width and
  657.       // -webkit-text-stroke-color properties.
  658.       const split = textOutline.split(' ');
  659.       if (split[0].match(TtmlTextParser.unitValues_)) {
  660.         // There is no defined color, so default to the text color.
  661.         cue.textStrokeColor = cue.color;
  662.       } else {
  663.         cue.textStrokeColor = split[0];
  664.         split.shift();
  665.       }
  666.       if (split[0] && split[0].match(TtmlTextParser.unitValues_)) {
  667.         cue.textStrokeWidth = split[0];
  668.       } else {
  669.         // If there is no width, or the width is not a number, don't draw a
  670.         // border.
  671.         cue.textStrokeColor = '';
  672.       }
  673.       // There is an optional blur radius also, but we have no way of
  674.       // replicating that, so ignore it.
  675.     }
  677.     const letterSpacing = TtmlTextParser.getStyleAttribute_(
  678.         cueElement, region, styles, 'letterSpacing', shouldInheritRegionStyles);
  679.     if (letterSpacing && letterSpacing.match(TtmlTextParser.unitValues_)) {
  680.       cue.letterSpacing = letterSpacing;
  681.     }
  683.     const linePadding = TtmlTextParser.getStyleAttribute_(
  684.         cueElement, region, styles, 'linePadding', shouldInheritRegionStyles);
  685.     if (linePadding && linePadding.match(TtmlTextParser.unitValues_)) {
  686.       cue.linePadding = linePadding;
  687.     }
  689.     const opacity = TtmlTextParser.getStyleAttribute_(
  690.         cueElement, region, styles, 'opacity', shouldInheritRegionStyles);
  691.     if (opacity) {
  692.       cue.opacity = parseFloat(opacity);
  693.     }
  695.     // Text decoration is an array of values which can come both from the
  696.     // element's style or be inherited from elements' parent nodes. All of those
  697.     // values should be applied as long as they don't contradict each other. If
  698.     // they do, elements' own style gets preference.
  699.     const textDecorationRegion = TtmlTextParser.getStyleAttributeFromRegion_(
  700.         region, styles, 'textDecoration');
  701.     if (textDecorationRegion) {
  702.       TtmlTextParser.addTextDecoration_(cue, textDecorationRegion);
  703.     }
  705.     const textDecorationElement = TtmlTextParser.getStyleAttributeFromElement_(
  706.         cueElement, styles, 'textDecoration');
  707.     if (textDecorationElement) {
  708.       TtmlTextParser.addTextDecoration_(cue, textDecorationElement);
  709.     }
  710.   }
  712.   /**
  713.    * Parses text decoration values and adds/removes them to/from the cue.
  714.    *
  715.    * @param {!shaka.text.Cue} cue
  716.    * @param {string} decoration
  717.    * @private
  718.    */
  719.   static addTextDecoration_(cue, decoration) {
  720.     const Cue = shaka.text.Cue;
  721.     for (const value of decoration.split(' ')) {
  722.       switch (value) {
  723.         case 'underline':
  724.           if (!cue.textDecoration.includes(Cue.textDecoration.UNDERLINE)) {
  725.             cue.textDecoration.push(Cue.textDecoration.UNDERLINE);
  726.           }
  727.           break;
  728.         case 'noUnderline':
  729.           if (cue.textDecoration.includes(Cue.textDecoration.UNDERLINE)) {
  730.             shaka.util.ArrayUtils.remove(cue.textDecoration,
  731.                 Cue.textDecoration.UNDERLINE);
  732.           }
  733.           break;
  734.         case 'lineThrough':
  735.           if (!cue.textDecoration.includes(Cue.textDecoration.LINE_THROUGH)) {
  736.             cue.textDecoration.push(Cue.textDecoration.LINE_THROUGH);
  737.           }
  738.           break;
  739.         case 'noLineThrough':
  740.           if (cue.textDecoration.includes(Cue.textDecoration.LINE_THROUGH)) {
  741.             shaka.util.ArrayUtils.remove(cue.textDecoration,
  742.                 Cue.textDecoration.LINE_THROUGH);
  743.           }
  744.           break;
  745.         case 'overline':
  746.           if (!cue.textDecoration.includes(Cue.textDecoration.OVERLINE)) {
  747.             cue.textDecoration.push(Cue.textDecoration.OVERLINE);
  748.           }
  749.           break;
  750.         case 'noOverline':
  751.           if (cue.textDecoration.includes(Cue.textDecoration.OVERLINE)) {
  752.             shaka.util.ArrayUtils.remove(cue.textDecoration,
  753.                 Cue.textDecoration.OVERLINE);
  754.           }
  755.           break;
  756.       }
  757.     }
  758.   }
  760.   /**
  761.    * Finds a specified attribute on either the original cue element or its
  762.    * associated region and returns the value if the attribute was found.
  763.    *
  764.    * @param {!Element} cueElement
  765.    * @param {Element} region
  766.    * @param {!Array.<!Element>} styles
  767.    * @param {string} attribute
  768.    * @param {boolean=} shouldInheritRegionStyles
  769.    * @return {?string}
  770.    * @private
  771.    */
  772.   static getStyleAttribute_(cueElement, region, styles, attribute,
  773.       shouldInheritRegionStyles=true) {
  774.     // An attribute can be specified on region level or in a styling block
  775.     // associated with the region or original element.
  776.     const TtmlTextParser = shaka.text.TtmlTextParser;
  777.     const attr = TtmlTextParser.getStyleAttributeFromElement_(
  778.         cueElement, styles, attribute);
  779.     if (attr) {
  780.       return attr;
  781.     }
  783.     if (shouldInheritRegionStyles) {
  784.       return TtmlTextParser.getStyleAttributeFromRegion_(
  785.           region, styles, attribute);
  786.     }
  787.     return null;
  788.   }
  790.   /**
  791.    * Finds a specified attribute on the element's associated region
  792.    * and returns the value if the attribute was found.
  793.    *
  794.    * @param {Element} region
  795.    * @param {!Array.<!Element>} styles
  796.    * @param {string} attribute
  797.    * @return {?string}
  798.    * @private
  799.    */
  800.   static getStyleAttributeFromRegion_(region, styles, attribute) {
  801.     const XmlUtils = shaka.util.XmlUtils;
  802.     const ttsNs = shaka.text.TtmlTextParser.styleNs_;
  804.     if (!region) {
  805.       return null;
  806.     }
  808.     const attr = XmlUtils.getAttributeNSList(region, ttsNs, attribute);
  809.     if (attr) {
  810.       return attr;
  811.     }
  813.     return shaka.text.TtmlTextParser.getInheritedStyleAttribute_(
  814.         region, styles, attribute);
  815.   }
  817.   /**
  818.    * Finds a specified attribute on the cue element and returns the value
  819.    * if the attribute was found.
  820.    *
  821.    * @param {!Element} cueElement
  822.    * @param {!Array.<!Element>} styles
  823.    * @param {string} attribute
  824.    * @return {?string}
  825.    * @private
  826.    */
  827.   static getStyleAttributeFromElement_(cueElement, styles, attribute) {
  828.     const XmlUtils = shaka.util.XmlUtils;
  829.     const ttsNs = shaka.text.TtmlTextParser.styleNs_;
  831.     // Styling on elements should take precedence
  832.     // over the main styling attributes
  833.     const elementAttribute = XmlUtils.getAttributeNSList(
  834.         cueElement,
  835.         ttsNs,
  836.         attribute);
  838.     if (elementAttribute) {
  839.       return elementAttribute;
  840.     }
  841.     return shaka.text.TtmlTextParser.getInheritedStyleAttribute_(
  842.         cueElement, styles, attribute);
  843.   }
  845.   /**
  846.    * Finds a specified attribute on an element's styles and the styles those
  847.    * styles inherit from.
  848.    *
  849.    * @param {!Element} element
  850.    * @param {!Array.<!Element>} styles
  851.    * @param {string} attribute
  852.    * @return {?string}
  853.    * @private
  854.    */
  855.   static getInheritedStyleAttribute_(element, styles, attribute) {
  856.     const XmlUtils = shaka.util.XmlUtils;
  857.     const ttsNs = shaka.text.TtmlTextParser.styleNs_;
  858.     const ebuttsNs = shaka.text.TtmlTextParser.styleEbuttsNs_;
  860.     const inheritedStyles =
  861.         shaka.text.TtmlTextParser.getElementsFromCollection_(
  862.             element, 'style', styles, /* prefix= */ '');
  864.     let styleValue = null;
  866.     // The last value in our styles stack takes the precedence over the others
  867.     for (let i = 0; i < inheritedStyles.length; i++) {
  868.       // Check ebu namespace first.
  869.       let styleAttributeValue = XmlUtils.getAttributeNS(
  870.           inheritedStyles[i],
  871.           ebuttsNs,
  872.           attribute);
  874.       if (!styleAttributeValue) {
  875.         // Fall back to tts namespace.
  876.         styleAttributeValue = XmlUtils.getAttributeNSList(
  877.             inheritedStyles[i],
  878.             ttsNs,
  879.             attribute);
  880.       }
  882.       if (!styleAttributeValue) {
  883.         // Next, check inheritance.
  884.         // Styles can inherit from other styles, so traverse up that chain.
  885.         styleAttributeValue =
  886.             shaka.text.TtmlTextParser.getStyleAttributeFromElement_(
  887.                 inheritedStyles[i], styles, attribute);
  888.       }
  890.       if (styleAttributeValue) {
  891.         styleValue = styleAttributeValue;
  892.       }
  893.     }
  895.     return styleValue;
  896.   }
  899.   /**
  900.    * Selects items from |collection| whose id matches |attributeName|
  901.    * from |element|.
  902.    *
  903.    * @param {Element} element
  904.    * @param {string} attributeName
  905.    * @param {!Array.<Element>} collection
  906.    * @param {string} prefixName
  907.    * @param {string=} nsName
  908.    * @return {!Array.<!Element>}
  909.    * @private
  910.    */
  911.   static getElementsFromCollection_(
  912.       element, attributeName, collection, prefixName, nsName) {
  913.     const items = [];
  915.     if (!element || collection.length < 1) {
  916.       return items;
  917.     }
  919.     const attributeValue = shaka.text.TtmlTextParser.getInheritedAttribute_(
  920.         element, attributeName, nsName);
  922.     if (attributeValue) {
  923.       // There could be multiple items in one attribute
  924.       // <span style="style1 style2">A cue</span>
  925.       const itemNames = attributeValue.split(' ');
  927.       for (const name of itemNames) {
  928.         for (const item of collection) {
  929.           if ((prefixName + item.getAttribute('xml:id')) == name) {
  930.             items.push(item);
  931.             break;
  932.           }
  933.         }
  934.       }
  935.     }
  937.     return items;
  938.   }
  941.   /**
  942.    * Traverses upwards from a given node until a given attribute is found.
  943.    *
  944.    * @param {!Element} element
  945.    * @param {string} attributeName
  946.    * @param {string=} nsName
  947.    * @return {?string}
  948.    * @private
  949.    */
  950.   static getInheritedAttribute_(element, attributeName, nsName) {
  951.     let ret = null;
  952.     const XmlUtils = shaka.util.XmlUtils;
  953.     while (element) {
  954.       ret = nsName ?
  955.           XmlUtils.getAttributeNS(element, nsName, attributeName) :
  956.           element.getAttribute(attributeName);
  957.       if (ret) {
  958.         break;
  959.       }
  961.       // Element.parentNode can lead to XMLDocument, which is not an Element and
  962.       // has no getAttribute().
  963.       const parentNode = element.parentNode;
  964.       if (parentNode instanceof Element) {
  965.         element = parentNode;
  966.       } else {
  967.         break;
  968.       }
  969.     }
  970.     return ret;
  971.   }
  973.   /**
  974.    * Factor parent/ancestor time attributes into the parsed time of a
  975.    * child/descendent.
  976.    *
  977.    * @param {!Element} parentElement
  978.    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  979.    * @param {?number} start The child's start time
  980.    * @param {?number} end The child's end time
  981.    * @return {{start: ?number, end: ?number}}
  982.    * @private
  983.    */
  984.   static resolveTime_(parentElement, rateInfo, start, end) {
  985.     const parentTime = shaka.text.TtmlTextParser.parseTime_(
  986.         parentElement, rateInfo);
  988.     if (start == null) {
  989.       // No start time of your own?  Inherit from the parent.
  990.       start = parentTime.start;
  991.     } else {
  992.       // Otherwise, the start time is relative to the parent's start time.
  993.       if (parentTime.start != null) {
  994.         start += parentTime.start;
  995.       }
  996.     }
  998.     if (end == null) {
  999.       // No end time of your own?  Inherit from the parent.
  1000.       end = parentTime.end;
  1001.     } else {
  1002.       // Otherwise, the end time is relative to the parent's _start_ time.
  1003.       // This is not a typo.  Both times are relative to the parent's _start_.
  1004.       if (parentTime.start != null) {
  1005.         end += parentTime.start;
  1006.       }
  1007.     }
  1009.     return {start, end};
  1010.   }
  1012.   /**
  1013.    * Parse TTML time attributes from the given element.
  1014.    *
  1015.    * @param {!Element} element
  1016.    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  1017.    * @return {{start: ?number, end: ?number}}
  1018.    * @private
  1019.    */
  1020.   static parseTime_(element, rateInfo) {
  1021.     const start = shaka.text.TtmlTextParser.parseTimeAttribute_(
  1022.         element.getAttribute('begin'), rateInfo);
  1023.     let end = shaka.text.TtmlTextParser.parseTimeAttribute_(
  1024.         element.getAttribute('end'), rateInfo);
  1025.     const duration = shaka.text.TtmlTextParser.parseTimeAttribute_(
  1026.         element.getAttribute('dur'), rateInfo);
  1027.     if (end == null && duration != null) {
  1028.       end = start + duration;
  1029.     }
  1030.     return {start, end};
  1031.   }
  1033.   /**
  1034.    * Parses a TTML time from the given attribute text.
  1035.    *
  1036.    * @param {string} text
  1037.    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  1038.    * @return {?number}
  1039.    * @private
  1040.    */
  1041.   static parseTimeAttribute_(text, rateInfo) {
  1042.     let ret = null;
  1043.     const TtmlTextParser = shaka.text.TtmlTextParser;
  1045.     if (TtmlTextParser.timeColonFormatFrames_.test(text)) {
  1046.       ret = TtmlTextParser.parseColonTimeWithFrames_(rateInfo, text);
  1047.     } else if (TtmlTextParser.timeColonFormat_.test(text)) {
  1048.       ret = TtmlTextParser.parseTimeFromRegex_(
  1049.           TtmlTextParser.timeColonFormat_, text);
  1050.     } else if (TtmlTextParser.timeColonFormatMilliseconds_.test(text)) {
  1051.       ret = TtmlTextParser.parseTimeFromRegex_(
  1052.           TtmlTextParser.timeColonFormatMilliseconds_, text);
  1053.     } else if (TtmlTextParser.timeFramesFormat_.test(text)) {
  1054.       ret = TtmlTextParser.parseFramesTime_(rateInfo, text);
  1055.     } else if (TtmlTextParser.timeTickFormat_.test(text)) {
  1056.       ret = TtmlTextParser.parseTickTime_(rateInfo, text);
  1057.     } else if (TtmlTextParser.timeHMSFormat_.test(text)) {
  1058.       ret = TtmlTextParser.parseTimeFromRegex_(
  1059.           TtmlTextParser.timeHMSFormat_, text);
  1060.     } else if (text) {
  1061.       // It's not empty or null, but it doesn't match a known format.
  1062.       throw new shaka.util.Error(
  1063.           shaka.util.Error.Severity.CRITICAL,
  1064.           shaka.util.Error.Category.TEXT,
  1065.           shaka.util.Error.Code.INVALID_TEXT_CUE,
  1066.           'Could not parse cue time range in TTML');
  1067.     }
  1069.     return ret;
  1070.   }
  1072.   /**
  1073.    * Parses a TTML time in frame format.
  1074.    *
  1075.    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  1076.    * @param {string} text
  1077.    * @return {?number}
  1078.    * @private
  1079.    */
  1080.   static parseFramesTime_(rateInfo, text) {
  1081.     // 75f or 75.5f
  1082.     const results = shaka.text.TtmlTextParser.timeFramesFormat_.exec(text);
  1083.     const frames = Number(results[1]);
  1085.     return frames / rateInfo.frameRate;
  1086.   }
  1088.   /**
  1089.    * Parses a TTML time in tick format.
  1090.    *
  1091.    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  1092.    * @param {string} text
  1093.    * @return {?number}
  1094.    * @private
  1095.    */
  1096.   static parseTickTime_(rateInfo, text) {
  1097.     // 50t or 50.5t
  1098.     const results = shaka.text.TtmlTextParser.timeTickFormat_.exec(text);
  1099.     const ticks = Number(results[1]);
  1101.     return ticks / rateInfo.tickRate;
  1102.   }
  1104.   /**
  1105.    * Parses a TTML colon formatted time containing frames.
  1106.    *
  1107.    * @param {!shaka.text.TtmlTextParser.RateInfo_} rateInfo
  1108.    * @param {string} text
  1109.    * @return {?number}
  1110.    * @private
  1111.    */
  1112.   static parseColonTimeWithFrames_(rateInfo, text) {
  1113.     // 01:02:43:07 ('07' is frames) or 01:02:43:07.1 (subframes)
  1114.     const results = shaka.text.TtmlTextParser.timeColonFormatFrames_.exec(text);
  1116.     const hours = Number(results[1]);
  1117.     const minutes = Number(results[2]);
  1118.     let seconds = Number(results[3]);
  1119.     let frames = Number(results[4]);
  1120.     const subframes = Number(results[5]) || 0;
  1122.     frames += subframes / rateInfo.subFrameRate;
  1123.     seconds += frames / rateInfo.frameRate;
  1125.     return seconds + (minutes * 60) + (hours * 3600);
  1126.   }
  1128.   /**
  1129.    * Parses a TTML time with a given regex. Expects regex to be some
  1130.    * sort of a time-matcher to match hours, minutes, seconds and milliseconds
  1131.    *
  1132.    * @param {!RegExp} regex
  1133.    * @param {string} text
  1134.    * @return {?number}
  1135.    * @private
  1136.    */
  1137.   static parseTimeFromRegex_(regex, text) {
  1138.     const results = regex.exec(text);
  1139.     if (results == null || results[0] == '') {
  1140.       return null;
  1141.     }
  1142.     // This capture is optional, but will still be in the array as undefined,
  1143.     // in which case it is 0.
  1144.     const hours = Number(results[1]) || 0;
  1145.     const minutes = Number(results[2]) || 0;
  1146.     const seconds = Number(results[3]) || 0;
  1147.     const milliseconds = Number(results[4]) || 0;
  1149.     return (milliseconds / 1000) + seconds + (minutes * 60) + (hours * 3600);
  1150.   }
  1152.   /**
  1153.    * If ttp:cellResolution provided returns cell resolution info
  1154.    * with number of columns and rows into which the Root Container
  1155.    * Region area is divided
  1156.    *
  1157.    * @param {?string} cellResolution
  1158.    * @return {?{columns: number, rows: number}}
  1159.    * @private
  1160.    */
  1161.   static getCellResolution_(cellResolution) {
  1162.     if (!cellResolution) {
  1163.       return null;
  1164.     }
  1165.     const matches = /^(\d+) (\d+)$/.exec(cellResolution);
  1167.     if (!matches) {
  1168.       return null;
  1169.     }
  1171.     const columns = parseInt(matches[1], 10);
  1172.     const rows = parseInt(matches[2], 10);
  1174.     return {columns, rows};
  1175.   }
  1176. };
  1178. /**
  1179.  * @summary
  1180.  * Contains information about frame/subframe rate
  1181.  * and frame rate multiplier for time in frame format.
  1182.  *
  1183.  * @example 01:02:03:04(4 frames) or 01:02:03:04.1(4 frames, 1 subframe)
  1184.  * @private
  1185.  */
  1186. shaka.text.TtmlTextParser.RateInfo_ = class {
  1187.   /**
  1188.    * @param {?string} frameRate
  1189.    * @param {?string} subFrameRate
  1190.    * @param {?string} frameRateMultiplier
  1191.    * @param {?string} tickRate
  1192.    */
  1193.   constructor(frameRate, subFrameRate, frameRateMultiplier, tickRate) {
  1194.     /**
  1195.      * @type {number}
  1196.      */
  1197.     this.frameRate = Number(frameRate) || 30;
  1199.     /**
  1200.      * @type {number}
  1201.      */
  1202.     this.subFrameRate = Number(subFrameRate) || 1;
  1204.     /**
  1205.      * @type {number}
  1206.      */
  1207.     this.tickRate = Number(tickRate);
  1208.     if (this.tickRate == 0) {
  1209.       if (frameRate) {
  1210.         this.tickRate = this.frameRate * this.subFrameRate;
  1211.       } else {
  1212.         this.tickRate = 1;
  1213.       }
  1214.     }
  1216.     if (frameRateMultiplier) {
  1217.       const multiplierResults = /^(\d+) (\d+)$/g.exec(frameRateMultiplier);
  1218.       if (multiplierResults) {
  1219.         const numerator = Number(multiplierResults[1]);
  1220.         const denominator = Number(multiplierResults[2]);
  1221.         const multiplierNum = numerator / denominator;
  1222.         this.frameRate *= multiplierNum;
  1223.       }
  1224.     }
  1225.   }
  1226. };
  1228. /**
  1229.  * @const
  1230.  * @private {!RegExp}
  1231.  * @example 50.17% 10%
  1232.  */
  1233. shaka.text.TtmlTextParser.percentValues_ =
  1234.     /^(\d{1,2}(?:\.\d+)?|100(?:\.0+)?)% (\d{1,2}(?:\.\d+)?|100(?:\.0+)?)%$/;
  1236. /**
  1237.  * @const
  1238.  * @private {!RegExp}
  1239.  * @example 0.6% 90%
  1240.  */
  1241. shaka.text.TtmlTextParser.percentValue_ = /^(\d{1,2}(?:\.\d+)?|100)%$/;
  1243. /**
  1244.  * @const
  1245.  * @private {!RegExp}
  1246.  * @example 100px, 8em, 0.80c
  1247.  */
  1248. shaka.text.TtmlTextParser.unitValues_ = /^(\d+px|\d+em|\d*\.?\d+c)$/;
  1250. /**
  1251.  * @const
  1252.  * @private {!RegExp}
  1253.  * @example 100px
  1254.  */
  1255. shaka.text.TtmlTextParser.pixelValues_ = /^(\d+)px (\d+)px$/;
  1257. /**
  1258.  * @const
  1259.  * @private {!RegExp}
  1260.  * @example 00:00:40:07 (7 frames) or 00:00:40:07.1 (7 frames, 1 subframe)
  1261.  */
  1262. shaka.text.TtmlTextParser.timeColonFormatFrames_ =
  1263.     /^(\d{2,}):(\d{2}):(\d{2}):(\d{2})\.?(\d+)?$/;
  1265. /**
  1266.  * @const
  1267.  * @private {!RegExp}
  1268.  * @example 00:00:40 or 00:40
  1269.  */
  1270. shaka.text.TtmlTextParser.timeColonFormat_ = /^(?:(\d{2,}):)?(\d{2}):(\d{2})$/;
  1272. /**
  1273.  * @const
  1274.  * @private {!RegExp}
  1275.  * @example 01:02:43.0345555 or 02:43.03
  1276.  */
  1277. shaka.text.TtmlTextParser.timeColonFormatMilliseconds_ =
  1278.     /^(?:(\d{2,}):)?(\d{2}):(\d{2}\.\d{2,})$/;
  1280. /**
  1281.  * @const
  1282.  * @private {!RegExp}
  1283.  * @example 75f or 75.5f
  1284.  */
  1285. shaka.text.TtmlTextParser.timeFramesFormat_ = /^(\d*(?:\.\d*)?)f$/;
  1287. /**
  1288.  * @const
  1289.  * @private {!RegExp}
  1290.  * @example 50t or 50.5t
  1291.  */
  1292. shaka.text.TtmlTextParser.timeTickFormat_ = /^(\d*(?:\.\d*)?)t$/;
  1294. /**
  1295.  * @const
  1296.  * @private {!RegExp}
  1297.  * @example 3.45h, 3m or 4.20s
  1298.  */
  1299. shaka.text.TtmlTextParser.timeHMSFormat_ =
  1300.     new RegExp(['^(?:(\\d*(?:\\.\\d*)?)h)?',
  1301.       '(?:(\\d*(?:\\.\\d*)?)m)?',
  1302.       '(?:(\\d*(?:\\.\\d*)?)s)?',
  1303.       '(?:(\\d*(?:\\.\\d*)?)ms)?$'].join(''));
  1305. /**
  1306.  * @const
  1307.  * @private {!Object.<string, shaka.text.Cue.lineAlign>}
  1308.  */
  1309. shaka.text.TtmlTextParser.textAlignToLineAlign_ = {
  1310.   'left': shaka.text.Cue.lineAlign.START,
  1311.   'center': shaka.text.Cue.lineAlign.CENTER,
  1312.   'right': shaka.text.Cue.lineAlign.END,
  1313.   'start': shaka.text.Cue.lineAlign.START,
  1314.   'end': shaka.text.Cue.lineAlign.END,
  1315. };
  1317. /**
  1318.  * @const
  1319.  * @private {!Object.<string, shaka.text.Cue.positionAlign>}
  1320.  */
  1321. shaka.text.TtmlTextParser.textAlignToPositionAlign_ = {
  1322.   'left': shaka.text.Cue.positionAlign.LEFT,
  1323.   'center': shaka.text.Cue.positionAlign.CENTER,
  1324.   'right': shaka.text.Cue.positionAlign.RIGHT,
  1325. };
  1327. /**
  1328.  * The namespace URL for TTML parameters.  Can be assigned any name in the TTML
  1329.  * document, not just "ttp:", so we use this with getAttributeNS() to ensure
  1330.  * that we support arbitrary namespace names.
  1331.  *
  1332.  * @const {!Array.<string>}
  1333.  * @private
  1334.  */
  1335. shaka.text.TtmlTextParser.parameterNs_ = [
  1336.   'http://www.w3.org/ns/ttml#parameter',
  1337.   'http://www.w3.org/2006/10/ttaf1#parameter',
  1338. ];
  1340. /**
  1341.  * The namespace URL for TTML styles.  Can be assigned any name in the TTML
  1342.  * document, not just "tts:", so we use this with getAttributeNS() to ensure
  1343.  * that we support arbitrary namespace names.
  1344.  *
  1345.  * @const {!Array.<string>}
  1346.  * @private
  1347.  */
  1348. shaka.text.TtmlTextParser.styleNs_ = [
  1349.   'http://www.w3.org/ns/ttml#styling',
  1350.   'http://www.w3.org/2006/10/ttaf1#styling',
  1351. ];
  1353. /**
  1354.  * The namespace URL for EBU TTML styles.  Can be assigned any name in the TTML
  1355.  * document, not just "ebutts:", so we use this with getAttributeNS() to ensure
  1356.  * that we support arbitrary namespace names.
  1357.  *
  1358.  * @const {string}
  1359.  * @private
  1360.  */
  1361. shaka.text.TtmlTextParser.styleEbuttsNs_ = 'urn:ebu:tt:style';
  1363. /**
  1364.  * The supported namespace URLs for SMPTE fields.
  1365.  * @const {!Array.<string>}
  1366.  * @private
  1367.  */
  1368. shaka.text.TtmlTextParser.smpteNsList_ = [
  1369.   'http://www.smpte-ra.org/schemas/2052-1/2010/smpte-tt',
  1370.   'http://www.smpte-ra.org/schemas/2052-1/2013/smpte-tt',
  1371. ];
  1373. shaka.text.TextEngine.registerParser(
  1374.     'application/ttml+xml', () => new shaka.text.TtmlTextParser());