@angular/animations 17.0.0-next.5 → 17.0.0-next.7

package/esm2022/src/version.mjs

@@ -11,5 +11,5 @@
  * Entry point for all public APIs of the animation package.
  */
 import { Version } from '@angular/core';
-export const VERSION = new Version('17.0.0-next.5');
+export const VERSION = new Version('17.0.0-next.7');
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2FuaW1hdGlvbnMvc3JjL3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUg7Ozs7R0FJRztBQUNILE9BQU8sRUFBQyxPQUFPLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFdEMsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBAbW9kdWxlXG4gKiBAZGVzY3JpcHRpb25cbiAqIEVudHJ5IHBvaW50IGZvciBhbGwgcHVibGljIEFQSXMgb2YgdGhlIGFuaW1hdGlvbiBwYWNrYWdlLlxuICovXG5pbXBvcnQge1ZlcnNpb259IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IG5ldyBWZXJzaW9uKCcwLjAuMC1QTEFDRUhPTERFUicpO1xuIl19

package/fesm2022/animations.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.5
+ * @license Angular v17.0.0-next.7
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */

package/fesm2022/browser/testing.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.5
+ * @license Angular v17.0.0-next.7
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */

package/fesm2022/browser.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v17.0.0-next.5
+ * @license Angular v17.0.0-next.7
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -494,42 +494,84 @@ function hypenatePropsKeys(original) {
     return newMap;
 }
 
+/**
+ * @publicApi
+ *
+ * `AnimationDriver` implentation for Noop animations
+ */
 class NoopAnimationDriver {
+    /**
+     * @returns Whether `prop` is a valid CSS property
+     */
     validateStyleProperty(prop) {
         return validateStyleProperty(prop);
     }
+    /**
+     * @deprecated unused
+     */
     matchesElement(_element, _selector) {
         // This method is deprecated and no longer in use so we return false.
         return false;
     }
+    /**
+     *
+     * @returns Whether elm1 contains elm2.
+     */
     containsElement(elm1, elm2) {
         return containsElement(elm1, elm2);
     }
+    /**
+     * @returns Rhe parent of the given element or `null` if the element is the `document`
+     */
     getParentElement(element) {
         return getParentElement(element);
     }
+    /**
+     * @returns The result of the query selector on the element. The array will contain up to 1 item
+     *     if `multi` is  `false`.
+     */
     query(element, selector, multi) {
         return invokeQuery(element, selector, multi);
     }
+    /**
+     * @returns The `defaultValue` or empty string
+     */
     computeStyle(element, prop, defaultValue) {
         return defaultValue || '';
     }
+    /**
+     * @returns An `NoopAnimationPlayer`
+     */
     animate(element, keyframes, duration, delay, easing, previousPlayers = [], scrubberAccessRequested) {
         return new NoopAnimationPlayer(duration, delay);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0-next.5", ngImport: i0, type: NoopAnimationDriver, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0-next.5", ngImport: i0, type: NoopAnimationDriver }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0-next.7", ngImport: i0, type: NoopAnimationDriver, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.0-next.7", ngImport: i0, type: NoopAnimationDriver }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0-next.5", ngImport: i0, type: NoopAnimationDriver, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0-next.7", ngImport: i0, type: NoopAnimationDriver, decorators: [{
             type: Injectable
         }] });
 /**
  * @publicApi
  */
 class AnimationDriver {
+    /**
+     * @deprecated Use the NoopAnimationDriver class.
+     */
     static { this.NOOP = ( /* @__PURE__ */new NoopAnimationDriver()); }
 }
 
+class AnimationStyleNormalizer {
+}
+class NoopAnimationStyleNormalizer {
+    normalizePropertyName(propertyName, errors) {
+        return propertyName;
+    }
+    normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
+        return value;
+    }
+}
+
 const ONE_SECOND = 1000;
 const SUBSTITUTION_EXPR_START = '{{';
 const SUBSTITUTION_EXPR_END = '}}';
@@ -779,6 +821,59 @@ function computeStyle(element, prop) {
     return window.getComputedStyle(element)[prop];
 }
 
+const DIMENSIONAL_PROP_SET = new Set([
+    'width',
+    'height',
+    'minWidth',
+    'minHeight',
+    'maxWidth',
+    'maxHeight',
+    'left',
+    'top',
+    'bottom',
+    'right',
+    'fontSize',
+    'outlineWidth',
+    'outlineOffset',
+    'paddingTop',
+    'paddingLeft',
+    'paddingBottom',
+    'paddingRight',
+    'marginTop',
+    'marginLeft',
+    'marginBottom',
+    'marginRight',
+    'borderRadius',
+    'borderWidth',
+    'borderTopWidth',
+    'borderLeftWidth',
+    'borderRightWidth',
+    'borderBottomWidth',
+    'textIndent',
+    'perspective'
+]);
+class WebAnimationsStyleNormalizer extends AnimationStyleNormalizer {
+    normalizePropertyName(propertyName, errors) {
+        return dashCaseToCamelCase(propertyName);
+    }
+    normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
+        let unit = '';
+        const strVal = value.toString().trim();
+        if (DIMENSIONAL_PROP_SET.has(normalizedProperty) && value !== 0 && value !== '0') {
+            if (typeof value === 'number') {
+                unit = 'px';
+            }
+            else {
+                const valAndSuffixMatch = value.match(/^[+-]?[\d\.]+([a-z]*)$/);
+                if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {
+                    errors.push(invalidCssUnitValue(userProvidedProperty, value));
+                }
+            }
+        }
+        return strVal + unit;
+    }
+}
+
 function createListOfWarnings(warnings) {
     const LINE_START = '\n - ';
     return `${LINE_START}${warnings.filter(Boolean).map(warning => warning).join(LINE_START)}`;
@@ -2167,99 +2262,6 @@ function flattenStyles(input, allStyles) {
     return styles;
 }
 
-class Animation {
-    constructor(_driver, input) {
-        this._driver = _driver;
-        const errors = [];
-        const warnings = [];
-        const ast = buildAnimationAst(_driver, input, errors, warnings);
-        if (errors.length) {
-            throw validationFailed(errors);
-        }
-        if (warnings.length) {
-            warnValidation(warnings);
-        }
-        this._animationAst = ast;
-    }
-    buildTimelines(element, startingStyles, destinationStyles, options, subInstructions) {
-        const start = Array.isArray(startingStyles) ? normalizeStyles(startingStyles) :
-            startingStyles;
-        const dest = Array.isArray(destinationStyles) ? normalizeStyles(destinationStyles) :
-            destinationStyles;
-        const errors = [];
-        subInstructions = subInstructions || new ElementInstructionMap();
-        const result = buildAnimationTimelines(this._driver, element, this._animationAst, ENTER_CLASSNAME, LEAVE_CLASSNAME, start, dest, options, subInstructions, errors);
-        if (errors.length) {
-            throw buildingFailed(errors);
-        }
-        return result;
-    }
-}
-
-class AnimationStyleNormalizer {
-}
-class NoopAnimationStyleNormalizer {
-    normalizePropertyName(propertyName, errors) {
-        return propertyName;
-    }
-    normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
-        return value;
-    }
-}
-
-const DIMENSIONAL_PROP_SET = new Set([
-    'width',
-    'height',
-    'minWidth',
-    'minHeight',
-    'maxWidth',
-    'maxHeight',
-    'left',
-    'top',
-    'bottom',
-    'right',
-    'fontSize',
-    'outlineWidth',
-    'outlineOffset',
-    'paddingTop',
-    'paddingLeft',
-    'paddingBottom',
-    'paddingRight',
-    'marginTop',
-    'marginLeft',
-    'marginBottom',
-    'marginRight',
-    'borderRadius',
-    'borderWidth',
-    'borderTopWidth',
-    'borderLeftWidth',
-    'borderRightWidth',
-    'borderBottomWidth',
-    'textIndent',
-    'perspective'
-]);
-class WebAnimationsStyleNormalizer extends AnimationStyleNormalizer {
-    normalizePropertyName(propertyName, errors) {
-        return dashCaseToCamelCase(propertyName);
-    }
-    normalizeStyleValue(userProvidedProperty, normalizedProperty, value, errors) {
-        let unit = '';
-        const strVal = value.toString().trim();
-        if (DIMENSIONAL_PROP_SET.has(normalizedProperty) && value !== 0 && value !== '0') {
-            if (typeof value === 'number') {
-                unit = 'px';
-            }
-            else {
-                const valAndSuffixMatch = value.match(/^[+-]?[\d\.]+([a-z]*)$/);
-                if (valAndSuffixMatch && valAndSuffixMatch[1].length == 0) {
-                    errors.push(invalidCssUnitValue(userProvidedProperty, value));
-                }
-            }
-        }
-        return strVal + unit;
-    }
-}
-
 function createTransitionInstruction(element, triggerName, fromState, toState, isRemovalTransition, fromStyles, toStyles, timelines, queriedElements, preStyleProps, postStyleProps, totalTime, errors) {
     return {
         type: 0 /* AnimationTransitionInstructionType.TransitionAnimation */,
@@ -4499,6 +4501,299 @@ class WebAnimationsDriver {
     }
 }
 
+function createEngine(type, doc) {
+    // TODO: find a way to make this tree shakable.
+    if (type === 'noop') {
+        return new AnimationEngine(doc, new NoopAnimationDriver(), new NoopAnimationStyleNormalizer());
+    }
+    return new AnimationEngine(doc, new WebAnimationsDriver(), new WebAnimationsStyleNormalizer());
+}
+
+class Animation {
+    constructor(_driver, input) {
+        this._driver = _driver;
+        const errors = [];
+        const warnings = [];
+        const ast = buildAnimationAst(_driver, input, errors, warnings);
+        if (errors.length) {
+            throw validationFailed(errors);
+        }
+        if (warnings.length) {
+            warnValidation(warnings);
+        }
+        this._animationAst = ast;
+    }
+    buildTimelines(element, startingStyles, destinationStyles, options, subInstructions) {
+        const start = Array.isArray(startingStyles) ? normalizeStyles(startingStyles) :
+            startingStyles;
+        const dest = Array.isArray(destinationStyles) ? normalizeStyles(destinationStyles) :
+            destinationStyles;
+        const errors = [];
+        subInstructions = subInstructions || new ElementInstructionMap();
+        const result = buildAnimationTimelines(this._driver, element, this._animationAst, ENTER_CLASSNAME, LEAVE_CLASSNAME, start, dest, options, subInstructions, errors);
+        if (errors.length) {
+            throw buildingFailed(errors);
+        }
+        return result;
+    }
+}
+
+const ANIMATION_PREFIX = '@';
+const DISABLE_ANIMATIONS_FLAG = '@.disabled';
+class BaseAnimationRenderer {
+    constructor(namespaceId, delegate, engine, _onDestroy) {
+        this.namespaceId = namespaceId;
+        this.delegate = delegate;
+        this.engine = engine;
+        this._onDestroy = _onDestroy;
+        this.isAnimationRenderer = true;
+    }
+    get data() {
+        return this.delegate.data;
+    }
+    destroyNode(node) {
+        this.delegate.destroyNode?.(node);
+    }
+    destroy() {
+        this.engine.destroy(this.namespaceId, this.delegate);
+        this.engine.afterFlushAnimationsDone(() => {
+            // Call the renderer destroy method after the animations has finished as otherwise
+            // styles will be removed too early which will cause an unstyled animation.
+            queueMicrotask(() => {
+                this.delegate.destroy();
+            });
+        });
+        this._onDestroy?.();
+    }
+    createElement(name, namespace) {
+        return this.delegate.createElement(name, namespace);
+    }
+    createComment(value) {
+        return this.delegate.createComment(value);
+    }
+    createText(value) {
+        return this.delegate.createText(value);
+    }
+    appendChild(parent, newChild) {
+        this.delegate.appendChild(parent, newChild);
+        this.engine.onInsert(this.namespaceId, newChild, parent, false);
+    }
+    insertBefore(parent, newChild, refChild, isMove = true) {
+        this.delegate.insertBefore(parent, newChild, refChild);
+        // If `isMove` true than we should animate this insert.
+        this.engine.onInsert(this.namespaceId, newChild, parent, isMove);
+    }
+    removeChild(parent, oldChild, isHostElement) {
+        this.engine.onRemove(this.namespaceId, oldChild, this.delegate);
+    }
+    selectRootElement(selectorOrNode, preserveContent) {
+        return this.delegate.selectRootElement(selectorOrNode, preserveContent);
+    }
+    parentNode(node) {
+        return this.delegate.parentNode(node);
+    }
+    nextSibling(node) {
+        return this.delegate.nextSibling(node);
+    }
+    setAttribute(el, name, value, namespace) {
+        this.delegate.setAttribute(el, name, value, namespace);
+    }
+    removeAttribute(el, name, namespace) {
+        this.delegate.removeAttribute(el, name, namespace);
+    }
+    addClass(el, name) {
+        this.delegate.addClass(el, name);
+    }
+    removeClass(el, name) {
+        this.delegate.removeClass(el, name);
+    }
+    setStyle(el, style, value, flags) {
+        this.delegate.setStyle(el, style, value, flags);
+    }
+    removeStyle(el, style, flags) {
+        this.delegate.removeStyle(el, style, flags);
+    }
+    setProperty(el, name, value) {
+        if (name.charAt(0) == ANIMATION_PREFIX && name == DISABLE_ANIMATIONS_FLAG) {
+            this.disableAnimations(el, !!value);
+        }
+        else {
+            this.delegate.setProperty(el, name, value);
+        }
+    }
+    setValue(node, value) {
+        this.delegate.setValue(node, value);
+    }
+    listen(target, eventName, callback) {
+        return this.delegate.listen(target, eventName, callback);
+    }
+    disableAnimations(element, value) {
+        this.engine.disableAnimations(element, value);
+    }
+}
+class AnimationRenderer extends BaseAnimationRenderer {
+    constructor(factory, namespaceId, delegate, engine, onDestroy) {
+        super(namespaceId, delegate, engine, onDestroy);
+        this.factory = factory;
+        this.namespaceId = namespaceId;
+    }
+    setProperty(el, name, value) {
+        if (name.charAt(0) == ANIMATION_PREFIX) {
+            if (name.charAt(1) == '.' && name == DISABLE_ANIMATIONS_FLAG) {
+                value = value === undefined ? true : !!value;
+                this.disableAnimations(el, value);
+            }
+            else {
+                this.engine.process(this.namespaceId, el, name.slice(1), value);
+            }
+        }
+        else {
+            this.delegate.setProperty(el, name, value);
+        }
+    }
+    listen(target, eventName, callback) {
+        if (eventName.charAt(0) == ANIMATION_PREFIX) {
+            const element = resolveElementFromTarget(target);
+            let name = eventName.slice(1);
+            let phase = '';
+            // @listener.phase is for trigger animation callbacks
+            // @@listener is for animation builder callbacks
+            if (name.charAt(0) != ANIMATION_PREFIX) {
+                [name, phase] = parseTriggerCallbackName(name);
+            }
+            return this.engine.listen(this.namespaceId, element, name, phase, event => {
+                const countId = event['_data'] || -1;
+                this.factory.scheduleListenerCallback(countId, callback, event);
+            });
+        }
+        return this.delegate.listen(target, eventName, callback);
+    }
+}
+function resolveElementFromTarget(target) {
+    switch (target) {
+        case 'body':
+            return document.body;
+        case 'document':
+            return document;
+        case 'window':
+            return window;
+        default:
+            return target;
+    }
+}
+function parseTriggerCallbackName(triggerName) {
+    const dotIndex = triggerName.indexOf('.');
+    const trigger = triggerName.substring(0, dotIndex);
+    const phase = triggerName.slice(dotIndex + 1);
+    return [trigger, phase];
+}
+
+class AnimationRendererFactory {
+    constructor(delegate, engine, _zone) {
+        this.delegate = delegate;
+        this.engine = engine;
+        this._zone = _zone;
+        this._currentId = 0;
+        this._microtaskId = 1;
+        this._animationCallbacksBuffer = [];
+        this._rendererCache = new Map();
+        this._cdRecurDepth = 0;
+        engine.onRemovalComplete = (element, delegate) => {
+            // Note: if a component element has a leave animation, and a host leave animation,
+            // the view engine will call `removeChild` for the parent
+            // component renderer as well as for the child component renderer.
+            // Therefore, we need to check if we already removed the element.
+            const parentNode = delegate?.parentNode(element);
+            if (parentNode) {
+                delegate.removeChild(parentNode, element);
+            }
+        };
+    }
+    createRenderer(hostElement, type) {
+        const EMPTY_NAMESPACE_ID = '';
+        // cache the delegates to find out which cached delegate can
+        // be used by which cached renderer
+        const delegate = this.delegate.createRenderer(hostElement, type);
+        if (!hostElement || !type?.data?.['animation']) {
+            const cache = this._rendererCache;
+            let renderer = cache.get(delegate);
+            if (!renderer) {
+                // Ensure that the renderer is removed from the cache on destroy
+                // since it may contain references to detached DOM nodes.
+                const onRendererDestroy = () => cache.delete(delegate);
+                renderer =
+                    new BaseAnimationRenderer(EMPTY_NAMESPACE_ID, delegate, this.engine, onRendererDestroy);
+                // only cache this result when the base renderer is used
+                cache.set(delegate, renderer);
+            }
+            return renderer;
+        }
+        const componentId = type.id;
+        const namespaceId = type.id + '-' + this._currentId;
+        this._currentId++;
+        this.engine.register(namespaceId, hostElement);
+        const registerTrigger = (trigger) => {
+            if (Array.isArray(trigger)) {
+                trigger.forEach(registerTrigger);
+            }
+            else {
+                this.engine.registerTrigger(componentId, namespaceId, hostElement, trigger.name, trigger);
+            }
+        };
+        const animationTriggers = type.data['animation'];
+        animationTriggers.forEach(registerTrigger);
+        return new AnimationRenderer(this, namespaceId, delegate, this.engine);
+    }
+    begin() {
+        this._cdRecurDepth++;
+        if (this.delegate.begin) {
+            this.delegate.begin();
+        }
+    }
+    _scheduleCountTask() {
+        queueMicrotask(() => {
+            this._microtaskId++;
+        });
+    }
+    /** @internal */
+    scheduleListenerCallback(count, fn, data) {
+        if (count >= 0 && count < this._microtaskId) {
+            this._zone.run(() => fn(data));
+            return;
+        }
+        const animationCallbacksBuffer = this._animationCallbacksBuffer;
+        if (animationCallbacksBuffer.length == 0) {
+            queueMicrotask(() => {
+                this._zone.run(() => {
+                    animationCallbacksBuffer.forEach(tuple => {
+                        const [fn, data] = tuple;
+                        fn(data);
+                    });
+                    this._animationCallbacksBuffer = [];
+                });
+            });
+        }
+        animationCallbacksBuffer.push([fn, data]);
+    }
+    end() {
+        this._cdRecurDepth--;
+        // this is to prevent animations from running twice when an inner
+        // component does CD when a parent component instead has inserted it
+        if (this._cdRecurDepth == 0) {
+            this._zone.runOutsideAngular(() => {
+                this._scheduleCountTask();
+                this.engine.flush(this._microtaskId);
+            });
+        }
+        if (this.delegate.end) {
+            this.delegate.end();
+        }
+    }
+    whenRenderingDone() {
+        return this.engine.whenRenderingDone();
+    }
+}
+
 /**
  * @module
  * @description
@@ -4517,5 +4812,5 @@ class WebAnimationsDriver {
  * Generated bundle index. Do not edit.
  */
 
-export { AnimationDriver, Animation as ɵAnimation, AnimationEngine as ɵAnimationEngine, AnimationStyleNormalizer as ɵAnimationStyleNormalizer, NoopAnimationDriver as ɵNoopAnimationDriver, NoopAnimationStyleNormalizer as ɵNoopAnimationStyleNormalizer, WebAnimationsDriver as ɵWebAnimationsDriver, WebAnimationsPlayer as ɵWebAnimationsPlayer, WebAnimationsStyleNormalizer as ɵWebAnimationsStyleNormalizer, allowPreviousPlayerStylesMerge as ɵallowPreviousPlayerStylesMerge, camelCaseToDashCase as ɵcamelCaseToDashCase, containsElement as ɵcontainsElement, getParentElement as ɵgetParentElement, invokeQuery as ɵinvokeQuery, normalizeKeyframes as ɵnormalizeKeyframes, validateStyleProperty as ɵvalidateStyleProperty, validateWebAnimatableStyleProperty as ɵvalidateWebAnimatableStyleProperty };
+export { AnimationDriver, NoopAnimationDriver, Animation as ɵAnimation, AnimationEngine as ɵAnimationEngine, AnimationRenderer as ɵAnimationRenderer, AnimationRendererFactory as ɵAnimationRendererFactory, AnimationStyleNormalizer as ɵAnimationStyleNormalizer, BaseAnimationRenderer as ɵBaseAnimationRenderer, NoopAnimationStyleNormalizer as ɵNoopAnimationStyleNormalizer, WebAnimationsDriver as ɵWebAnimationsDriver, WebAnimationsPlayer as ɵWebAnimationsPlayer, WebAnimationsStyleNormalizer as ɵWebAnimationsStyleNormalizer, allowPreviousPlayerStylesMerge as ɵallowPreviousPlayerStylesMerge, camelCaseToDashCase as ɵcamelCaseToDashCase, containsElement as ɵcontainsElement, createEngine as ɵcreateEngine, getParentElement as ɵgetParentElement, invokeQuery as ɵinvokeQuery, normalizeKeyframes as ɵnormalizeKeyframes, validateStyleProperty as ɵvalidateStyleProperty, validateWebAnimatableStyleProperty as ɵvalidateWebAnimatableStyleProperty };
 //# sourceMappingURL=browser.mjs.map