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