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