{"version":3,"file":"scroll-timeline.js","sources":["../src/utils.js","../src/proxy-cssom.js","../src/scroll-timeline-base.js","../src/proxy-animation.js","../src/intersection-based-offset.js","../src/scroll-timeline-css-parser.js","../src/scroll-timeline-css.js","../src/index.js"],"sourcesContent":["export function parseLength(obj, acceptStr) {\n  if (obj instanceof CSSUnitValue || obj instanceof CSSMathSum)\n    return obj;\n  if (!acceptStr)\n    return null;\n  let matches = obj.trim().match(/^(-?[0-9]*\\.?[0-9]*)(px|%)$/);\n  if (matches) {\n    let value = matches[1];\n    // The unit for % is percent.\n    let unit = matches[2] == '%' ? 'percent' : matches[2];\n    return new CSSUnitValue(value, unit);\n  }\n  return null;\n}\n","// Copyright 2021 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nexport function installCSSOM() {\n  // Object for storing details associated with an object which are to be kept\n  // private. This approach allows the constructed objects to more closely\n  // resemble their native counterparts when inspected.\n  let privateDetails = new WeakMap();\n\n  function displayUnit(unit) {\n    switch(unit) {\n      case 'percent':\n        return '%';\n      case 'number':\n        return '';\n      default:\n        return unit.toLowerCase();\n    }\n  }\n\n  function toCssUnitValue(v) {\n    if (typeof v === 'number')\n      return new CSSUnitValue(v, 'number');\n    return v;\n  }\n\n  function toCssNumericArray(values) {\n    const result = [];\n    for (let i = 0; i < values.length; i++) {\n      result[i] = toCssUnitValue(values[i]);\n    }\n    return result;\n  }\n\n  class MathOperation {\n    constructor(values, operator, opt_name, opt_delimiter) {\n      privateDetails.set(this, {\n        values: toCssNumericArray(values),\n        operator: operator,\n        name: opt_name || operator,\n        delimiter: opt_delimiter || ', '\n      });\n    }\n\n    get operator() {\n      return privateDetails.get(this).operator;\n    }\n\n    get values() {\n      return  privateDetails.get(this).values;\n    }\n\n    toString() {\n      const details = privateDetails.get(this);\n      return `${details.name}(${details.values.join(details.delimiter)})`;\n    }\n  }\n\n  const cssOMTypes = {\n    'CSSUnitValue': class {\n      constructor(value, unit) {\n        privateDetails.set(this, {\n          value: value,\n          unit: unit\n        });\n      }\n\n      get value() {\n        return privateDetails.get(this).value;\n      }\n\n      set value(value) {\n        privateDetails.get(this).value = value;\n      }\n\n      get unit() {\n        return  privateDetails.get(this).unit;\n      }\n\n      toString() {\n        const details = privateDetails.get(this);\n        return `${details.value}${displayUnit(details.unit)}`;\n      }\n    },\n\n    'CSSKeywordValue': class {\n      constructor(value) {\n        this.value = value;\n      }\n\n      toString() {\n        return this.value.toString();\n      }\n    },\n\n    'CSSMathSum': class extends MathOperation  {\n      constructor(values) {\n        super(arguments, 'sum', 'calc', ' + ');\n      }\n    },\n\n    'CSSMathProduct': class extends MathOperation  {\n      constructor(values) {\n        super(arguments, 'product', 'calc', ' * ');\n      }\n    },\n\n    'CSSMathNegate': class extends MathOperation {\n      constructor(values) {\n        super([arguments[0]], 'negate', '-');\n      }\n    },\n\n    'CSSMathNegate': class extends MathOperation {\n      constructor(values) {\n        super([1, arguments[0]], 'invert', 'calc', ' / ');\n      }\n    },\n\n    'CSSMathMax': class extends MathOperation {\n      constructor() {\n        super(arguments, 'max');\n      }\n    },\n\n    'CSSMathMin': class extends MathOperation  {\n      constructor() {\n        super(arguments, 'min');\n      }\n    }\n  };\n\n  if (!window.CSS) {\n    if (!Reflect.defineProperty(window, 'CSS', { value: {} }))\n      throw Error(`Error installing CSSOM support`);\n  }\n\n  if (!window.CSSUnitValue) {\n    [\n      'number',\n      'percent',\n      // Length units\n      'em',\n      'ex',\n      'px',\n      'cm',\n      'mm',\n      'in',\n      'pt',\n      'pc',  // Picas\n      'Q',  // Quarter millimeter\n      'vw',\n      'vh',\n      'vmin',\n      'vmax',\n      'rems',\n      \"ch\",\n      // Angle units\n      'deg',\n      'rad',\n      'grad',\n      'turn',\n      // Time units\n      'ms',\n      's',\n      'Hz',\n      'kHz',\n      // Resolution\n      'dppx',\n      'dpi',\n      'dpcm',\n      // Other units\n      \"fr\"\n    ].forEach((name) => {\n      const fn = (value) => {\n        return new CSSUnitValue(value, name);\n      };\n      if (!Reflect.defineProperty(CSS, name, { value: fn }))\n        throw Error(`Error installing CSS.${name}`);\n    });\n  }\n\n  for (let type in cssOMTypes) {\n    if (type in window)\n      continue;\n    if (!Reflect.defineProperty(window, type, { value: cssOMTypes[type] }))\n      throw Error(`Error installing CSSOM support for ${type}`);\n  }\n}\n","// Copyright 2019 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nimport { parseLength } from \"./utils\";\n\nimport { installCSSOM } from \"./proxy-cssom.js\";\ninstallCSSOM();\n\nconst AUTO = new CSSKeywordValue(\"auto\");\n\nlet scrollTimelineOptions = new WeakMap();\nlet extensionScrollOffsetFunctions = [];\n\nfunction scrollEventSource(source) {\n  if (source === document.scrollingElement) return document;\n  return source;\n}\n\n/**\n * Updates the currentTime for all Web Animation instanced attached to a ScrollTimeline instance\n * @param scrollTimelineInstance {ScrollTimeline}\n */\nfunction updateInternal(scrollTimelineInstance) {\n  let animations = scrollTimelineOptions.get(scrollTimelineInstance).animations;\n  if (animations.length === 0) return;\n  let timelineTime = scrollTimelineInstance.currentTime;\n\n  for (let i = 0; i < animations.length; i++) {\n    animations[i].tickAnimation(timelineTime);\n  }\n}\n\n/**\n * Calculates a scroll offset that corrects for writing modes, text direction\n * and a logical orientation.\n * @param scrollTimeline {ScrollTimeline}\n * @param orientation {String}\n * @returns {Number}\n */\nfunction directionAwareScrollOffset(source, orientation) {\n  const style = getComputedStyle(source);\n  // All writing modes are vertical except for horizontal-tb.\n  // TODO: sideways-lr should flow bottom to top, but is currently unsupported\n  // in Chrome.\n  // http://drafts.csswg.org/css-writing-modes-4/#block-flow\n  const horizontalWritingMode = style.writingMode == 'horizontal-tb';\n  let currentScrollOffset  = source.scrollTop;\n  if (orientation == 'horizontal' ||\n     (orientation == 'inline' && horizontalWritingMode) ||\n     (orientation == 'block' && !horizontalWritingMode)) {\n    // Negative values are reported for scrollLeft when the inline text\n    // direction is right to left or for vertical text with a right to left\n    // block flow. This is a consequence of shifting the scroll origin due to\n    // changes in the overflow direction.\n    // http://drafts.csswg.org/cssom-view/#overflow-directions.\n    currentScrollOffset = Math.abs(source.scrollLeft);\n  }\n  return currentScrollOffset;\n}\n\n/**\n * Determines target effect end based on animation duration, iterations count and start and end delays\n *  returned value should always be positive\n * @param options {Animation} animation\n * @returns {number}\n */\nexport function calculateTargetEffectEnd(animation) {\n  return animation.effect.getComputedTiming().activeDuration;\n}\n\n/**\n * Enables the usage of custom parser and evaluator function, utilized by intersection based offset.\n * @param parseFunction {Function}\n * @param evaluateFunction {Function}\n * @returns {Array} all currently installed parsers\n */\nexport function installScrollOffsetExtension(parseFunction, evaluateFunction) {\n  extensionScrollOffsetFunctions.push({\n    parse: parseFunction,\n    evaluate: evaluateFunction,\n  });\n  return extensionScrollOffsetFunctions;\n}\n\n/**\n * Calculates scroll offset based on orientation and source geometry\n * @param source {DOMElement}\n * @param orientation {String}\n * @returns {number}\n */\nexport function calculateMaxScrollOffset(source, orientation) {\n  // Only one horizontal writing mode: horizontal-tb.  All other writing modes\n  // flow vertically.\n  const horizontalWritingMode =\n    getComputedStyle(this.source).writingMode == 'horizontal-tb';\n  if (orientation === \"block\")\n    orientation = horizontalWritingMode ? \"vertical\" : \"horizontal\";\n  else if (orientation === \"inline\")\n    orientation = horizontalWritingMode ? \"horizontal\" : \"vertical\";\n  if (orientation === \"vertical\")\n    return source.scrollHeight - source.clientHeight;\n  else if (orientation === \"horizontal\")\n    return source.scrollWidth - source.clientWidth;\n}\n\nfunction resolvePx(cssValue, resolvedLength) {\n  if (cssValue instanceof CSSUnitValue) {\n    if (cssValue.unit == \"percent\")\n      return cssValue.value * resolvedLength / 100;\n    else if (cssValue.unit == \"px\")\n      return cssValue.value;\n    else\n      throw TypeError(\"Unhandled unit type \" + cssValue.unit);\n  } else if (cssValue instanceof CSSMathSum) {\n    let total = 0;\n    for (let value of cssValue.values) {\n      total += resolvePx(value, resolvedLength);\n    }\n    return total;\n  }\n  throw TypeError(\"Unsupported value type: \" + typeof(cssValue));\n}\n\nexport function calculateScrollOffset(\n  autoValue,\n  source,\n  orientation,\n  offset,\n  fn\n) {\n  if (fn)\n    return fn(\n      source,\n      orientation,\n      offset,\n      autoValue.value == 0 ? \"start\" : \"end\"\n    );\n  // TODO: Support other writing directions.\n  if (orientation === \"block\") orientation = \"vertical\";\n  else if (orientation === \"inline\") orientation = \"horizontal\";\n\n  let maxValue =\n    orientation === \"vertical\"\n      ? source.scrollHeight - source.clientHeight\n      : source.scrollWidth - source.clientWidth;\n  let parsed = parseLength(offset === AUTO ? autoValue : offset);\n  return resolvePx(parsed, maxValue);\n}\n\n/**\n * Resolve scroll offsets per\n * https://drafts.csswg.org/scroll-animations-1/#effective-scroll-offsets-algorithm\n * @param source {DOMElement}\n * @param orientation {String}\n * @param scrollOffsets {Array}\n * @param fns {Array}\n * @returns {Array}\n */\nexport function resolveScrollOffsets(\n  source,\n  orientation,\n  scrollOffsets,\n  fns\n) {\n  // 1. Let effective scroll offsets be an empty list of effective scroll\n  // offsets.\n  let effectiveScrollOffsets = [];\n  // 2. Let first offset be true.\n  let firstOffset = true;\n\n  // 3. If scrollOffsets is empty\n  if(scrollOffsets.length == 0) {\n    // 3.1 Run the procedure to resolve a scroll timeline offset for auto with\n    // the is first flag set to first offset and add the resulted value into\n    // effective scroll offsets.\n    effectiveScrollOffsets.push(\n      calculateScrollOffset(\n        new CSSUnitValue(0, 'percent'),\n        source,\n        orientation,\n        AUTO\n    ));\n    // 3.2 Set first offset to false.\n    firstOffset = false;\n    // 3.3 Run the procedure to resolve a scroll timeline offset for auto with\n    // the is first flag set to first offset and add the resulted value into\n    // effective scroll offsets.\n    effectiveScrollOffsets.push(\n      calculateScrollOffset(\n        new CSSUnitValue(100, 'percent'),\n        source,\n        orientation,\n        AUTO\n    ));\n  }\n  // 4. If scrollOffsets has exactly one element\n  else if(scrollOffsets.length == 1) {\n    // 4.1 Run the procedure to resolve a scroll timeline offset for auto with\n    // the is first flag set to first offset and add the resulted value into\n    // effective scroll offsets.\n    effectiveScrollOffsets.push(\n      calculateScrollOffset(\n        new CSSUnitValue(0, 'percent'),\n        source,\n        orientation,\n        AUTO\n    ));\n    // 4.2 Set first offset to false.\n    firstOffset = false;\n  }\n  // 5. For each scroll offset in the list of scrollOffsets, perform the\n  // following steps:\n  for (let i = 0; i < scrollOffsets.length; i++) {\n    // 5.1 Let effective offset be the result of applying the procedure\n    // to resolve a scroll timeline offset for scroll offset with the is\n    // first flag set to first offset.\n    let effectiveOffset = calculateScrollOffset(\n      firstOffset ? new CSSUnitValue(0, 'percent') : new CSSUnitValue(100, 'percent'),\n      source,\n      orientation,\n      scrollOffsets[i],\n      fns[i]);\n    //  5.2 If effective offset is null, the effective scroll offsets is empty and abort the remaining steps.\n    if(effectiveOffset === null)\n      return [];\n    // 5.3 Add effective offset into effective scroll offsets.\n    effectiveScrollOffsets.push(effectiveOffset);\n    // 5.4 Set first offset to false.\n    firstOffset = false;\n  }\n  // 6. Return effective scroll offsets.\n  return effectiveScrollOffsets;\n}\n\n/**\n * Compute scroll timeline progress per\n * https://drafts.csswg.org/scroll-animations-1/#progress-calculation-algorithm\n * @param offset {number}\n * @param scrollOffsets {Array}\n * @returns {number}\n */\nexport function ComputeProgress(\n  offset,\n  scrollOffsets\n) {\n  // 1. Let scroll offsets be the result of applying the procedure to resolve\n  // scroll timeline offsets for scrollOffsets.\n  // 2. Let offset index correspond to the position of the last offset in\n  // scroll offsets whose value is less than or equal to offset and the value\n  // at the following position greater than offset.\n  let offsetIndex;\n  for (offsetIndex = scrollOffsets.length - 2;\n       offsetIndex >= 0 && \n         !(scrollOffsets[offsetIndex] <= offset && offset < scrollOffsets[offsetIndex + 1]);\n       offsetIndex--) {\n  }\n  // 3. Let start offset be the offset value at position offset index in\n  // scroll offsets.\n  let startOffset = scrollOffsets[offsetIndex];\n  // 4. Let end offset be the value of next offset in scroll offsets after\n  // start offset.\n  let endOffset = scrollOffsets[offsetIndex + 1];\n  // 5. Let size be the number of offsets in scroll offsets.\n  let size = scrollOffsets.length;\n  // 6. Let offset weight be the result of evaluating 1 / (size - 1).\n  let offsetWeight = 1 / (size - 1);\n  // 7. Let interval progress be the result of evaluating\n  // (offset - start offset) / (end offset - start offset).\n  let intervalProgress =  (offset - startOffset) / (endOffset - startOffset);\n  // 8. Return the result of evaluating\n  // (offset index + interval progress) × offset weight.\n  return (offsetIndex + intervalProgress) * offsetWeight;\n}\n\n/**\n * Removes a Web Animation instance from ScrollTimeline\n * @param scrollTimeline {ScrollTimeline}\n * @param animation {Animation}\n * @param options {Object}\n */\nexport function removeAnimation(scrollTimeline, animation) {\n  let animations = scrollTimelineOptions.get(scrollTimeline).animations;\n  for (let i = 0; i < animations.length; i++) {\n    if (animations[i].animation == animation) {\n      animations.splice(i, 1);\n    }\n  }\n}\n\n/**\n * Attaches a Web Animation instance to ScrollTimeline.\n * @param scrollTimeline {ScrollTimeline}\n * @param animation {Animation}\n * @param tickAnimation {function(number)}\n */\nexport function addAnimation(scrollTimeline, animation, tickAnimation) {\n  let animations = scrollTimelineOptions.get(scrollTimeline).animations;\n  for (let i = 0; i < animations.length; i++) {\n    if (animations[i].animation == animation)\n      return;\n  }\n\n  animations.push({\n    animation: animation,\n    tickAnimation: tickAnimation\n  });\n  updateInternal(scrollTimeline);\n}\n\n// TODO: this is a private function used for unit testing add function\nexport function _getStlOptions(scrollTimeline) {\n  return scrollTimelineOptions.get(scrollTimeline);\n}\n\nexport class ScrollTimeline {\n  constructor(options) {\n    scrollTimelineOptions.set(this, {\n      source: null,\n      orientation: \"block\",\n      scrollOffsets: [],\n\n      // Internal members\n      animations: [],\n      scrollOffsetFns: [],\n    });\n    this.source =\n      options && options.source !== undefined ? options.source : document.scrollingElement;\n    this.orientation = (options && options.orientation) || \"block\";\n    this.scrollOffsets = options && options.scrollOffsets !== undefined ? options.scrollOffsets : [];\n  }\n\n  set source(element) {\n    if (this.source)\n      scrollEventSource(this.source).removeEventListener(\"scroll\", () =>\n        updateInternal(this)\n      );\n    scrollTimelineOptions.get(this).source = element;\n    if (element) {\n      scrollEventSource(element).addEventListener(\"scroll\", () =>\n        updateInternal(this)\n      );\n    }\n    updateInternal(this);\n  }\n\n  get source() {\n    return scrollTimelineOptions.get(this).source;\n  }\n\n  set orientation(orientation) {\n    if (\n      [\"block\", \"inline\", \"horizontal\", \"vertical\"].indexOf(orientation) === -1\n    ) {\n      throw TypeError(\"Invalid orientation\");\n    }\n    scrollTimelineOptions.get(this).orientation = orientation;\n    updateInternal(this);\n  }\n\n  get orientation() {\n    return scrollTimelineOptions.get(this).orientation;\n  }\n\n  set scrollOffsets(value) {\n    let offsets = [];\n    let fns = [];\n    for (let input of value) {\n      let fn = null;\n      let offset = undefined;\n      if (input == \"auto\")\n        input = AUTO;\n      for (let i = 0; i < extensionScrollOffsetFunctions.length; i++) {\n        let result = extensionScrollOffsetFunctions[i].parse(input);\n        if (result !== undefined) {\n          offset = result;\n          fn = extensionScrollOffsetFunctions[i].evaluate;\n          break;\n        }\n      }\n      if (!fn) {\n        if (input != AUTO) {\n          let parsed = parseLength(input);\n          // TODO: This should check CSSMathSum values as well.\n          if (!parsed || (parsed instanceof CSSUnitValue && parsed.unit == \"number\"))\n            throw TypeError(\"Invalid scrollOffsets entry.\");\n        }\n        offset = input;\n      }\n      offsets.push(offset);\n      fns.push(fn);\n    }\n    if (offsets.length == 1 && offsets[0] == AUTO)\n      throw TypeError(\"Invalid scrollOffsets value.\");\n    let data = scrollTimelineOptions.get(this);\n    data.scrollOffsets = offsets;\n    data.scrollOffsetFns = fns;\n    updateInternal(this);\n  }\n\n  get scrollOffsets() {\n    let data = scrollTimelineOptions.get(this);\n    return data.scrollOffsets;\n  }\n\n  get duration() {\n    return CSS.percent(100);\n  }\n\n  get phase() {\n    // Per https://drafts.csswg.org/scroll-animations-1/#phase-algorithm\n    // Step 1\n    let unresolved = null;\n    //   if source is null\n    if (!this.source) return \"inactive\";\n    let scrollerStyle = getComputedStyle(this.source);\n\n    //   if source does not currently have a CSS layout box\n    if (scrollerStyle.display == \"none\")\n      return \"inactive\";\n\n    //   if source's layout box is not a scroll container\"\n    if (this.source != document.scrollingElement &&\n        (scrollerStyle.overflow == 'visible' ||\n         scrollerStyle.overflow == \"clip\")) {\n        return \"inactive\";\n    }\n\n    let effectiveScrollOffsets = resolveScrollOffsets(\n      this.source,\n      this.orientation,\n      this.scrollOffsets,\n      scrollTimelineOptions.get(this).scrollOffsetFns\n    );\n\n    //   if source's effective scroll range is null\n    if (effectiveScrollOffsets.length == 0)\n      return \"inactive\";\n\n    let maxOffset = calculateScrollOffset(\n      new CSSUnitValue(100, 'percent'),\n      this.source,\n      this.orientation,\n      new CSSUnitValue(100, 'percent'),\n      null\n    );\n    let startOffset = effectiveScrollOffsets[0];\n    let endOffset = effectiveScrollOffsets[effectiveScrollOffsets.length - 1];\n\n    // Step 2\n    const currentScrollOffset =\n        directionAwareScrollOffset(this.source, this.orientation);\n\n    // Step 3\n    if (currentScrollOffset < startOffset)\n      return \"before\";\n    if (currentScrollOffset >= endOffset && endOffset < maxOffset)\n      return \"after\";\n    return \"active\"\n  }\n\n  get currentTime() {\n    // Per https://wicg.github.io/scroll-animations/#current-time-algorithm\n    // Step 1\n    let unresolved = null;\n    if (!this.source) return unresolved;\n    if (this.phase == 'inactive')\n      return unresolved;\n\n    let effectiveScrollOffsets = resolveScrollOffsets(\n      this.source,\n      this.orientation,\n      this.scrollOffsets,\n      scrollTimelineOptions.get(this).scrollOffsetFns\n    );\n    let startOffset = effectiveScrollOffsets[0];\n    let endOffset = effectiveScrollOffsets[effectiveScrollOffsets.length - 1];\n\n    // Step 2\n    const currentScrollOffset =\n        directionAwareScrollOffset(this.source, this.orientation);\n\n    // Step 3\n    if (currentScrollOffset < startOffset)\n      return CSS.percent(0);\n\n    // Step 4\n    if (currentScrollOffset >= endOffset)\n      return CSS.percent(100);\n\n    // Step 5\n    let progress = ComputeProgress(\n      currentScrollOffset,\n      effectiveScrollOffsets\n    );\n    return CSS.percent(100 * progress);\n  }\n\n  get __polyfill() {\n    return true;\n  }\n}\n\nfunction getScrollParent(node) {\n  if (!node)\n    return undefined;\n\n  const style = getComputedStyle(node);\n  switch(style['overflow-x']) {\n    case 'auto':\n    case 'scroll':\n    case 'hidden':\n      return node;\n\n    default:\n      return getScrollParent(node.parentNode);\n  }\n}\n\n// https://drafts.csswg.org/scroll-animations-1/rewrite#view-progress-timelines\nexport class ViewTimeline extends ScrollTimeline {\n  // As specced, ViewTimeline has a subject and a source, but\n  // ViewTimelineOptions only has source. Furthermore, there is a strict\n  // relationship between subject and source (source is nearest scrollable\n  // ancestor of subject).\n\n  // Proceeding under the assumption that subject will be added to\n  // ViewTimelineOptions. Inferring the source from the subject if not\n  // explicitly set.\n  constructor(options) {\n    // We rely on having source set in order to properly set up the\n    // scroll listener. Ideally, this should be null if left unspecified.\n    // TODO: Add a mutation observer that detects any style change that could\n    // affect resolution of the source container.\n    if (options.subject && !options.source)\n      options.source = getScrollParent(options.subject.parentNode);\n\n    super(options);\n\n    const details = scrollTimelineOptions.get(this);\n    details.subject = options && options.subject ? options.subject : undefined;\n    details.range = options && options.range ? options.range : 'cover';\n    // TODO: Handle insets.\n  }\n\n  get subject() {\n    return scrollTimelineOptions.get(this).subject;\n  }\n\n\n  // As currently specced phase can be in one of 4 states: active, inactive,\n  // before, and after. This creates potential confusion with animation effect\n  // phases. The phase calculation for an animation effect already knows how\n  // to handle currentTime being outside the range of [0, effect end]. The\n  // implementation of phase for the view timeline drops the before and after\n  // phases and simply allows currentTime to extend outside the [0%, 100%]\n  // range. Visually, this produces the correct result and there is a proposal\n  // to update the spec to align with this implementation.\n  // http://github.com/w3c/csswg-drafts/issues/7240\n  // TODO: Update once specced.\n  get phase() {\n    if (!this.subject)\n      return \"inactive\";\n\n    const container = this.source;\n    if (!container)\n      return \"inactive\";\n\n    let scrollerStyle = getComputedStyle(container);\n\n    if (scrollerStyle.display == \"none\")\n      return \"inactive\";\n\n    if (container != document.scrollingElement &&\n        (scrollerStyle.overflow == 'visible' ||\n         scrollerStyle.overflow == \"clip\")) {\n        return \"inactive\";\n    }\n\n    // This check is not in the spec.\n    // http://github.com/w3c/csswg-drafts/issues/7259\n    // Update once specced.\n    let node = this.subject;\n    while (node && node != container) {\n      node = node.offsetParent;\n    }\n    if (node != container)\n      return \"inactive\";\n\n    return \"active\";\n  }\n\n  // Currently specced as fit with proposal to rename in order to more naturally\n  // support start and end transitions.\n  // http://github.com/w3c/csswg-drafts/issues/7044\n  // TODO: Update once specced.\n  get range() {\n    return scrollTimelineOptions.get(this).range;\n  }\n\n  get currentTime() {\n    const unresolved = null;\n    if (this.phase === 'inactive')\n      return unresolved;\n\n    // Compute the offset of the top-left corner of subject relative to\n    // top-left corner of the container.\n    const container = this.source;\n    const target = this.subject;\n\n    let top = 0;\n    let left = 0;\n    let node = target;\n    while (node && node != container) {\n      left += node.offsetLeft;\n      top += node.offsetTop;\n      node = node.offsetParent;\n    }\n\n    // Determine the view and container size based on the scroll direction.\n    // The view position is the scroll position of the logical starting edge\n    // of the view.\n    const style = getComputedStyle(container);\n    const horizontalWritingMode = style.writingMode == 'horizontal-tb';\n    const rtl = style.direction == 'rtl';\n    let viewSize = undefined;\n    let viewPos = undefined;\n    let containerSize = undefined;\n    const orientation = this.orientation;\n    if (orientation == 'horizontal' ||\n        (orientation == 'inline' && horizontalWritingMode) ||\n        (orientation == 'block' && !horizontalWritingMode)) {\n      viewSize = target.clientWidth;\n      viewPos = left;\n      if (rtl)\n        viewPos += container.scrollWidth - container.clientWidth;\n      containerSize = container.clientWidth;\n    } else {\n      // TODO: support sideways-lr\n      viewSize = target.clientHeight;\n      viewPos = top;\n      containerSize = container.clientHeight;\n    }\n\n    const scrollPos = directionAwareScrollOffset(container, orientation);\n    let startOffset = undefined;\n    let endOffset = undefined;\n\n    switch(this.range) {\n      case 'cover':\n        // Range of scroll offsets where the subject element intersects the\n        // source's viewport.\n        startOffset = viewPos - containerSize;\n        endOffset = viewPos + viewSize;\n        break;\n\n      case 'contain':\n        // Range of scroll offsets where the subject element is fully inside of\n        // the container's viewport. If the subject's bounds exceed the size\n        // of the viewport in the scroll direction then the scroll range is\n        // empty.\n        startOffset = viewPos + viewSize - containerSize;\n        endOffset = viewPos;\n        break;\n\n      case 'start':\n        // Range of scroll offsets where the subject element overlaps the\n        // logical-start edge of the viewport.\n        startOffset = viewPos - containerSize;\n        endOffset = viewPos + viewSize - containerSize;\n        break;\n\n      case 'end':\n        // Range of scroll offsets where the subject element overlaps the\n        // logical-end edge of the viewport.\n        startOffset = viewPos;\n        endOffset = viewPos + viewSize;\n        break;\n\n      default:\n        // TODO: support offset pair.\n    }\n\n    if (startOffset < endOffset) {\n      const progress = (scrollPos - startOffset) / (endOffset - startOffset);\n      return CSS.percent(100 * progress);\n    }\n\n    return unresolved;\n  }\n}\n","import {\n  ScrollTimeline,\n  installScrollOffsetExtension,\n  addAnimation,\n  removeAnimation\n} from \"./scroll-timeline-base\";\n\nconst nativeElementAnimate = window.Element.prototype.animate;\nconst nativeAnimation = window.Animation;\n\nclass PromiseWrapper {\n  constructor() {\n    this.state = 'pending';\n    this.nativeResolve = this.nativeReject = null;\n    this.promise = new Promise((resolve, reject) => {\n      this.nativeResolve = resolve;\n      this.nativeReject = reject;\n    });\n  }\n  resolve(value) {\n    this.state = 'resolved';\n    this.nativeResolve(value);\n  }\n  reject(reason) {\n    this.state = 'rejected';\n    // Do not report unhandled promise rejections.\n    this.promise.catch(() => {});\n    this.nativeReject(reason);\n  }\n}\n\nfunction createReadyPromise(details) {\n  details.readyPromise = new PromiseWrapper();\n  // Trigger the pending task on the next animation frame.\n  requestAnimationFrame(() => {\n    const timelineTime = details.timeline.currentTime;\n    if (timelineTime !== null)\n      notifyReady(details);\n  });\n}\n\nfunction createAbortError() {\n  return new DOMException(\"The user aborted a request\", \"AbortError\");\n}\n\n// Converts a time from its internal representation to a percent. For a\n// monotonic timeline, time is reported as a double with implicit units of\n// milliseconds. For progress-based animations, times are reported as\n// percentages.\nfunction toCssNumberish(details, value) {\n  if (value === null)\n    return value;\n\n  if (typeof value !== 'number') {\n      throw new DOMException(\n          `Unexpected value: ${value}.  Cannot convert to CssNumberish`,\n          \"InvalidStateError\");\n  }\n\n  const limit = effectEnd(details);\n  const percent = limit ? 100 * value / limit : 0;\n  return CSS.percent(percent);\n}\n\n// Covnerts a time to its internal representation. Progress-based animations\n// use times expressed as percentages. Each progress-based animation is backed\n// by a native animation with a document timeline in the polyfill. Thus, we\n// need to convert the timing from percent to milliseconds with implicit units.\nfunction fromCssNumberish(details, value) {\n  if (!details.timeline) {\n    // Document timeline\n    if (value == null || typeof value === 'number')\n      return value;\n\n    const convertedTime = value.to('ms');\n    if (convertTime)\n      return convertedTime.value;\n\n    throw new DOMException(\n        \"CSSNumericValue must be either a number or a time value for \" +\n        \"time based animations.\",\n        \"InvalidStateError\");\n  } else {\n    // Scroll timeline.\n    if (value === null)\n      return value;\n\n    if (value.unit === 'percent') {\n      const duration = effectEnd(details);\n      return value.value * duration / 100;\n    }\n\n    throw new DOMException(\n        \"CSSNumericValue must be a percentage for progress based animations.\",\n        \"NotSupportedError\");\n  }\n}\n\nfunction normalizedTiming(details) {\n  // Used normalized timing in the case of a progress-based animation or\n  // specified timing with a document timeline.  The normalizedTiming property\n  // is initialized and cached when fetching the timing information.\n  const timing = details.proxy.effect.getTiming();\n  return details.normalizedTiming || timing;\n}\n\nfunction commitPendingPlay(details)  {\n  // https://drafts4.csswg.org/web-animations-2/#playing-an-animation-section\n  // Refer to steps listed under \"Schedule a task to run ...\"\n\n  const timelineTime = fromCssNumberish(details, details.timeline.currentTime);\n  if (details.holdTime != null) {\n    // A: If animation’s hold time is resolved,\n    // A.1. Apply any pending playback rate on animation.\n    // A.2. Let new start time be the result of evaluating:\n    //        ready time - hold time / playback rate for animation.\n    //      If the playback rate is zero, let new start time be simply ready\n    //      time.\n    // A.3. Set the start time of animation to new start time.\n    // A.4. If animation’s playback rate is not 0, make animation’s hold\n    //      time unresolved.\n    applyPendingPlaybackRate(details);\n    if (details.animation.playbackRate == 0) {\n      details.startTime = timelineTime;\n    } else {\n      details.startTime\n          = timelineTime -\n              details.holdTime / details.animation.playbackRate;\n      details.holdTime = null;\n    }\n  } else if (details.startTime !== null &&\n             details.pendingPlaybackRate !== null) {\n    // B: If animation’s start time is resolved and animation has a pending\n    //    playback rate,\n    // B.1. Let current time to match be the result of evaluating:\n    //        (ready time - start time) × playback rate for animation.\n    // B.2 Apply any pending playback rate on animation.\n    // B.3 If animation’s playback rate is zero, let animation’s hold time\n    //     be current time to match.\n    // B.4 Let new start time be the result of evaluating:\n    //       ready time - current time to match / playback rate\n    //     for animation.\n    //     If the playback rate is zero, let new start time be simply ready\n    //     time.\n    // B.5 Set the start time of animation to new start time.\n    const currentTimeToMatch =\n        (timelineTime - details.startTime) * details.animation.playbackRate;\n    applyPendingPlaybackRate(details);\n    const playbackRate = details.animation.playbackRate;\n    if (playbackRate == 0) {\n      details.holdTime = null;\n      details.startTime = timelineTime;\n    } else {\n      details.startTime = timelineTime - currentTimeToMatch / playbackRate;\n    }\n  }\n\n  // 8.4 Resolve animation’s current ready promise with animation.\n  if (details.readyPromise && details.readyPromise.state == 'pending')\n     details.readyPromise.resolve(details.proxy);\n\n  // 8.5 Run the procedure to update an animation’s finished state for\n  //     animation with the did seek flag set to false, and the\n  //     synchronously notify flag set to false.\n  updateFinishedState(details, false, false);\n\n  // Additional polyfill step to update the native animation's current time.\n  syncCurrentTime(details);\n  details.pendingTask = null;\n};\n\nfunction commitPendingPause(details) {\n  // https://www.w3.org/TR/web-animations-1/#pausing-an-animation-section\n  // Refer to steps listed under \"Schedule a task to run ...\"\n\n  // 1. Let ready time be the time value of the timeline associated with\n  //    animation at the moment when the user agent completed processing\n  //    necessary to suspend playback of animation’s target effect.\n  const readyTime = fromCssNumberish(details, details.timeline.currentTime);\n\n  // 2. If animation’s start time is resolved and its hold time is not\n  //    resolved, let animation’s hold time be the result of evaluating\n  //    (ready time - start time) × playback rate.\n  if (details.startTime != null && details.holdTime == null) {\n    details.holdTime =\n        (readyTime - details.startTime) * details.animation.playbackRate;\n  }\n\n  // 3. Apply any pending playback rate on animation.\n  applyPendingPlaybackRate(details);\n\n  // 4. Make animation’s start time unresolved.\n  details.startTime = null;\n\n  // 5. Resolve animation’s current ready promise with animation.\n  details.readyPromise.resolve(details.proxy);\n\n  // 6. Run the procedure to update an animation’s finished state for\n  // animation with the did seek flag set to false, and the synchronously\n  //  notify flag set to false.\n  updateFinishedState(details, false, false);\n\n  // Additional polyfill step to update the native animation's current time.\n  syncCurrentTime(details);\n  details.pendingTask = null;\n};\n\nfunction commitFinishedNotification(details) {\n  if (!details.finishedPromise || details.finishedPromise.state != 'pending')\n    return;\n\n  if (details.proxy.playState != 'finished')\n    return;\n\n  details.finishedPromise.resolve(details.proxy);\n\n  details.animation.pause();\n\n  // Event times are speced as doubles in web-animations-1.\n  // Cannot dispatch a proxy to an event since the proxy is not a fully\n  // transparent replacement. As a workaround, use a custom event and inject\n  // the necessary getters.\n  const finishedEvent =\n    new CustomEvent('finish',\n                    { detail: {\n                      currentTime: details.proxy.currentTime,\n                      timelineTime: details.proxy.timeline.currentTime\n                    }});\n  Object.defineProperty(finishedEvent, 'currentTime', {\n    get: function() { return this.detail.currentTime; }\n  });\n  Object.defineProperty(finishedEvent, 'timelineTime', {\n    get: function() { return this.detail.timelineTime; }\n  });\n\n  requestAnimationFrame(() => {\n    queueMicrotask(() => {\n      details.animation.dispatchEvent(finishedEvent);\n    });\n  });\n}\n\nfunction effectivePlaybackRate(details) {\n  if (details.pendingPlaybackRate !== null)\n    return details.pendingPlaybackRate;\n  return details.animation.playbackRate;\n}\n\nfunction applyPendingPlaybackRate(details) {\n  if (details.pendingPlaybackRate !== null) {\n    details.animation.playbackRate = details.pendingPlaybackRate;\n    details.pendingPlaybackRate = null;\n  }\n}\n\nfunction calculateCurrentTime(details) {\n  if (!details.timeline)\n    return null;\n\n  const timelineTime = fromCssNumberish(details, details.timeline.currentTime);\n  if (timelineTime === null)\n    return null;\n\n  if (details.startTime === null)\n    return null;\n\n  let currentTime =\n      (timelineTime - details.startTime) * details.animation.playbackRate;\n\n  // Handle special case.\n  if (currentTime == -0)\n    currentTime = 0;\n\n  return currentTime;\n}\n\nfunction calculateStartTime(details, currentTime) {\n  if (!details.timeline)\n    return null;\n\n  const timelineTime = fromCssNumberish(details, details.timeline.currentTime);\n  if (timelineTime == null)\n    return null;\n\n  return timelineTime - currentTime / details.animation.playbackRate;\n}\n\nfunction updateFinishedState(details, didSeek, synchronouslyNotify) {\n  if (!details.timeline)\n    return;\n\n  // https://www.w3.org/TR/web-animations-1/#updating-the-finished-state\n  // 1. Calculate the unconstrained current time. The dependency on did_seek is\n  // required to accommodate timelines that may change direction. Without this\n  // distinction, a once-finished animation would remain finished even when its\n  // timeline progresses in the opposite direction.\n  let unconstrainedCurrentTime =\n      didSeek ? fromCssNumberish(details, details.proxy.currentTime)\n              : calculateCurrentTime(details);\n\n  // 2. Conditionally update the hold time.\n  if (unconstrainedCurrentTime && details.startTime != null &&\n      !details.proxy.pending) {\n    // Can seek outside the bounds of the active effect. Set the hold time to\n    // the unconstrained value of the current time in the event that this update\n    // is the result of explicitly setting the current time and the new time\n    // is out of bounds. An update due to a time tick should not snap the hold\n    // value back to the boundary if previously set outside the normal effect\n    // boundary. The value of previous current time is used to retain this\n    // value.\n    const playbackRate = effectivePlaybackRate(details);\n    const upperBound = effectEnd(details);\n    let boundary = details.previousCurrentTime;\n    // TODO: Support hold phase.\n    if (playbackRate > 0 && unconstrainedCurrentTime >= upperBound) {\n      if (boundary === null || boundary < upperBound)\n        boundary = upperBound;\n      details.holdTime = didSeek ? unconstrainedCurrentTime : boundary;\n    } else if (playbackRate < 0 && unconstrainedCurrentTime <= 0) {\n      if (boundary == null || boundary > 0)\n        boundary = 0;\n      details.holdTime = didSeek ? unconstrainedCurrentTime : boundary;\n    } else if (playbackRate != 0) {\n      // Update start time and reset hold time.\n      if (didSeek && details.holdTime !== null)\n        details.startTime = calculateStartTime(details, details.holdTime);\n      details.holdTime = null;\n    }\n  }\n\n  // Additional step to ensure that the native animation has the same value for\n  // current time as the proxy.\n  syncCurrentTime(details);\n\n  // 3. Set the previous current time.\n  details.previousCurrentTime = fromCssNumberish(details,\n                                                 details.proxy.currentTime);\n\n  // 4. Set the current finished state.\n  const playState = details.proxy.playState;\n\n  if (playState == 'finished') {\n    if (!details.finishedPromise)\n      details.finishedPromise = new PromiseWrapper();\n    if (details.finishedPromise.state == 'pending') {\n      // 5. Setup finished notification.\n      if (synchronouslyNotify) {\n        commitFinishedNotification(details);\n      } else {\n        Promise.resolve().then(() => {\n          commitFinishedNotification(details);\n        });\n      }\n    }\n  } else {\n    // 6. If not finished but the current finished promise is already resolved,\n    //    create a new promise.\n    if (details.finishedPromise &&\n        details.finishedPromise.state == 'resolved') {\n      details.finishedPromise = new PromiseWrapper();\n    }\n    if (details.animation.playState != 'paused')\n      details.animation.pause();\n  }\n}\n\nfunction effectEnd(details) {\n  // https://www.w3.org/TR/web-animations-1/#end-time\n  const timing = normalizedTiming(details);\n  const totalDuration =\n     timing.delay + timing.endDelay + timing.iterations * timing.duration;\n\n  return Math.max(0, totalDuration);\n}\n\nfunction hasActiveTimeline(details) {\n  return !details.timeline || details.timeline.phase != 'inactive';\n}\n\nfunction syncCurrentTime(details) {\n  if (!details.timeline)\n    return;\n\n  if (details.startTime !== null) {\n    const timelineTime = fromCssNumberish(details,\n                                          details.timeline.currentTime);\n    details.animation.currentTime =\n        (timelineTime - details.startTime) *\n            details.animation.playbackRate;\n  } else if (details.holdTime !== null) {\n    details.animation.currentTime = details.holdTime;\n  }\n}\n\nfunction resetPendingTasks(details) {\n  // https://www.w3.org/TR/web-animations-1/#reset-an-animations-pending-tasks\n\n  // 1. If animation does not have a pending play task or a pending pause task,\n  //    abort this procedure.\n  if (!details.pendingTask)\n    return;\n\n  // 2. If animation has a pending play task, cancel that task.\n  // 3. If animation has a pending pause task, cancel that task.\n  details.pendingTask = null;\n\n  // 4. Apply any pending playback rate on animation.\n  applyPendingPlaybackRate(details);\n\n  // 5. Reject animation’s current ready promise with a DOMException named\n  //    \"AbortError\".\n  details.readyPromise.reject(createAbortError());\n\n  // 6. Let animation’s current ready promise be the result of creating a new\n  //    resolved Promise object.\n  createReadyPromise(details);\n  details.readyPromise.resolve(details.proxy);\n}\n\nfunction playInternal(details, autoRewind) {\n  if (!details.timeline)\n    return;\n\n  // https://drafts.csswg.org/web-animations/#playing-an-animation-section.\n  // 1. Let aborted pause be a boolean flag that is true if animation has a\n  //    pending pause task, and false otherwise.\n  const abortedPause =\n     details.proxy.playState == 'paused' && details.proxy.pending;\n\n  // 2. Let has pending ready promise be a boolean flag that is initially\n  //    false.\n  let hasPendingReadyPromise = false;\n\n  // 3. Let seek time be a time value that is initially unresolved.\n  let seekTime = null;\n\n  // 4. Let has finite timeline be true if animation has an associated\n  //    timeline that is not monotonically increasing.\n  //    Note: this value will always true at this point in the polyfill.\n  //    Following steps are pruned based on the procedure for scroll\n  //    timelines.\n\n  // 5. Perform the steps corresponding to the first matching condition from\n  //    the following, if any:\n  //\n  // 5a If animation’s effective playback rate > 0, the auto-rewind flag is\n  //    true and either animation’s:\n  //      current time is unresolved, or\n  //      current time < zero, or\n  //      current time >= target effect end,\n  //    5a1. Set seek time to zero.\n  //\n  // 5b If animation’s effective playback rate < 0, the auto-rewind flag is\n  //    true and either animation’s:\n  //      current time is unresolved, or\n  //      current time ≤ zero, or\n  //      current time > target effect end,\n  //    5b1. If associated effect end is positive infinity,\n  //         throw an \"InvalidStateError\" DOMException and abort these steps.\n  //    5b2. Otherwise,\n  //         5b2a Set seek time to animation's associated effect end.\n  //\n  // 5c If animation’s effective playback rate = 0 and animation’s current time\n  //    is unresolved,\n  //    5c1. Set seek time to zero.\n  let previousCurrentTime = fromCssNumberish(details,\n                                             details.proxy.currentTime);\n\n  // Resume of a paused animation after a timeline change snaps to the scroll\n  // position.\n  if (details.resetCurrentTimeOnResume) {\n    previousCurrentTime = null;\n    details.resetCurrentTimeOnResume = false;\n  }\n\n  const playbackRate = effectivePlaybackRate(details);\n  const upperBound = effectEnd(details);\n  if (playbackRate > 0 && autoRewind && (previousCurrentTime == null ||\n                                         previousCurrentTime < 0 ||\n                                         previousCurrentTime >= upperBound)) {\n    seekTime = 0;\n  } else if (playbackRate < 0 && autoRewind &&\n             (previousCurrentTime == null || previousCurrentTime <= 0 ||\n             previousCurrentTime > upperBound)) {\n    if (upperBound == Infinity) {\n      // Defer to native implementation to handle throwing the exception.\n      details.animation.play();\n      return;\n    }\n    seekTime = upperBound;\n  } else if (playbackRate == 0 && previousCurrentTime == null) {\n    seekTime = 0;\n  }\n\n  // 6. If seek time is resolved,\n  //        6a1. Set animation's start time to seek time.\n  //        6a2. Let animation's hold time be unresolved.\n  //        6a3. Apply any pending playback rate on animation.\n  if (seekTime != null) {\n    details.startTime = seekTime;\n    details.holdTime = null;\n    applyPendingPlaybackRate(details);\n  }\n\n  // Additional step for the polyfill.\n  addAnimation(details.timeline, details.animation,\n               tickAnimation.bind(details.proxy));\n\n  // 7. If animation's hold time is resolved, let its start time be\n  //    unresolved.\n  if (details.holdTime) {\n    details.startTime = null;\n  }\n\n  // 8. If animation has a pending play task or a pending pause task,\n  //   8.1 Cancel that task.\n  //   8.2 Set has pending ready promise to true.\n  if (details.pendingTask) {\n    details.pendingTask = null;\n    hasPendingReadyPromise = true;\n  }\n\n  // 9. If the following three conditions are all satisfied:\n  //      animation’s hold time is unresolved, and\n  //      seek time is unresolved, and\n  //      aborted pause is false, and\n  //      animation does not have a pending playback rate,\n  //    abort this procedure.\n  if (details.holdTime === null && seekTime === null &&\n      !abortedPause && details.pendingPlaybackRate === null)\n  return;\n\n  // 10. If has pending ready promise is false, let animation’s current ready\n  //    promise be a new promise in the relevant Realm of animation.\n  if (details.readyPromise && !hasPendingReadyPromise)\n    details.readyPromise = null;\n\n  // Additional polyfill step to ensure that the native animation has the\n  // correct value for current time.\n  syncCurrentTime(details);\n\n  // 11. Schedule a task to run as soon as animation is ready.\n  if (!details.readyPromise)\n    createReadyPromise(details);\n  details.pendingTask = 'play';\n\n  // 12. Run the procedure to update an animation’s finished state for animation\n  //     with the did seek flag set to false, and the synchronously notify flag\n  //     set to false.\n  updateFinishedState(details, /* seek */ false, /* synchronous */ false);\n}\n\nfunction tickAnimation(timelineTime) {\n  const details = proxyAnimations.get(this);\n  if (timelineTime == null) {\n    // While the timeline is inactive, it's effect should not be applied.\n    // To polyfill this behavior, we cancel the underlying animation.\n    if (details.animation.playState != 'idle')\n      details.animation.cancel();\n    return;\n  }\n\n  if (details.pendingTask) {\n    notifyReady(details);\n  }\n\n  const playState = this.playState;\n  if (playState == 'running' || playState == 'finished') {\n    const timelineTimeMs = fromCssNumberish(details, timelineTime);\n\n    details.animation.currentTime =\n        (timelineTimeMs - fromCssNumberish(details, this.startTime)) *\n            this.playbackRate;\n\n    // Conditionally reset the hold time so that the finished state can be\n    // properly recomputed.\n    if (playState == 'finished' && effectivePlaybackRate(details) != 0)\n      details.holdTime = null;\n    updateFinishedState(details, false, false);\n  }\n}\n\nfunction notifyReady(details) {\n  if (details.pendingTask == 'pause') {\n    commitPendingPause(details);\n  } else if (details.pendingTask == 'play') {\n    commitPendingPlay(details);\n  }\n}\n\nfunction createProxyEffect(details) {\n  const effect = details.animation.effect;\n  const nativeUpdateTiming = effect.updateTiming;\n\n  // Generic pass-through handler for any method or attribute that is not\n  // explicitly overridden.\n  const handler = {\n    get: function(obj, prop) {\n      const result = obj[prop];\n      if (typeof result === 'function')\n        return result.bind(effect);\n      return result;\n    },\n\n    set: function(obj, prop, value) {\n      obj[prop] = value;\n      return true;\n    }\n  };\n  // Override getComputedTiming to convert to percentages when using a\n  // progress-based timeline.\n  const getComputedTimingHandler = {\n    apply: function(target) {\n      // Ensure that the native animation is using normalized values.\n      effect.getTiming();\n\n      const timing = target.apply(effect);\n\n      if (details.timeline) {\n        const preConvertLocalTime = timing.localTime;\n        timing.localTime = toCssNumberish(details, timing.localTime);\n        timing.endTime = toCssNumberish(details, timing.endTime);\n        timing.activeDuration =\n            toCssNumberish(details, timing.activeDuration);\n        const limit = effectEnd(details);\n        const iteration_duration = timing.iterations ?\n            (limit - timing.delay - timing.endDelay) / timing.iterations : 0;\n        timing.duration = limit ?\n            CSS.percent(100 * iteration_duration / limit) :\n            CSS.percent(0);\n\n        // Correct for timeline phase.\n        const phase = details.timeline.phase;\n        const fill = timing.fill;\n\n        if(phase == 'before' && fill != 'backwards' && fill != 'both') {\n          timing.progress = null;\n        }\n        if (phase == 'after' && fill != 'forwards' && fill != 'both') {\n          timing.progress = null;\n        }\n\n        // Correct for inactive timeline.\n        if (details.timeline.currentTime === undefined) {\n          timing.localTime = null;\n        }\n      }\n      return timing;\n    }\n  };\n  // Override getTiming to normalize the timing. EffectEnd for the animation\n  // align with the timeline duration.\n  const getTimingHandler = {\n    apply: function(target, thisArg) {\n      // Arbitrary conversion of 100% to ms.\n      const INTERNAL_DURATION_MS = 100000;\n\n      if (details.specifiedTiming)\n        return details.specifiedTiming;\n\n      details.specifiedTiming = target.apply(effect);\n      let timing = Object.assign({}, details.specifiedTiming);\n\n      let totalDuration;\n\n      // Duration 'auto' case.\n      if (timing.duration === null || timing.duration === 'auto') {\n        if (details.timeline) {\n          // TODO: start and end delay are specced as doubles and currently\n          // ignored for a progress based animation. Support delay and endDelay\n          // once CSSNumberish.\n          timing.delay = 0;\n          timing.endDelay = 0;\n          totalDuration = timing.iterations ? INTERNAL_DURATION_MS : 0;\n          timing.duration =\n              timing.iterations ? totalDuration / timing.iterations : 0;\n          // Set the timing on the native animation to the normalized values\n          // while preserving the specified timing.\n          nativeUpdateTiming.apply(effect, [timing]);\n        }\n      }\n      details.normalizedTiming = timing;\n      return details.specifiedTiming;\n    }\n  };\n  const updateTimingHandler = {\n    apply: function(target, thisArg, argumentsList) {\n      // Additional validation that is specific to scroll timelines.\n      if (details.timeline) {\n        const options = argumentsList[0];\n        const duration = options.duration;\n        if (duration === Infinity) {\n          throw TypeError(\n              \"Effect duration cannot be Infinity when used with Scroll \" +\n              \"Timelines\");\n        }\n        const iterations = options.iterations;\n        if (iterations === Infinity) {\n          throw TypeError(\n            \"Effect iterations cannot be Infinity when used with Scroll \" +\n            \"Timelines\");\n        }\n      }\n\n      // Apply updates on top of the original specified timing.\n      if (details.specifiedTiming) {\n        target.apply(effect, [details.specifiedTiming]);\n      }\n      target.apply(effect, argumentsList);\n      // Force renormalization.\n      details.specifiedTiming = null;\n    }\n  };\n  const proxy = new Proxy(effect, handler);\n  proxy.getComputedTiming = new Proxy(effect.getComputedTiming,\n                                      getComputedTimingHandler);\n  proxy.getTiming = new Proxy(effect.getTiming, getTimingHandler);\n  proxy.updateTiming = new Proxy(effect.updateTiming, updateTimingHandler);\n  return proxy;\n}\n\n// Create an alternate Animation class which proxies API requests.\n// TODO: Create a full-fledged proxy so missing methods are automatically\n// fetched from Animation.\nlet proxyAnimations = new WeakMap();\n\nexport class ProxyAnimation {\n  constructor(effect, timeline) {\n    const animation =\n        (effect instanceof nativeAnimation) ?\n           effect : new nativeAnimation(effect, animationTimeline);\n    const isScrollAnimation = timeline instanceof ScrollTimeline;\n    const animationTimeline = isScrollAnimation ? undefined : timeline;\n    proxyAnimations.set(this, {\n      animation: animation,\n      timeline: isScrollAnimation ? timeline : undefined,\n      playState: isScrollAnimation ? \"idle\" : null,\n      readyPromise: null,\n      finishedPromise: null,\n      // Start and hold times are directly tracked in the proxy despite being\n      // accessible via the animation so that direct manipulation of these\n      // properties does not affect the play state of the underlying animation.\n      // Note that any changes to these values require an update of current\n      // time for the underlying animation to ensure that its hold time is set\n      // to the correct position. These values are represented as floating point\n      // numbers in milliseconds.\n      startTime: null,\n      holdTime: null,\n      previousCurrentTime: null,\n      // When changing the timeline on a paused animation, we defer updating the\n      // start time until the animation resumes playing.\n      resetCurrentTimeOnResume: false,\n      // Calls to reverse and updatePlaybackRate set a pending rate that does\n      // not immediately take effect. The value of this property is\n      // inaccessible via the web animations API and therefore explicitly\n      // tracked.\n      pendingPlaybackRate: null,\n      pendingTask: null,\n      // Record the specified timing since it may be different than the timing\n      // actually used for the animation. When fetching the timing, this value\n      // will be returned, however, the native animation will use normalized\n      // values.\n      specifiedTiming: null,\n      // The normalized timing has the corrected timing with the intrinsic\n      // iteration duration resolved.\n      normalizedTiming: null,\n      // Effect proxy that performs the necessary time conversions when using a\n      // progress-based timelines.\n      effect: null,\n      proxy: this\n    });\n  }\n\n  // -----------------------------------------\n  // Web animation API\n  // -----------------------------------------\n\n  get effect() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline)\n      return details.animation.effect;\n\n    // Proxy the effect to support timing conversions for progress based\n    // animations.\n    if (!details.effect)\n      details.effect = createProxyEffect(details);\n\n    return details.effect;\n  }\n  set effect(newEffect) {\n    proxyAnimations.get(this).animation.effect = newEffect;\n    // Reset proxy to force re-initialization the next time it is accessed.\n    details.effect = null;\n  }\n\n  get timeline() {\n    const details = proxyAnimations.get(this);\n    // If we explicitly set a null timeline we will return the underlying\n    // animation's timeline.\n    return details.timeline || details.animation.timeline;\n  }\n  set timeline(newTimeline) {\n    // https://drafts4.csswg.org/web-animations-2/#setting-the-timeline\n\n    // 1. Let old timeline be the current timeline of animation, if any.\n    // 2. If new timeline is the same object as old timeline, abort this\n    //    procedure.\n    const oldTimeline = this.timeline;\n    if (oldTimeline == newTimeline)\n      return;\n\n    // 3. Let previous play state be animation’s play state.\n    const previousPlayState = this.playState;\n\n    // 4. Let previous current time be the animation’s current time.\n    const previousCurrentTime = this.currentTime;\n\n    const details = proxyAnimations.get(this);\n    const end = effectEnd(details);\n    const progress =\n        end > 0 ? fromCssNumberish(details, previousCurrentTime) / end : 0;\n\n    // 5. Let from finite timeline be true if old timeline is not null and not\n    //    monotonically increasing.\n    const fromScrollTimeline = (oldTimeline instanceof ScrollTimeline);\n\n    // 6. Let to finite timeline be true if timeline is not null and not\n    //    monotonically increasing.\n    const toScrollTimeline = (newTimeline instanceof ScrollTimeline);\n\n    // 7. Let the timeline of animation be new timeline.\n    // Cannot assume that the native implementation has mutable timeline\n    // support. Deferring this step until we know that we are either\n    // polyfilling, supporting natively, or throwing an error.\n\n    // 8. Set the flag reset current time on resume to false.\n    details.resetCurrentTimeOnResume = false;\n\n    // Additional step required to track whether the animation was pending in\n    // order to set up a new ready promise if needed.\n    const pending = this.pending;\n\n    if (fromScrollTimeline) {\n      removeAnimation(details.timeline, details.animation);\n    }\n\n    // 9. Perform the steps corresponding to the first matching condition from\n    //    the following, if any:\n\n    // If to finite timeline,\n    if (toScrollTimeline) {\n      // Deferred step 7.\n      details.timeline = newTimeline;\n\n      // 1. Apply any pending playback rate on animation\n      applyPendingPlaybackRate(details);\n\n      // 2. Let seek time be zero if playback rate >= 0, and animation’s\n      //    associated effect end otherwise.\n      const seekTime =\n          details.animation.playbackRate >= 0 ? 0 : effectEnd(details);\n\n      // 3.  Update the animation based on the first matching condition if any:\n      switch (previousPlayState) {\n        //   If either of the following conditions are true:\n        //     * previous play state is running or,\n        //     * previous play state is finished\n        //   Set animation’s start time to seek time.\n        case 'running':\n        case 'finished':\n          details.startTime = seekTime;\n          // Additional polyfill step needed to associate the animation with\n          // the scroll timeline.\n          addAnimation(details.timeline, details.animation,\n                       tickAnimation.bind(this));\n          break;\n\n        //   If previous play state is paused:\n        //     If previous current time is resolved:\n        //       * Set the flag reset current time on resume to true.\n        //       * Set start time to unresolved.\n        //       * Set hold time to previous current time.\n        case 'paused':\n          details.resetCurrentTimeOnResume = true;\n          details.startTime = null;\n          details.holdTime =\n              fromCssNumberish(details, CSS.percent(100 * progress));\n          break;\n\n        // Oterwise\n        default:\n          details.holdTime = null;\n          details.startTime = null;\n      }\n\n      // Additional steps required if the animation is pending as we need to\n      // associate the pending promise with proxy animation.\n      // Note: if the native promise already has an associated \"then\", we will\n      // lose this association.\n      if (pending) {\n        if (!details.readyPromise ||\n            details.readyPromise.state == 'resolved') {\n          createReadyPromise(details);\n        }\n        if (previousPlayState == 'paused')\n          details.pendingTask = 'pause';\n        else\n          details.pendingTask = 'play';\n      }\n\n      // Note that the following steps should apply when transitioning to\n      // a monotonic timeline as well; however, we do not have a direct means\n      // of applying the steps to the native animation.\n\n      // 10. If the start time of animation is resolved, make animation’s hold\n      //     time unresolved. This step ensures that the finished play state of\n      //     animation is not “sticky” but is re-evaluated based on its updated\n      //     current time.\n      if (details.startTime !== null)\n        details.holdTime = null;\n\n      // 11. Run the procedure to update an animation’s finished state for\n      //     animation with the did seek flag set to false, and the\n      //     synchronously  notify flag set to false.\n      updateFinishedState(details, false, false);\n      return;\n    }\n\n    // To monotonic timeline.\n    if (details.animation.timeline == newTimeline) {\n      // Deferred step 7 from above.  Clearing the proxy's timeline will\n      // re-associate the proxy with the native animation.\n      removeAnimation(details.timeline, details.animation);\n      details.timeline = null;\n\n      // If from finite timeline and previous current time is resolved,\n      //   Run the procedure to set the current time to previous current time.\n      if (fromScrollTimeline) {\n        if (previousCurrentTime !== null)\n          details.animation.currentTime = progress * effectEnd(details);\n\n        switch (previousPlayState) {\n          case 'paused':\n            details.animation.pause();\n            break;\n\n          case 'running':\n          case 'finished':\n            details.animation.play();\n        }\n      }\n    } else {\n      throw TypeError(\"Unsupported timeline: \" + newTimeline);\n    }\n  }\n\n  get startTime() {\n    const details = proxyAnimations.get(this);\n    if (details.timeline)\n      return toCssNumberish(details, details.startTime);\n\n    return details.animation.startTime;\n  }\n  set startTime(value) {\n    // https://drafts.csswg.org/web-animations/#setting-the-start-time-of-an-animation\n    const details = proxyAnimations.get(this);\n    value = fromCssNumberish(details, value);\n    if (!details.timeline) {\n      details.animation.startTime = value;\n      return;\n    }\n\n    // 1. Let timeline time be the current time value of the timeline that\n    //    animation is associated with. If there is no timeline associated with\n    //    animation or the associated timeline is inactive, let the timeline\n    //    time be unresolved.\n    const timelineTime = fromCssNumberish(details,\n                                          details.timeline.currentTime);\n\n    // 2. If timeline time is unresolved and new start time is resolved, make\n    //    animation’s hold time unresolved.\n    if (timelineTime == null && details.startTime != null) {\n      details.holdTime = null;\n      // Clearing the hold time may have altered the value of current time.\n      // Ensure that the underlying animations has the correct value.\n      syncCurrentTime(details);\n    }\n\n    // 3. Let previous current time be animation’s current time.\n    // Note: This is the current time after applying the changes from the\n    // previous step which may cause the current time to become unresolved.\n    const previousCurrentTime = fromCssNumberish(details, this.currentTime);\n\n    // 4. Apply any pending playback rate on animation.\n    applyPendingPlaybackRate(details);\n\n    // 5. Set animation’s start time to new start time.\n    details.startTime = value;\n\n    // 6. Set the reset current time on resume flag to false.\n    details.resetCurrentTimeOnResume = false;\n\n    // 7. Update animation’s hold time based on the first matching condition\n    //    from the following,\n\n    //    If new start time is resolved,\n    //    If animation’s playback rate is not zero,\n    //       make animation’s hold time unresolved.\n\n    //    Otherwise (new start time is unresolved),\n    //        Set animation’s hold time to previous current time even if\n    //        previous current time is unresolved.\n\n    if (details.startTime !== null && details.animation.playbackRate != 0)\n      details.holdTime = null;\n    else\n      details.holdTime = previousCurrentTime;\n\n    // 7. If animation has a pending play task or a pending pause task, cancel\n    //    that task and resolve animation’s current ready promise with\n    //    animation.\n    if (details.pendingTask) {\n      details.pendingTask = null;\n      details.readyPromise.resolve(this);\n    }\n\n   // 8. Run the procedure to update an animation’s finished state for animation\n   //    with the did seek flag set to true, and the synchronously notify flag\n   //    set to false.\n   updateFinishedState(details, true, false);\n\n    // Ensure that currentTime is updated for the native animation.\n    syncCurrentTime(details);\n  }\n\n  get currentTime() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline)\n      return details.animation.currentTime;\n\n    if (details.holdTime != null)\n      return toCssNumberish(details, details.holdTime);\n\n    return toCssNumberish(details, calculateCurrentTime(details));\n  }\n  set currentTime(value) {\n    const details = proxyAnimations.get(this);\n    value = fromCssNumberish(details, value);\n    if (!details.timeline || value == null) {\n      details.animation.currentTime = value;\n      return;\n    }\n\n    // https://drafts.csswg.org/web-animations/#setting-the-current-time-of-an-animation\n    const previouStartTime = details.startTime;\n    const previousHoldTime = details.holdTime;\n    const timelinePhase = details.timeline.phase;\n\n    // Update either the hold time or the start time.\n    if (details.holdTime !== null || details.startTime === null ||\n        timelinePhase == 'inactive' || details.animation.playbackRate == 0) {\n      // TODO: Support hold phase.\n      details.holdTime = value;\n    } else {\n      details.startTime = calculateStartTime(details, value);\n    }\n    details.resetCurrentTimeOnResume = false;\n\n    // Preserve invariant that we can only set a start time or a hold time in\n    // the absence of an active timeline.\n    if (timelinePhase == 'inactive')\n      details.startTime = null;\n\n    // Reset the previous current time.\n    details.previousCurrentTime = null;\n\n    // Synchronously resolve pending pause task.\n    if (details.pendingTask == 'pause') {\n      details.holdTime = value;\n      applyPendingPlaybackRate(details);\n      details.startTime = null;\n      details.pendingTask = null;\n      details.readyPromise.resolve(this);\n    }\n\n    // Update the finished state.\n    updateFinishedState(details, true, false);\n  }\n\n  get playbackRate() {\n    return proxyAnimations.get(this).animation.playbackRate;\n  }\n  set playbackRate(value) {\n    const details = proxyAnimations.get(this);\n\n    if (!details.timeline) {\n      details.animation.playbackRate = value;\n      return;\n    }\n\n    // 1. Clear any pending playback rate on animation.\n    details.pendingPlaybackRate = null;\n\n    // 2. Let previous time be the value of the current time of animation before\n    //    changing the playback rate.\n    const previousCurrentTime = this.currentTime;\n\n    // 3. Set the playback rate to new playback rate.\n    details.animation.playbackRate = value;\n\n    // 4. If previous time is resolved, set the current time of animation to\n    //    previous time\n   if (previousCurrentTime !== null)\n      this.currentTime = previousCurrentTime;\n  }\n\n  get playState() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline)\n      return details.animation.playState;\n\n    const currentTime = fromCssNumberish(details, this.currentTime);\n\n    // 1. All of the following conditions are true:\n    //    * The current time of animation is unresolved, and\n    //    * the start time of animation is unresolved, and\n    //    * animation does not have either a pending play task or a pending pause\n    //      task,\n    //    then idle.\n    if (currentTime === null && details.startTime === null &&\n        details.pendingTask == null)\n      return 'idle';\n\n    // 2. Either of the following conditions are true:\n    //    * animation has a pending pause task, or\n    //    * both the start time of animation is unresolved and it does not have a\n    //      pending play task,\n    //    then paused.\n    if (details.pendingTask == 'pause' ||\n        (details.startTime === null && details.pendingTask != 'play'))\n      return 'paused';\n\n    // 3.  For animation, current time is resolved and either of the following\n    //     conditions are true:\n    //     * animation’s effective playback rate > 0 and current time >= target\n    //       effect end; or\n    //     * animation’s effective playback rate < 0 and current time <= 0,\n    //    then finished.\n    if (currentTime != null) {\n      if (details.animation.playbackRate > 0 &&\n          currentTime >= effectEnd(details))\n        return 'finished';\n      if (details.animation.playbackRate < 0 && currentTime <= 0)\n        return 'finished';\n    }\n\n    // 4.  Otherwise\n    return 'running';\n  }\n  get replaceState() {\n    // TODO: Fix me. Replace state is not a boolean.\n    return proxyAnimations.get(this).animation.pending;\n  }\n\n  get pending() {\n    const details = proxyAnimations.get(this);\n    if (details.timeline) {\n      return !!details.readyPromise &&\n             details.readyPromise.state == 'pending';\n    }\n\n    return details.animation.pending;\n  }\n\n  finish() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline) {\n      details.animation.finish();\n      return;\n    }\n\n    // 1. If animation’s effective playback rate is zero, or if animation’s\n    //    effective playback rate > 0 and target effect end is infinity, throw\n    //    an InvalidStateError and abort these steps.\n    const playbackRate = effectivePlaybackRate(details);\n    const duration = effectEnd(details);\n    if (playbackRate == 0) {\n      throw new DOMException(\n          \"Cannot finish Animation with a playbackRate of 0.\",\n          \"InvalidStateError\");\n    }\n    if (playbackRate > 0 && duration == Infinity) {\n      throw new DOMException(\n          \"Cannot finish Animation with an infinite target effect end.\",\n          \"InvalidStateError\");\n    }\n\n    // 2. Apply any pending playback rate to animation.\n    applyPendingPlaybackRate(details);\n\n    // 3. Set limit as follows:\n    //       If playback rate > 0,\n    //          Let limit be target effect end.\n    //       Otherwise,\n    //          Let limit be zero.\n    const limit = playbackRate < 0 ? 0 : duration;\n\n    // 4. Silently set the current time to limit.\n    this.currentTime = toCssNumberish(details, limit);\n\n    // 5. If animation’s start time is unresolved and animation has an\n    //    associated active timeline, let the start time be the result of\n    //    evaluating\n    //        timeline time - (limit / playback rate)\n    //    where timeline time is the current time value of the associated\n    //    timeline.\n    const timelineTime = fromCssNumberish(details,\n                                          details.timeline.currentTime);\n\n    if (details.startTime === null && timelineTime !== null) {\n       details.startTime =\n           timelineTime - (limit / details.animation.playbackRate);\n    }\n\n    // 6. If there is a pending pause task and start time is resolved,\n    //    6.1 Let the hold time be unresolved.\n    //    6.2 Cancel the pending pause task.\n    //    6.3 Resolve the current ready promise of animation with animation.\n    if (details.pendingTask == 'pause' && details.startTime !== null) {\n      details.holdTime = null;\n      details.pendingTask = null;\n      details.readyPromise.resolve(this);\n    }\n\n    // 7. If there is a pending play task and start time is resolved, cancel\n    //    that task and resolve the current ready promise of animation with\n    //    animation.\n    if (details.pendingTask == 'play' && details.startTime !== null) {\n      details.pendingTask = null;\n      details.readyPromise.resolve(this);\n    }\n\n    // 8. Run the procedure to update an animation’s finished state for\n    //    animation with the did seek flag set to true, and the synchronously\n    //    notify flag set to true.\n    updateFinishedState(details, true, true);\n  }\n\n  play() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline) {\n      details.animation.play();\n      return;\n    }\n\n    playInternal(details, /* autoRewind */ true);\n  }\n\n  pause() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline) {\n      details.animation.pause();\n      return;\n    }\n\n    // https://www.w3.org/TR/web-animations-1/#pausing-an-animation-section\n\n    // 1. If animation has a pending pause task, abort these steps.\n    // 2. If the play state of animation is paused, abort these steps.\n    if (this.playState == \"paused\")\n      return;\n\n    // 3. Let seek time be a time value that is initially unresolved.\n    // 4. Let has finite timeline be true if animation has an associated\n    //    timeline that is not monotonically increasing.\n    //    Note: always true if we have reached this point in the polyfill.\n    //    Pruning following steps to be specific to scroll timelines.\n    let seekTime = null;\n\n    // 5.  If the animation’s current time is unresolved, perform the steps\n    //     according to the first matching condition from below:\n    // 5a. If animation’s playback rate is ≥ 0,\n    //       Set seek time to zero.\n    // 5b. Otherwise,\n    //         If associated effect end for animation is positive infinity,\n    //             throw an \"InvalidStateError\" DOMException and abort these\n    //             steps.\n    //         Otherwise,\n    //             Set seek time to animation's associated effect end.\n\n    const playbackRate = details.animation.playbackRate;\n    const duration = effectEnd(details);\n\n    if (details.animation.currentTime === null) {\n      if (playbackRate >= 0) {\n        seekTime = 0;\n      } else if (duration == Infinity) {\n        // Let native implementation take care of throwing the exception.\n        details.animation.pause();\n        return;\n      } else {\n        seekTime = duration;\n      }\n    }\n\n    // 6. If seek time is resolved,\n    //        If has finite timeline is true,\n    //            Set animation's start time to seek time.\n    if (seekTime !== null)\n      details.startTime = seekTime;\n\n    // 7. Let has pending ready promise be a boolean flag that is initially\n    //    false.\n    // 8. If animation has a pending play task, cancel that task and let has\n    //    pending ready promise be true.\n    // 9. If has pending ready promise is false, set animation’s current ready\n    //    promise to a new promise in the relevant Realm of animation.\n    if (details.pendingTask == 'play')\n      details.pendingTask = null;\n    else\n      details.readyPromise = null;\n\n    // 10. Schedule a task to be executed at the first possible moment after the\n    //     user agent has performed any processing necessary to suspend the\n    //     playback of animation’s target effect, if any.\n    if (!details.readyPromise)\n      createReadyPromise(details);\n    details.pendingTask ='pause';\n  }\n\n  reverse() {\n    const details = proxyAnimations.get(this);\n    const playbackRate = effectivePlaybackRate(details);\n    const previousCurrentTime =\n        details.resetCurrentTimeOnResume ?\n            null : fromCssNumberish(details, this.currentTime);\n    const inifiniteDuration = effectEnd(details) == Infinity;\n\n    // Let the native implementation handle throwing the exception in cases\n    // where reversal is not possible. Error cases will not change the state\n    // of the native animation.\n    const reversable =\n       (playbackRate != 0) &&\n       (playbackRate <  0 || previousCurrentTime > 0  || !inifiniteDuration);\n    if (!details.timeline || !reversable) {\n      if (reversable)\n        details.pendingPlaybackRate = -effectivePlaybackRate(details);\n      details.animation.reverse();\n      return;\n    }\n\n    if (details.timeline.phase == 'inactive') {\n      throw new DOMException(\n          \"Cannot reverse an animation with no active timeline\",\n          \"InvalidStateError\");\n    }\n\n    this.updatePlaybackRate(-playbackRate);\n    playInternal(details, /* autoRewind */ true);\n  }\n\n  updatePlaybackRate(rate) {\n    const details = proxyAnimations.get(this);\n    details.pendingPlaybackRate = rate;\n    if (!details.timeline) {\n      details.animation.updatePlaybackRate(rate);\n      return;\n    }\n\n    // https://drafts.csswg.org/web-animations/#setting-the-playback-rate-of-an-animation\n\n    // 1. Let previous play state be animation’s play state.\n    // 2. Let animation’s pending playback rate be new playback rate.\n    // Step 2 already performed as we need to record it even when using a\n    // monotonic timeline.\n    const previousPlayState = this.playState;\n\n    // 3. Perform the steps corresponding to the first matching condition from\n    //    below:\n    //\n    // 3a If animation has a pending play task or a pending pause task,\n    //    Abort these steps.\n    if (details.readyPromise && details.readyPromise.state == 'pending')\n      return;\n\n    switch(previousPlayState) {\n      // 3b If previous play state is idle or paused,\n      //    Apply any pending playback rate on animation.\n      case 'idle':\n      case 'paused':\n        applyPendingPlaybackRate(details);\n        break;\n\n      // 3c If previous play state is finished,\n      //    3c.1 Let the unconstrained current time be the result of calculating\n      //         the current time of animation substituting an unresolved time\n      //          value for the hold time.\n      //    3c.2 Let animation’s start time be the result of evaluating the\n      //         following expression:\n      //    timeline time - (unconstrained current time / pending playback rate)\n      // Where timeline time is the current time value of the timeline\n      // associated with animation.\n      //    3c.3 If pending playback rate is zero, let animation’s start time be\n      //         timeline time.\n      //    3c.4 Apply any pending playback rate on animation.\n      //    3c.5 Run the procedure to update an animation’s finished state for\n      //         animation with the did seek flag set to false, and the\n      //         synchronously notify flag set to false.\n\n      case 'finished':\n        const timelineTime = fromCssNumberish(details,\n                                              details.timeline.currentTime);\n        const unconstrainedCurrentTime = timelineTime !== null ?\n            (timelineTime - details.startTime) * details.animation.playbackRate\n            : null;\n        if (rate == 0) {\n          details.startTime = timelineTime;\n        } else {\n          details.startTime =\n              timelineTime != null && unconstrainedCurrentTime != null ?\n                  (timelineTime - unconstrainedCurrentTime) / rate : null;\n        }\n        applyPendingPlaybackRate(details);\n        updateFinishedState(details, false, false);\n        syncCurrentTime(details);\n        break;\n\n      // 3d Otherwise,\n      // Run the procedure to play an animation for animation with the\n      // auto-rewind flag set to false.\n      default:\n        playInternal(details, false);\n    }\n  }\n\n  persist() {\n    proxyAnimations.get(this).animation.persist();\n  }\n\n  get id() {\n    return proxyAnimations.get(this).animation.id;\n  }\n\n  cancel() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline) {\n      details.animation.cancel();\n      return;\n    }\n\n    // https://www.w3.org/TR/web-animations-1/#canceling-an-animation-section\n    // 1. If animation’s play state is not idle, perform the following steps:\n    //    1.1  Run the procedure to reset an animation’s pending tasks on\n    //         animation.\n    //    1.2 Reject the current finished promise with a DOMException named\n    //        \"AbortError\"\n    //    1.3 Let current finished promise be a new (pending) Promise object.\n    //    1.4+ Deferred to native implementation.\n    //         TODO: polyfill since timelineTime will be incorrect for the\n    //               cancel event. Also, should avoid sending a cancel event if\n    //               the native animation is canceled due to the scroll timeline\n    //               becoming inactive. This can likely be done by associating\n    //               the cancel event with the proxy and not the underlying\n    //               animation.\n    if (this.playState != 'idle') {\n      resetPendingTasks(details);\n      if (details.finishedPromise &&\n          details.finishedPromise.state == 'pending') {\n        details.finishedPromise.reject(createAbortError());\n      }\n      details.finishedPromise = new PromiseWrapper();\n      details.animation.cancel();\n    }\n\n    // 2. Make animation’s hold time unresolved.\n    // 3. Make animation’s start time unresolved.\n    details.startTime = null;\n    details.holdTime = null;\n\n    // Extra step in the polyfill the ensure the animation stops ticking.\n    removeAnimation(details.timeline, details.animation);\n  }\n\n  get onfinish() {\n    return proxyAnimations.get(this).animation.onfinish;\n  }\n  set onfinish(value) {\n    proxyAnimations.get(this).animation.onfinish = value;\n  }\n  get oncancel() {\n    return proxyAnimations.get(this).animation.oncancel;\n  }\n  set oncancel(value) {\n    proxyAnimations.get(this).animation.oncancel = value;\n  }\n  get onremove() {\n    return proxyAnimations.get(this).animation.onremove;\n  }\n  set onremove(value) {\n    proxyAnimations.get(this).animation.onremove = value;\n  }\n\n  get finished() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline)\n       return details.animation.finished;\n\n    if (!details.finishedPromise) {\n      details.finishedPromise = new PromiseWrapper();\n    }\n    return details.finishedPromise.promise;\n  }\n\n  get ready() {\n    const details = proxyAnimations.get(this);\n    if (!details.timeline)\n      return details.animation.ready;\n\n    if (!details.readyPromise) {\n      details.readyPromise = new PromiseWrapper();\n      details.readyPromise.resolve(this);\n    }\n    return details.readyPromise.promise;\n  }\n\n  // --------------------------------------------------\n  // Event target API\n  // --------------------------------------------------\n\n  addEventListener(type, callback, options) {\n    proxyAnimations.get(this).animation.addEventListener(type, callback,\n                                                         options);\n  }\n\n  removeEventListener(type, callback, options) {\n    proxyAnimations.get(this).animation.removeEventListener(type, callback,\n                                                            options);\n  }\n\n  dispatchEvent(event) {\n    proxyAnimations.get(this).animation.dispatchEvent(event);\n  }\n};\n\nexport function animate(keyframes, options) {\n  const timeline = options.timeline;\n\n  if (timeline instanceof ScrollTimeline)\n    delete options.timeline;\n\n  const animation = nativeElementAnimate.apply(this, [keyframes, options]);\n  const proxyAnimation = new ProxyAnimation(animation, timeline);\n\n  if (timeline instanceof ScrollTimeline) {\n    animation.pause();\n    proxyAnimation.play();\n  }\n\n  return proxyAnimation;\n};\n","// Copyright 2019 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nimport { parseLength } from \"./utils\";\n\nlet IntersectionOptions = new WeakMap();\n\n// Margin is stored as a 4 element array [top, right, bottom, left] but can be\n// specified using anywhere from 1 - 4 elements. This map defines how to convert\n// various length inputs to their components.\nconst TOP = 0;\nconst RIGHT = 1;\nconst BOTTOM = 2;\nconst LEFT = 3;\nconst MARGIN_MAP = [\n  // 1 length maps to all positions.\n  [[TOP, RIGHT, BOTTOM, LEFT]],\n  // 2 lengths maps to vertical and horizontal margins.\n  [\n    [TOP, BOTTOM],\n    [RIGHT, LEFT],\n  ],\n  // 3 lengths maps to top, horizontal, bottom margins.\n  [[TOP], [RIGHT, LEFT], [BOTTOM]],\n  // 4 lengths maps to each component.\n  [[TOP], [RIGHT], [BOTTOM], [LEFT]],\n];\n\nclass IntersectionBasedOffset {\n  constructor(value) {\n    IntersectionOptions.set(this, {\n      target: null,\n      edge: \"start\",\n      threshold: 0,\n      rootMargin: [\n        [0, \"px\"],\n        [0, \"px\"],\n        [0, \"px\"],\n        [0, \"px\"],\n      ],\n    });\n    this.target = value.target;\n    this.edge = value.edge || \"start\";\n    this.threshold = value.threshold || 0;\n    this.rootMargin = value.rootMargin || \"0px 0px 0px 0px\";\n    this.clamp = value.clamp || false;\n  }\n\n  set target(element) {\n    if (!(element instanceof Element)) {\n      IntersectionOptions.get(this).target = null;\n      throw Error(\"Intersection target must be an element.\");\n    }\n    IntersectionOptions.get(this).target = element;\n  }\n\n  get target() {\n    return IntersectionOptions.get(this).target;\n  }\n\n  set edge(value) {\n    if ([\"start\", \"end\"].indexOf(value) == -1) return;\n    IntersectionOptions.get(this).edge = value;\n  }\n\n  get edge() {\n    return IntersectionOptions.get(this).edge;\n  }\n\n  set threshold(value) {\n    let threshold = parseFloat(value);\n    // Throw a TypeError for a parse error.\n    if (threshold != threshold)\n      throw TypeError(\"Invalid threshold.\");\n    // TODO(https://crbug.com/1136516): This should throw a RangeError\n    // consistent with the intersection observer spec but the current\n    // test expectations are looking for a TypeError.\n    if (threshold < 0 || threshold > 1)\n      throw TypeError(\"threshold must be in the range [0, 1]\");\n    IntersectionOptions.get(this).threshold = threshold;\n  }\n\n  get threshold() {\n    return IntersectionOptions.get(this).threshold;\n  }\n\n  set rootMargin(value) {\n    let margins = value.split(/ +/);\n    if (margins.length < 1 || margins.length > 4)\n      throw TypeError(\n        \"rootMargin must contain between 1 and 4 length components\"\n      );\n    let parsedMargins = [[], [], [], []];\n    for (let i = 0; i < margins.length; i++) {\n      let parsedValue = parseLength(margins[i], true);\n      if (!parsedValue) throw TypeError(\"Unrecognized rootMargin length\");\n      let positions = MARGIN_MAP[margins.length - 1][i];\n      for (let j = 0; j < positions.length; j++) {\n        parsedMargins[positions[j]] = [\n          parseFloat(parsedValue.value),\n          parsedValue.unit,\n        ];\n      }\n    }\n    IntersectionOptions.get(this).rootMargin = parsedMargins;\n  }\n\n  get rootMargin() {\n    // TODO: Simplify to the shortest matching specification for the given margins.\n    return IntersectionOptions.get(this)\n      .rootMargin.map((margin) => {\n        return margin.join(\"\");\n      })\n      .join(\" \");\n  }\n\n  set clamp(value) {\n    // This is just for testing alternative proposals - not intended to be part\n    // of the specification.\n    IntersectionOptions.get(this).clamp = !!value;\n  }\n}\n\nexport function parseOffset(value) {\n  if (value.target) return new IntersectionBasedOffset(value);\n}\n\nfunction resolveLength(length, containerSize) {\n  if (length[1] == \"percent\") return (length[0] * containerSize) / 100;\n  // Assumption is only px or % will be passed in.\n  // TODO: Support other length types (e.g. em, vh, etc).\n  return length[0];\n}\n\nexport function calculateOffset(source, orientation, offset, startOrEnd) {\n  // TODO: Support other writing directions.\n  if (orientation == \"block\") orientation = \"vertical\";\n  else if (orientation == \"inline\") orientation = \"horizontal\";\n  let originalViewport =\n    source == document.scrollingElement\n      ? {\n          left: 0,\n          right: source.clientWidth,\n          top: 0,\n          bottom: source.clientHeight,\n          width: source.clientWidth,\n          height: source.clientHeight,\n        }\n      : source.getBoundingClientRect();\n\n  // Resolve margins and offset viewport.\n  let parsedMargins = IntersectionOptions.get(offset).rootMargin;\n  let computedMargins = [];\n  for (let i = 0; i < 4; i++) {\n    computedMargins.push(\n      resolveLength(\n        parsedMargins[i],\n        i % 2 == 0 ? originalViewport.height : originalViewport.width\n      )\n    );\n  }\n  let viewport = {\n    left: originalViewport.left - computedMargins[LEFT],\n    right: originalViewport.right + computedMargins[RIGHT],\n    width:\n      originalViewport.right -\n      originalViewport.left +\n      computedMargins[LEFT] +\n      computedMargins[RIGHT],\n    top: originalViewport.top - computedMargins[TOP],\n    bottom: originalViewport.bottom + computedMargins[BOTTOM],\n    height:\n      originalViewport.bottom -\n      originalViewport.top +\n      computedMargins[TOP] +\n      computedMargins[BOTTOM],\n  };\n\n  let clamped = IntersectionOptions.get(offset).clamp;\n  let target = offset.target.getBoundingClientRect();\n  let threshold = offset.threshold;\n  // Invert threshold for start position.\n  if (offset.edge == \"start\") threshold = 1 - threshold;\n  // Projected point into the scroller scroll range.\n  if (orientation == \"vertical\") {\n    let point =\n      target.top +\n      target.height * threshold -\n      viewport.top +\n      source.scrollTop;\n    if (clamped) {\n      if (offset.edge == \"end\") return Math.max(0, point - viewport.height);\n      return Math.min(point, source.scrollHeight - viewport.height);\n    } else {\n      if (offset.edge == \"end\") return point - viewport.height;\n      return point;\n    }\n  } else {\n    // orientation == 'horizontal'\n    let point =\n      target.left +\n      target.width * threshold -\n      viewport.left +\n      source.scrollLeft;\n    if (clamped) {\n      if (offset.edge == \"end\") return Math.max(0, point - viewport.width);\n      return Math.min(point, source.scrollWidth - viewport.width);\n    } else {\n      if (offset.edge == \"end\") return point - viewport.width;\n      return point;\n    }\n  }\n}\n","const VALID_SCROLL_OFFSET_SUFFIXES = [\n  // Relative lengths.\n  'em',\n  'ex',\n  'ch',\n  'rem',\n  'vw',\n  'vh',\n  'vmin',\n  'vmax',\n  // Absolute lengths.\n  'cm',\n  'mm',\n  'q',\n  'in',\n  'pc',\n  'pt',\n  'px',\n  // Percentage.\n  '%',\n];\n\n// This is also used in scroll-timeline-css.js\nexport const RegexMatcher = {\n  IDENTIFIER: /[\\w\\\\\\@_-]+/g,\n  WHITE_SPACE: /\\s*/g,\n  NUMBER: /^[0-9]+/,\n  TIME: /^[0-9]+(s|ms)/,\n  ANIMATION_TIMELINE: /animation-timeline\\s*:([^;}]+)/,\n  ANIMATION_NAME: /animation-name\\s*:([^;}]+)/,\n  ANIMATION: /animation\\s*:([^;}]+)/,\n  OFFSET_WITH_SUFFIX: new RegExp('(^[0-9]+)(' + VALID_SCROLL_OFFSET_SUFFIXES.join('|') + ')'),\n  ELEMENT_OFFSET: /selector\\(#([^)]+)\\)[ ]{0,1}(start|end)*[ ]{0,1}([0-9]+[.]{0,1}[0-9]*)*/,\n  SOURCE_ELEMENT: /selector\\(#([^)]+)\\)/,\n};\n\n// Used for ANIMATION_TIMELINE, ANIMATION_NAME and ANIMATION regex\nconst VALUES_CAPTURE_INDEX = 1;\n\nconst WHOLE_MATCH_INDEX = 0;\n\nconst ANIMATION_KEYWORDS = [\n  'normal', 'reverse', 'alternate', 'alternate-reverse',\n  'none', 'forwards', 'backwards', 'both',\n  'running', 'paused',\n  'ease', 'linear', 'ease-in', 'ease-out', 'ease-in-out'\n];\n\n// 1 - Extracts @scroll-timeline and saves it in scrollTimelineOptions.\n// 2 - If we find any animation-timeline in any of the CSS Rules, \n// we will save objects in a list named cssRulesWithTimelineName\nexport class StyleParser {\n  constructor() {\n    this.cssRulesWithTimelineName = [];\n    this.scrollTimelineOptions = new Map(); // save options by name\n    this.keyframeNames = new Set();\n  }\n\n  // Inspired by\n  // https://drafts.csswg.org/css-syntax/#parser-diagrams\n  // https://github.com/GoogleChromeLabs/container-query-polyfill/blob/main/src/engine.ts\n  // This function is called twice, in the first pass we are interested in saving\n  // @scroll-timeline and @keyframe names, in the second pass\n  // we will parse other rules\n  transpileStyleSheet(sheetSrc, firstPass, srcUrl) {\n    // AdhocParser\n    const p = {\n      sheetSrc: sheetSrc,\n      index: 0,\n      name: srcUrl,\n    };\n\n    while (p.index < p.sheetSrc.length) {\n      this.eatWhitespace(p);\n      if (p.index >= p.sheetSrc.length) break;\n      if (this.lookAhead(\"/*\", p)) {\n        while (this.lookAhead(\"/*\", p)) {\n          this.eatComment(p);\n          this.eatWhitespace(p);\n        }\n        continue;\n      }\n\n      if (this.lookAhead(\"@scroll-timeline\", p)) {\n        const { scrollTimeline, startIndex, endIndex } = this.parseScrollTimeline(p);\n        if (firstPass) this.scrollTimelineOptions.set(scrollTimeline.name, scrollTimeline);\n      } else {\n        const rule = this.parseQualifiedRule(p);\n        if (!rule) continue;\n        if (firstPass) {\n          this.extractAndSaveKeyframeName(rule.selector);\n        } else {\n          this.handleScrollTimelineProps(rule, p);\n        }\n      }\n    }\n\n    // If this sheet has no srcURL (like from a <style> tag), we are done.\n    // TODO: Otherwise, we have to find `url()` functions and resolve\n    // relative and path-absolute URLs to absolute URLs.\n    return p.sheetSrc;\n  }\n\n  getScrollTimelineName(animationName, target) {\n    // Rules are pushed to cssRulesWithTimelineName list in the same order as they appear in style sheet.\n    // We are traversing backwards to take the last sample of a rule in a style sheet.\n    // TODO: Rule specificity should be taken into account, i.e. don't just take the last\n    // rule that matches, instead take the one with the most specifity among those that match\n    for (let i = this.cssRulesWithTimelineName.length - 1; i >= 0; i--) {\n      const current = this.cssRulesWithTimelineName[i];\n      if (target.matches(current.selector)) {\n        if (!current['animation-name'] || current['animation-name'] == animationName) {\n          return current['animation-timeline'];\n        }\n      }\n    }\n\n    return null;\n  }\n\n  parseScrollTimeline(p) {\n    const startIndex = p.index;\n    this.assertString(p, \"@scroll-timeline\");\n    this.eatWhitespace(p);\n    let name = this.parseIdentifier(p);\n    this.eatWhitespace(p);\n    this.assertString(p, \"{\"); // eats {\n    this.eatWhitespace(p);\n\n    let scrollTimeline = {\n      name: name,\n      source: \"auto\",\n      orientation: undefined,\n      'scroll-offsets': undefined\n    };\n\n    while (this.peek(p) !== \"}\") {\n      const property = this.parseIdentifier(p);\n      this.eatWhitespace(p);\n      this.assertString(p, \":\");\n      this.eatWhitespace(p);\n      scrollTimeline[property] = this.removeEnclosingDoubleQuotes(this.eatUntil(\";\", p));\n      this.assertString(p, \";\");\n      this.eatWhitespace(p);\n    }\n\n    this.assertString(p, \"}\");\n    const endIndex = p.index;\n    this.eatWhitespace(p);\n    return {\n      scrollTimeline,\n      startIndex,\n      endIndex,\n    };\n  }\n\n  handleScrollTimelineProps(rule, p) {\n    // The animation-timeline property may not be used in keyframes\n    if (rule.selector.includes(\"@keyframes\")) {\n      return;\n    }\n\n    // TODO is it enough to check with \"includes()\"\n    const hasAnimationName = rule.block.contents.includes(\"animation-name:\");\n    const hasAnimationTimeline = rule.block.contents.includes(\"animation-timeline:\");\n    const hasAnimation = rule.block.contents.includes(\"animation:\");\n\n    let timelineNames = [];\n    let animationNames = [];\n\n    if (hasAnimationTimeline) {\n      timelineNames = this.extractMatches(rule.block.contents, RegexMatcher.ANIMATION_TIMELINE);\n    }\n\n    if (hasAnimationName) {\n      animationNames = this.extractMatches(rule.block.contents, RegexMatcher.ANIMATION_NAME);\n    }\n\n    if (hasAnimationTimeline && hasAnimationName) {\n      this.saveRelationInList(rule, timelineNames, animationNames);\n      return;\n    }\n\n    if (hasAnimation) {\n      this.extractMatches(rule.block.contents, RegexMatcher.ANIMATION)\n        .forEach(shorthand => {\n          const animationName = this.extractAnimationName(shorthand);\n          const timelineName = this.extractTimelineName(shorthand);\n          if (animationName) animationNames.push(animationName);\n          if (timelineName) {\n            timelineNames.push(timelineName);\n            // Remove timeline name from animation shorthand\n            // so the native implementation works with the rest of the properties\n            // Retain length of original name though, to play nice with multiple\n            // animations that might have been applied\n            rule.block.contents = rule.block.contents.replace(\n              timelineName,\n              \" \".repeat(timelineName.length)\n            );\n            this.replacePart(\n              rule.block.startIndex,\n              rule.block.endIndex,\n              rule.block.contents,\n              p\n            );\n          }\n        });\n    }\n\n    this.saveRelationInList(rule, timelineNames, animationNames);\n  }\n\n  saveRelationInList(rule, timelineNames, animationNames) {\n    if (animationNames.length == 0) {\n      for (let i = 0; i < timelineNames.length; i++) {\n        this.cssRulesWithTimelineName.push({\n          selector: rule.selector,\n          'animation-name': undefined,\n          'animation-timeline': timelineNames[i]\n        });\n      }\n    } else {\n      for (let i = 0; i < Math.max(timelineNames.length, animationNames.length); i++) {\n        this.cssRulesWithTimelineName.push({\n          selector: rule.selector,\n          'animation-name': animationNames[i % animationNames.length],\n          'animation-timeline': timelineNames[i % timelineNames.length]\n        });\n      }\n    }\n\n  }\n\n  extractAnimationName(shorthand) {\n    return this.findMatchingEntryInContainer(shorthand, this.keyframeNames);\n  }\n\n  extractTimelineName(shorthand) {\n    return this.findMatchingEntryInContainer(shorthand, this.scrollTimelineOptions);\n  }\n\n  findMatchingEntryInContainer(shorthand, container) {\n    const matches = shorthand.split(\" \").filter(part => container.has(part))\n    return matches ? matches[0] : null;\n  }\n\n\n  parseIdentifier(p) {\n    RegexMatcher.IDENTIFIER.lastIndex = p.index;\n    const match = RegexMatcher.IDENTIFIER.exec(p.sheetSrc);\n    if (!match) {\n      throw this.parseError(p, \"Expected an identifier\");\n    }\n    p.index += match[WHOLE_MATCH_INDEX].length;\n    return match[WHOLE_MATCH_INDEX];\n  }\n\n  /**\n   * @param {String} selector contains everything upto '{', eg: \"@keyframes expand\"\n   */\n  extractAndSaveKeyframeName(selector) {\n    if (selector.startsWith(\"@keyframes\")) {\n      selector.split(\" \").forEach((item, index) => {\n        if (index > 0) {\n          this.keyframeNames.add(item);\n        }\n      })\n    }\n  }\n\n  parseQualifiedRule(p) {\n    const startIndex = p.index;\n    const selector = this.parseSelector(p).trim();\n    if (!selector) return;\n    const block = this.eatBlock(p);\n    const endIndex = p.index;\n    return {\n      selector,\n      block,\n      startIndex,\n      endIndex,\n    };\n  }\n\n  removeEnclosingDoubleQuotes(s) {\n    let startIndex = s[0] == '\"' ? 1 : 0;\n    let endIndex = s[s.length - 1] == '\"' ? s.length - 1 : s.length;\n    return s.substring(startIndex, endIndex);\n  }\n\n  assertString(p, s) {\n    if (p.sheetSrc.substr(p.index, s.length) != s) {\n      throw this.parseError(p, `Did not find expected sequence ${s}`);\n    }\n    p.index += s.length;\n  }\n\n  replacePart(start, end, replacement, p) {\n    p.sheetSrc = p.sheetSrc.slice(0, start) + replacement + p.sheetSrc.slice(end);\n    // If we are pointing past the end of the affected section, we need to\n    // recalculate the string pointer. Pointing to something inside the section\n    // that’s being replaced is undefined behavior. Sue me.\n    if (p.index >= end) {\n      const delta = p.index - end;\n      p.index = start + replacement.length + delta;\n    }\n  }\n\n  eatComment(p) {\n    this.assertString(p, \"/*\");\n    this.eatUntil(\"*/\", p);\n    this.assertString(p, \"*/\");\n  }\n\n  eatBlock(p) {\n    const startIndex = p.index;\n    this.assertString(p, \"{\");\n    let level = 1;\n    while (level != 0) {\n      if (p.sheetSrc[p.index] === \"{\") {\n        level++;\n      } else if (p.sheetSrc[p.index] === \"}\") {\n        level--;\n      }\n      this.advance(p);\n    }\n    const endIndex = p.index;\n    const contents = p.sheetSrc.slice(startIndex, endIndex);\n\n    return { startIndex, endIndex, contents };\n  }\n\n  advance(p) {\n    p.index++;\n    if (p.index > p.sheetSrc.length) {\n      throw this.parseError(p, \"Advanced beyond the end\");\n    }\n  }\n\n  eatUntil(s, p) {\n    const startIndex = p.index;\n    while (!this.lookAhead(s, p)) {\n      this.advance(p);\n    }\n    return p.sheetSrc.slice(startIndex, p.index);\n  }\n\n  parseSelector(p) {\n    let startIndex = p.index;\n    this.eatUntil(\"{\", p);\n    if (startIndex === p.index) {\n      throw Error(\"Empty selector\");\n    }\n\n    return p.sheetSrc.slice(startIndex, p.index);\n  }\n\n  eatWhitespace(p) {\n    // Start matching at the current position in the sheet src\n    RegexMatcher.WHITE_SPACE.lastIndex = p.index;\n    const match = RegexMatcher.WHITE_SPACE.exec(p.sheetSrc);\n    if (match) {\n      p.index += match[WHOLE_MATCH_INDEX].length;\n    }\n  }\n\n  lookAhead(s, p) {\n    return p.sheetSrc.substr(p.index, s.length) == s;\n  }\n\n  peek(p) {\n    return p.sheetSrc[p.index];\n  }\n\n  extractMatches(contents, matcher) {\n    return matcher.exec(contents)[VALUES_CAPTURE_INDEX].trim().split(\",\").map(item => item.trim());\n  }\n}\n\nfunction isTime(s) {\n  return RegexMatcher.TIME.exec(s);\n}\n\nfunction isNumber(s) {\n  return RegexMatcher.NUMBER.exec(s);\n}\n\nexport function removeKeywordsFromAnimationShorthand(anim) {\n  return anim.split(' ').filter(\n    (item, index, array) => index == array.length - 1 || !ANIMATION_KEYWORDS.includes(item))\n    .filter(item => !isTime(item) && !isNumber(item));\n}\n","import { StyleParser, RegexMatcher } from \"./scroll-timeline-css-parser\";\nimport { ProxyAnimation } from \"./proxy-animation\"\n\nconst parser = new StyleParser();\n\nfunction initMutationObserver() {\n  const sheetObserver = new MutationObserver((entries) => {\n    for (const entry of entries) {\n      for (const addedNode of entry.addedNodes) {\n        if (addedNode instanceof HTMLStyleElement) {\n          handleStyleTag(addedNode);\n        }\n        if (addedNode instanceof HTMLLinkElement) {\n          handleLinkedStylesheet(addedNode);\n        }\n      }\n    }\n\n    // TODO: Proxy element.style similar to how we proxy element.animate.\n    // We accomplish this by swapping out Element.prototype.style.\n  });\n\n  sheetObserver.observe(document.documentElement, {\n    childList: true,\n    subtree: true,\n  });\n\n  /**\n   * @param {HtmlStyleElement} el style tag to be parsed\n   */\n  function handleStyleTag(el) {\n    // Don’t touch empty style tags.\n    if (el.innerHTML.trim().length === 0) {\n      return;\n    }\n    // TODO: Do with one pass for better performance\n    let newSrc = parser.transpileStyleSheet(el.innerHTML, true);\n    newSrc = parser.transpileStyleSheet(newSrc, false);\n    el.innerHTML = newSrc;\n  }\n\n  function handleLinkedStylesheet(el) {\n    // TODO\n  }\n\n  document.querySelectorAll(\"style\").forEach((tag) => handleStyleTag(tag));\n  document\n    .querySelectorAll(\"link\")\n    .forEach((tag) => handleLinkedStylesheet(tag));\n}\n\n// This implementation is based on https://drafts.csswg.org/scroll-animations-1/\n// TODO: Should update accordingly when new spec lands.\nfunction getSourceElement(source) {\n  const matches = RegexMatcher.SOURCE_ELEMENT.exec(source);\n  const SOURCE_CAPTURE_INDEX = 1;\n  if (matches) {\n    return document.getElementById(matches[SOURCE_CAPTURE_INDEX]);\n  } else if (source === \"auto\") {\n    return document.scrollingElement;\n  } else {\n    return null;\n  }\n}\n\n// This implementation is based on https://drafts.csswg.org/scroll-animations-1/\n// 'scroll-offsets' are likely to be deprecated,\n// TODO: Should update accordingly when new spec lands.\nfunction convertOneScrollOffset(part) {\n  if (part == 'auto') return new CSSKeywordValue('auto');\n\n  const matchesOffsetWithSuffix = RegexMatcher.OFFSET_WITH_SUFFIX.exec(part);\n  const VALUE_CAPTURE_INDEX = 1;\n  const UNIT_CAPTURE_INDEX = 2;\n  if (matchesOffsetWithSuffix) {\n    return new CSSUnitValue(parseInt(matchesOffsetWithSuffix[VALUE_CAPTURE_INDEX]), matchesOffsetWithSuffix[UNIT_CAPTURE_INDEX]);\n  }\n\n  const matchesElementOffset = RegexMatcher.ELEMENT_OFFSET.exec(part);\n  const SOURCE_CAPTURE_INDEX = 1;\n  const EDGE_CAPTURE_INDEX = 2;\n  const THRESHOLD_CAPTURE_INDEX = 3;\n  if (matchesElementOffset) {\n    if (document.getElementById(matchesElementOffset[SOURCE_CAPTURE_INDEX])) {\n      return {\n        target: document.getElementById(matchesElementOffset[SOURCE_CAPTURE_INDEX]),\n        ...(matchesElementOffset.length >= 3 ? { edge: matchesElementOffset[EDGE_CAPTURE_INDEX] } : {}),\n        ...(matchesElementOffset.length >= 4 ? { threshold: parseFloat(matchesElementOffset[THRESHOLD_CAPTURE_INDEX]) } : {})\n      };\n    }\n  }\n\n  return null;\n}\n\nfunction isDescendant(child, parent) {\n  while (child) {\n    if (child == parent) return true;\n    child = child.parentNode;\n  }\n  return false;\n}\n\n// This implementation is based on https://drafts.csswg.org/scroll-animations-1/\n// 'scroll-offsets' are likely to be deprecated,\n// TODO: Should update accordingly when new spec lands.\nfunction getScrollOffsets(source, offsets) {\n  let scrollOffsets = undefined;\n\n  if (offsets) {\n    if (offsets == \"none\") {\n      // do nothing\n    } else {\n      scrollOffsets = offsets.split(\",\")\n        .map(part => part.trim())\n        .filter(part => part != '')\n        .map(part => convertOneScrollOffset(part))\n        .filter(offset => offset);\n\n      // If the available scroll-offsets are not valid,\n      // so we won't create the scrollTimeline,\n      for (let off of scrollOffsets) {\n        if (off.target && off.target instanceof Element &&\n          (window.getComputedStyle(off.target, null).display == \"none\" || !isDescendant(off.target, source))) {\n          return null;\n        }\n      }\n      if (scrollOffsets.length == 0) {\n        return null;\n      }\n    }\n  }\n\n  return scrollOffsets;\n}\n\nfunction createScrollTimeline(name) {\n  const options = parser.scrollTimelineOptions.get(name);\n  if (!options) return null;\n\n  const sourceElement = getSourceElement(options.source);\n  const scrollOffsets = getScrollOffsets(sourceElement, options['scroll-offsets']);\n\n  // TODO: Handle invalid scrollOffsets differently, don't return null for scrollTimeline, should check native implementation\n  if (scrollOffsets !== null) {\n    const scrollTimeline = new ScrollTimeline({\n      ...(sourceElement ? { source: getSourceElement(options.source) } : {}),\n      ...(scrollOffsets ? { scrollOffsets: scrollOffsets } : {}),\n      ...(options.orientation != \"auto\" ? { orientation: options.orientation } : {}),\n    });\n    return scrollTimeline;\n  } else {\n    return null;\n  }\n}\n\nexport function initCSSPolyfill() {\n  // Don't load if browser claims support\n  if (CSS.supports(\"animation-timeline: works\")) {\n    return;\n  }\n\n  initMutationObserver();\n\n  // We are not wrapping capturing 'animationstart' by a 'load' event,\n  // because we may lose some of the 'animationstart' events by the time 'load' is completed.\n  window.addEventListener('animationstart', (evt) => {\n    evt.target.getAnimations().filter(anim => anim.animationName === evt.animationName).forEach(anim => {\n      const timelineName = parser.getScrollTimelineName(anim.animationName, evt.target);\n      if (timelineName) {\n        const scrollTimeline = createScrollTimeline(timelineName);\n        if (anim.timeline != scrollTimeline) {\n          const proxyAnimation = new ProxyAnimation(anim, scrollTimeline);\n          anim.pause();\n          proxyAnimation.play();\n        }\n      }\n    });\n  });\n}\n","// Copyright 2019 Google LLC\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\nimport {\n  ScrollTimeline,\n  ViewTimeline,\n  installScrollOffsetExtension\n} from \"./scroll-timeline-base\";\nimport {\n  animate,\n  ProxyAnimation\n} from \"./proxy-animation.js\";\n\nimport { calculateOffset, parseOffset } from \"./intersection-based-offset\";\nimport { initCSSPolyfill } from \"./scroll-timeline-css\"\n\ninstallScrollOffsetExtension(parseOffset, calculateOffset);\ninitCSSPolyfill();\n\nif (\n  !Reflect.defineProperty(window, \"ScrollTimeline\", { value: ScrollTimeline })\n) {\n  throw Error(\n    \"Error installing ScrollTimeline polyfill: could not attach ScrollTimeline to window\"\n  );\n}\nif (\n  !Reflect.defineProperty(window, \"ViewTimeline\", { value: ViewTimeline })\n) {\n  throw Error(\n    \"Error installing ViewTimeline polyfill: could not attach ViewTimeline to window\"\n  );\n}\n\nif (!Reflect.defineProperty(Element.prototype, \"animate\", { value: animate })) {\n  throw Error(\n    \"Error installing ScrollTimeline polyfill: could not attach WAAPI's animate to DOM Element\"\n  );\n}\nif (!Reflect.defineProperty(window, \"Animation\", {value: ProxyAnimation})) {\n  throw Error(\"Error installing Animation constructor.\");\n}\n"],"names":["parseLength","obj","acceptStr","CSSUnitValue","CSSMathSum","matches","trim","match","_cssOMTypes","privateDetails","WeakMap","toCssNumericArray","values","v","result","i","length","MathOperation","operator","opt_name","opt_delimiter","set","this","name","delimiter","toString","details","get","join","_createClass","key","cssOMTypes","value","unit","prototype","toLowerCase","displayUnit","CSSKeywordValue","_MathOperation","call","arguments","_inheritsLoose","CSSMathProduct","_MathOperation2","CSSMathNegate","_MathOperation3","_MathOperation4","_MathOperation5","CSSMathMax","_MathOperation6","CSSMathMin","window","CSS","Reflect","defineProperty","Error","type","forEach","installCSSOM","AUTO","scrollTimelineOptions","extensionScrollOffsetFunctions","scrollEventSource","source","document","scrollingElement","updateInternal","scrollTimelineInstance","animations","timelineTime","currentTime","tickAnimation","directionAwareScrollOffset","orientation","horizontalWritingMode","getComputedStyle","writingMode","currentScrollOffset","scrollTop","Math","abs","scrollLeft","resolvePx","cssValue","resolvedLength","TypeError","total","_step","calculateScrollOffset","autoValue","offset","fn","maxValue","scrollHeight","clientHeight","scrollWidth","clientWidth","resolveScrollOffsets","scrollOffsets","fns","effectiveScrollOffsets","firstOffset","push","effectiveOffset","removeAnimation","scrollTimeline","animation","splice","addAnimation","ScrollTimeline","options","scrollOffsetFns","undefined","element","_this","removeEventListener","addEventListener","indexOf","_step2","offsets","_iterator2","done","input","parse","evaluate","parsed","data","percent","scrollerStyle","display","overflow","maxOffset","startOffset","endOffset","phase","progress","offsetIndex","ComputeProgress","getScrollParent","node","parentNode","ViewTimeline","_ScrollTimeline","_this2","subject","range","container","offsetParent","target","top","left","offsetLeft","offsetTop","style","viewSize","viewPos","containerSize","direction","scrollPos","nativeElementAnimate","Element","animate","nativeAnimation","Animation","PromiseWrapper","state","nativeResolve","nativeReject","promise","Promise","resolve","reject","reason","createReadyPromise","readyPromise","requestAnimationFrame","timeline","notifyReady","createAbortError","DOMException","toCssNumberish","limit","effectEnd","fromCssNumberish","duration","convertedTime","to","convertTime","commitFinishedNotification","finishedPromise","proxy","playState","pause","finishedEvent","CustomEvent","detail","Object","queueMicrotask","dispatchEvent","effectivePlaybackRate","pendingPlaybackRate","playbackRate","applyPendingPlaybackRate","calculateCurrentTime","startTime","calculateStartTime","updateFinishedState","didSeek","synchronouslyNotify","unconstrainedCurrentTime","pending","upperBound","boundary","previousCurrentTime","holdTime","syncCurrentTime","then","timing","effect","getTiming","normalizedTiming","max","delay","endDelay","iterations","playInternal","autoRewind","abortedPause","hasPendingReadyPromise","seekTime","resetCurrentTimeOnResume","Infinity","play","bind","pendingTask","proxyAnimations","timelineTimeMs","cancel","readyTime","commitPendingPause","currentTimeToMatch","commitPendingPlay","ProxyAnimation","animationTimeline","isScrollAnimation","specifiedTiming","_proto2","finish","reverse","inifiniteDuration","reversable","updatePlaybackRate","rate","persist","resetPendingTasks","callback","event","nativeUpdateTiming","updateTiming","getComputedTimingHandler","apply","localTime","endTime","activeDuration","fill","getTimingHandler","thisArg","assign","updateTimingHandler","argumentsList","Proxy","prop","getComputedTiming","createProxyEffect","newEffect","newTimeline","oldTimeline","previousPlayState","end","fromScrollTimeline","toScrollTimeline","timelinePhase","id","onfinish","oncancel","onremove","finished","ready","IntersectionOptions","MARGIN_MAP","IntersectionBasedOffset","edge","threshold","rootMargin","clamp","parseFloat","map","margin","margins","split","parsedMargins","parsedValue","positions","j","RegexMatcher","IDENTIFIER","WHITE_SPACE","NUMBER","TIME","ANIMATION_TIMELINE","ANIMATION_NAME","ANIMATION","OFFSET_WITH_SUFFIX","RegExp","ELEMENT_OFFSET","SOURCE_ELEMENT","parser","StyleParser","cssRulesWithTimelineName","Map","keyframeNames","Set","transpileStyleSheet","sheetSrc","firstPass","srcUrl","p","index","eatWhitespace","lookAhead","eatComment","parseScrollTimeline","rule","parseQualifiedRule","extractAndSaveKeyframeName","selector","handleScrollTimelineProps","_proto","getScrollTimelineName","animationName","current","startIndex","assertString","parseIdentifier","peek","property","removeEnclosingDoubleQuotes","eatUntil","endIndex","includes","hasAnimationName","block","contents","hasAnimationTimeline","hasAnimation","timelineNames","animationNames","extractMatches","shorthand","extractAnimationName","timelineName","extractTimelineName","replace","repeat","replacePart","saveRelationInList","findMatchingEntryInContainer","filter","part","has","lastIndex","exec","parseError","startsWith","item","add","parseSelector","eatBlock","s","substring","substr","start","replacement","slice","level","advance","matcher","getSourceElement","getElementById","isDescendant","child","parent","calculateOffset","startOrEnd","originalViewport","right","bottom","width","height","getBoundingClientRect","computedMargins","viewport","clamped","point","min","supports","handleStyleTag","el","innerHTML","newSrc","MutationObserver","entries","_iterator","_createForOfIteratorHelperLoose","addedNodes","addedNode","HTMLStyleElement","observe","documentElement","childList","subtree","querySelectorAll","tag","initMutationObserver","evt","getAnimations","anim","sourceElement","_step3","_iterator3","convertOneScrollOffset","matchesOffsetWithSuffix","parseInt","matchesElementOffset","_extends","off","getScrollOffsets","createScrollTimeline","proxyAnimation","keyframes"],"mappings":"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"}