@nativescript/core 8.9.0-alpha.2 → 8.9.0-napi-es5.0

package/ui/core/properties/index.js

@@ -5,18 +5,19 @@ import { profile } from '../../../profiling';
 /**
  * Value specifying that Property should be set to its initial value.
  */
-export const unsetValue = new Object();
-const cssPropertyNames = [];
-const symbolPropertyMap = {};
-const cssSymbolPropertyMap = {};
-const inheritableProperties = new Array();
-const inheritableCssProperties = new Array();
+export var unsetValue = new Object();
+var cssPropertyNames = [];
+var symbolPropertyMap = {};
+var cssSymbolPropertyMap = {};
+var inheritableProperties = new Array();
+var inheritableCssProperties = new Array();
 function print(map) {
-    const symbols = Object.getOwnPropertySymbols(map);
-    for (const symbol of symbols) {
-        const prop = map[symbol];
+    var symbols = Object.getOwnPropertySymbols(map);
+    for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) {
+        var symbol = symbols_1[_i];
+        var prop = map[symbol];
         if (!prop.registered) {
-            console.log(`Property ${prop.name} not Registered!!!!!`);
+            console.log("Property ".concat(prop.name, " not Registered!!!!!"));
         }
     }
 }
@@ -47,33 +48,33 @@ export function _evaluateCssVariableExpression(view, cssName, value) {
         // Value is not using css-variable(s)
         return value;
     }
-    let output = value.trim();
+    var output = value.trim();
     // Evaluate every (and nested) css-variables in the value.
-    let lastValue;
+    var lastValue;
     while (lastValue !== output) {
         lastValue = output;
-        const idx = output.lastIndexOf('var(');
+        var idx = output.lastIndexOf('var(');
         if (idx === -1) {
             continue;
         }
-        const endIdx = output.indexOf(')', idx);
+        var endIdx = output.indexOf(')', idx);
         if (endIdx === -1) {
             continue;
         }
-        const matched = output
+        var matched = output
             .substring(idx + 4, endIdx)
             .split(',')
-            .map((v) => v.trim())
-            .filter((v) => !!v);
-        const cssVariableName = matched.shift();
-        let cssVariableValue = view.style.getCssVariable(cssVariableName);
+            .map(function (v) { return v.trim(); })
+            .filter(function (v) { return !!v; });
+        var cssVariableName = matched.shift();
+        var cssVariableValue = view.style.getCssVariable(cssVariableName);
         if (cssVariableValue === null && matched.length) {
             cssVariableValue = _evaluateCssVariableExpression(view, cssName, matched.join(', ')).split(',')[0];
         }
         if (!cssVariableValue) {
             cssVariableValue = 'unset';
         }
-        output = `${output.substring(0, idx)}${cssVariableValue}${output.substring(endIdx + 1)}`;
+        output = "".concat(output.substring(0, idx)).concat(cssVariableValue).concat(output.substring(endIdx + 1));
     }
     return output;
 }
@@ -90,31 +91,31 @@ export function _evaluateCssCalcExpression(value) {
     }
 }
 function getPropertiesFromMap(map) {
-    const props = [];
-    Object.getOwnPropertySymbols(map).forEach((symbol) => props.push(map[symbol]));
+    var props = [];
+    Object.getOwnPropertySymbols(map).forEach(function (symbol) { return props.push(map[symbol]); });
     return props;
 }
-export class Property {
-    constructor(options) {
+var Property = /** @class */ (function () {
+    function Property(options) {
         this.enumerable = true;
         this.configurable = true;
-        const propertyName = options.name;
+        var propertyName = options.name;
         this.name = propertyName;
-        const key = Symbol(propertyName + ':propertyKey');
+        var key = Symbol(propertyName + ':propertyKey');
         this.key = key;
-        const getDefault = Symbol(propertyName + ':getDefault');
+        var getDefault = Symbol(propertyName + ':getDefault');
         this.getDefault = getDefault;
-        const setNative = Symbol(propertyName + ':setNative');
+        var setNative = Symbol(propertyName + ':setNative');
         this.setNative = setNative;
-        const defaultValueKey = Symbol(propertyName + ':nativeDefaultValue');
+        var defaultValueKey = Symbol(propertyName + ':nativeDefaultValue');
         this.defaultValueKey = defaultValueKey;
-        const defaultValue = options.defaultValue;
+        var defaultValue = options.defaultValue;
         this.defaultValue = defaultValue;
-        const eventName = propertyName + 'Change';
-        let equalityComparer = options.equalityComparer;
-        let affectsLayout = options.affectsLayout;
-        let valueChanged = options.valueChanged;
-        let valueConverter = options.valueConverter;
+        var eventName = propertyName + 'Change';
+        var equalityComparer = options.equalityComparer;
+        var affectsLayout = options.affectsLayout;
+        var valueChanged = options.valueChanged;
+        var valueConverter = options.valueConverter;
         this.overrideHandlers = function (options) {
             if (typeof options.equalityComparer !== 'undefined') {
                 equalityComparer = options.equalityComparer;
@@ -129,11 +130,11 @@ export class Property {
                 valueConverter = options.valueConverter;
             }
         };
-        const property = this;
+        var property = this;
         this.set = function (boxedValue) {
-            const reset = boxedValue === unsetValue;
-            let value;
-            let wrapped;
+            var reset = boxedValue === unsetValue;
+            var value;
+            var wrapped;
             if (reset) {
                 value = defaultValue;
             }
@@ -144,8 +145,8 @@ export class Property {
                     value = valueConverter(value);
                 }
             }
-            const oldValue = (key in this ? this[key] : defaultValue);
-            const changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
+            var oldValue = (key in this ? this[key] : defaultValue);
+            var changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
             if (wrapped || changed) {
                 if (affectsLayout) {
                     this.requestLayout();
@@ -194,10 +195,10 @@ export class Property {
                 if (this.hasListeners(eventName)) {
                     this.notify({
                         object: this,
-                        eventName,
-                        propertyName,
-                        value,
-                        oldValue,
+                        eventName: eventName,
+                        propertyName: propertyName,
+                        value: value,
+                        oldValue: oldValue,
                     });
                 }
                 if (this.domNode) {
@@ -214,8 +215,8 @@ export class Property {
             return (key in this ? this[key] : defaultValue);
         };
         this.nativeValueChange = function (owner, value) {
-            const oldValue = (key in owner ? owner[key] : defaultValue);
-            const changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
+            var oldValue = (key in owner ? owner[key] : defaultValue);
+            var changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
             if (changed) {
                 owner[key] = value;
                 if (valueChanged) {
@@ -227,10 +228,10 @@ export class Property {
                 if (owner.hasListeners(eventName)) {
                     owner.notify({
                         object: owner,
-                        eventName,
-                        propertyName,
-                        value,
-                        oldValue,
+                        eventName: eventName,
+                        propertyName: propertyName,
+                        value: value,
+                        oldValue: oldValue,
                     });
                 }
                 if (affectsLayout) {
@@ -243,36 +244,39 @@ export class Property {
         };
         symbolPropertyMap[key] = this;
     }
-    register(cls) {
+    Property.prototype.register = function (cls) {
         if (this.registered) {
-            throw new Error(`Property ${this.name} already registered.`);
+            throw new Error("Property ".concat(this.name, " already registered."));
         }
         this.registered = true;
         Object.defineProperty(cls.prototype, this.name, this);
-    }
-    isSet(instance) {
+    };
+    Property.prototype.isSet = function (instance) {
         return this.key in instance;
-    }
-}
+    };
+    return Property;
+}());
+export { Property };
 Property.prototype.isStyleProperty = false;
-export class CoercibleProperty extends Property {
-    constructor(options) {
-        super(options);
-        const propertyName = options.name;
-        const key = this.key;
-        const getDefault = this.getDefault;
-        const setNative = this.setNative;
-        const defaultValueKey = this.defaultValueKey;
-        const defaultValue = this.defaultValue;
-        const coerceKey = Symbol(propertyName + ':coerceKey');
-        const eventName = propertyName + 'Change';
-        let affectsLayout = options.affectsLayout;
-        let equalityComparer = options.equalityComparer;
-        let valueChanged = options.valueChanged;
-        let valueConverter = options.valueConverter;
-        let coerceCallback = options.coerceValue;
-        const property = this;
-        this.overrideHandlers = function (options) {
+var CoercibleProperty = /** @class */ (function (_super) {
+    __extends(CoercibleProperty, _super);
+    function CoercibleProperty(options) {
+        var _this = _super.call(this, options) || this;
+        var propertyName = options.name;
+        var key = _this.key;
+        var getDefault = _this.getDefault;
+        var setNative = _this.setNative;
+        var defaultValueKey = _this.defaultValueKey;
+        var defaultValue = _this.defaultValue;
+        var coerceKey = Symbol(propertyName + ':coerceKey');
+        var eventName = propertyName + 'Change';
+        var affectsLayout = options.affectsLayout;
+        var equalityComparer = options.equalityComparer;
+        var valueChanged = options.valueChanged;
+        var valueConverter = options.valueConverter;
+        var coerceCallback = options.coerceValue;
+        var property = _this;
+        _this.overrideHandlers = function (options) {
             if (typeof options.equalityComparer !== 'undefined') {
                 equalityComparer = options.equalityComparer;
             }
@@ -289,15 +293,15 @@ export class CoercibleProperty extends Property {
                 coerceCallback = options.coerceValue;
             }
         };
-        this.coerce = function (target) {
-            const originalValue = (coerceKey in target ? target[coerceKey] : defaultValue);
+        _this.coerce = function (target) {
+            var originalValue = (coerceKey in target ? target[coerceKey] : defaultValue);
             // need that to make coercing but also fire change events
             target[propertyName] = originalValue;
         };
-        this.set = function (boxedValue) {
-            const reset = boxedValue === unsetValue;
-            let value;
-            let wrapped;
+        _this.set = function (boxedValue) {
+            var reset = boxedValue === unsetValue;
+            var value;
+            var wrapped;
             if (reset) {
                 value = defaultValue;
                 delete this[coerceKey];
@@ -311,8 +315,8 @@ export class CoercibleProperty extends Property {
                 this[coerceKey] = value;
                 value = coerceCallback(this, value);
             }
-            const oldValue = key in this ? this[key] : defaultValue;
-            const changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
+            var oldValue = key in this ? this[key] : defaultValue;
+            var changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
             if (wrapped || changed) {
                 if (reset) {
                     delete this[key];
@@ -358,10 +362,10 @@ export class CoercibleProperty extends Property {
                 if (this.hasListeners(eventName)) {
                     this.notify({
                         object: this,
-                        eventName,
-                        propertyName,
-                        value,
-                        oldValue,
+                        eventName: eventName,
+                        propertyName: propertyName,
+                        value: value,
+                        oldValue: oldValue,
                     });
                 }
                 if (affectsLayout) {
@@ -377,92 +381,101 @@ export class CoercibleProperty extends Property {
                 }
             }
         };
+        return _this;
     }
-}
-export class InheritedProperty extends Property {
-    constructor(options) {
-        super(options);
-        const name = options.name;
-        const key = this.key;
-        const defaultValue = options.defaultValue;
-        const sourceKey = Symbol(name + ':valueSourceKey');
-        this.sourceKey = sourceKey;
-        const setBase = this.set;
-        const setFunc = (valueSource) => function (value) {
-            const that = this;
-            let unboxedValue;
-            let newValueSource;
-            if (value === unsetValue) {
-                // If unsetValue - we want to reset the property.
-                const parent = that.parent;
-                // If we have parent and it has non-default value we use as our inherited value.
-                if (parent && parent[sourceKey] !== 0 /* ValueSource.Default */) {
-                    unboxedValue = parent[name];
-                    newValueSource = 1 /* ValueSource.Inherited */;
+    return CoercibleProperty;
+}(Property));
+export { CoercibleProperty };
+var InheritedProperty = /** @class */ (function (_super) {
+    __extends(InheritedProperty, _super);
+    function InheritedProperty(options) {
+        var _this = _super.call(this, options) || this;
+        var name = options.name;
+        var key = _this.key;
+        var defaultValue = options.defaultValue;
+        var sourceKey = Symbol(name + ':valueSourceKey');
+        _this.sourceKey = sourceKey;
+        var setBase = _this.set;
+        var setFunc = function (valueSource) {
+            return function (value) {
+                var that = this;
+                var unboxedValue;
+                var newValueSource;
+                if (value === unsetValue) {
+                    // If unsetValue - we want to reset the property.
+                    var parent_1 = that.parent;
+                    // If we have parent and it has non-default value we use as our inherited value.
+                    if (parent_1 && parent_1[sourceKey] !== 0 /* ValueSource.Default */) {
+                        unboxedValue = parent_1[name];
+                        newValueSource = 1 /* ValueSource.Inherited */;
+                    }
+                    else {
+                        unboxedValue = defaultValue;
+                        newValueSource = 0 /* ValueSource.Default */;
+                    }
                 }
                 else {
-                    unboxedValue = defaultValue;
-                    newValueSource = 0 /* ValueSource.Default */;
+                    // else we are set through property set.
+                    unboxedValue = value;
+                    newValueSource = valueSource;
                 }
-            }
-            else {
-                // else we are set through property set.
-                unboxedValue = value;
-                newValueSource = valueSource;
-            }
-            // take currentValue before calling base - base may change it.
-            const currentValue = that[key];
-            setBase.call(that, unboxedValue);
-            const newValue = that[key];
-            that[sourceKey] = newValueSource;
-            if (currentValue !== newValue) {
-                const reset = newValueSource === 0 /* ValueSource.Default */;
-                that.eachChild((child) => {
-                    const childValueSource = child[sourceKey] || 0 /* ValueSource.Default */;
-                    if (reset) {
-                        if (childValueSource === 1 /* ValueSource.Inherited */) {
-                            setFunc.call(child, unsetValue);
+                // take currentValue before calling base - base may change it.
+                var currentValue = that[key];
+                setBase.call(that, unboxedValue);
+                var newValue = that[key];
+                that[sourceKey] = newValueSource;
+                if (currentValue !== newValue) {
+                    var reset_1 = newValueSource === 0 /* ValueSource.Default */;
+                    that.eachChild(function (child) {
+                        var childValueSource = child[sourceKey] || 0 /* ValueSource.Default */;
+                        if (reset_1) {
+                            if (childValueSource === 1 /* ValueSource.Inherited */) {
+                                setFunc.call(child, unsetValue);
+                            }
                         }
-                    }
-                    else {
-                        if (childValueSource <= 1 /* ValueSource.Inherited */) {
-                            setInheritedValue.call(child, newValue);
+                        else {
+                            if (childValueSource <= 1 /* ValueSource.Inherited */) {
+                                setInheritedValue.call(child, newValue);
+                            }
                         }
-                    }
-                    return true;
-                });
-            }
+                        return true;
+                    });
+                }
+            };
         };
-        const setInheritedValue = setFunc(1 /* ValueSource.Inherited */);
-        this.setInheritedValue = setInheritedValue;
-        this.set = setFunc(3 /* ValueSource.Local */);
-        inheritableProperties.push(this);
+        var setInheritedValue = setFunc(1 /* ValueSource.Inherited */);
+        _this.setInheritedValue = setInheritedValue;
+        _this.set = setFunc(3 /* ValueSource.Local */);
+        inheritableProperties.push(_this);
+        return _this;
     }
-}
-export class CssProperty {
-    constructor(options) {
-        const propertyName = options.name;
+    return InheritedProperty;
+}(Property));
+export { InheritedProperty };
+var CssProperty = /** @class */ (function () {
+    function CssProperty(options) {
+        var propertyName = options.name;
         this.name = propertyName;
         cssPropertyNames.push(options.cssName);
-        this.cssName = `css:${options.cssName}`;
+        this.cssName = "css:".concat(options.cssName);
         this.cssLocalName = options.cssName;
-        const key = Symbol(propertyName + ':propertyKey');
+        var key = Symbol(propertyName + ':propertyKey');
         this.key = key;
-        const sourceKey = Symbol(propertyName + ':valueSourceKey');
+        var sourceKey = Symbol(propertyName + ':valueSourceKey');
         this.sourceKey = sourceKey;
-        const getDefault = Symbol(propertyName + ':getDefault');
+        var getDefault = Symbol(propertyName + ':getDefault');
         this.getDefault = getDefault;
-        const setNative = Symbol(propertyName + ':setNative');
+        var setNative = Symbol(propertyName + ':setNative');
         this.setNative = setNative;
-        const defaultValueKey = Symbol(propertyName + ':nativeDefaultValue');
+        var defaultValueKey = Symbol(propertyName + ':nativeDefaultValue');
         this.defaultValueKey = defaultValueKey;
-        const defaultValue = options.defaultValue;
+        var defaultValue = options.defaultValue;
         this.defaultValue = defaultValue;
-        const eventName = propertyName + 'Change';
-        let affectsLayout = options.affectsLayout;
-        let equalityComparer = options.equalityComparer;
-        let valueChanged = options.valueChanged;
-        let valueConverter = options.valueConverter;
+        var eventName = propertyName + 'Change';
+        var affectsLayout = options.affectsLayout;
+        var equalityComparer = options.equalityComparer;
+        var valueChanged = options.valueChanged;
+        var valueConverter = options.valueConverter;
         this.overrideHandlers = function (options) {
             if (typeof options.equalityComparer !== 'undefined') {
                 equalityComparer = options.equalityComparer;
@@ -477,15 +490,15 @@ export class CssProperty {
                 valueConverter = options.valueConverter;
             }
         };
-        const property = this;
+        var property = this;
         function setLocalValue(newValue) {
-            const view = this.viewRef.get();
+            var view = this.viewRef.get();
             if (!view) {
-                Trace.write(`${newValue} not set to view because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+                Trace.write("".concat(newValue, " not set to view because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
                 return;
             }
-            const reset = newValue === unsetValue || newValue === '';
-            let value;
+            var reset = newValue === unsetValue || newValue === '';
+            var value;
             if (reset) {
                 value = defaultValue;
                 delete this[sourceKey];
@@ -494,8 +507,8 @@ export class CssProperty {
                 this[sourceKey] = 3 /* ValueSource.Local */;
                 value = valueConverter && typeof newValue === 'string' ? valueConverter(newValue) : newValue;
             }
-            const oldValue = (key in this ? this[key] : defaultValue);
-            const changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
+            var oldValue = (key in this ? this[key] : defaultValue);
+            var changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
             if (changed) {
                 if (reset) {
                     delete this[key];
@@ -541,10 +554,10 @@ export class CssProperty {
                 if (this.hasListeners(eventName)) {
                     this.notify({
                         object: this,
-                        eventName,
-                        propertyName,
-                        value,
-                        oldValue,
+                        eventName: eventName,
+                        propertyName: propertyName,
+                        value: value,
+                        oldValue: oldValue,
                     });
                 }
                 if (affectsLayout) {
@@ -553,18 +566,18 @@ export class CssProperty {
             }
         }
         function setCssValue(newValue) {
-            const view = this.viewRef.get();
+            var view = this.viewRef.get();
             if (!view) {
-                Trace.write(`${newValue} not set to view because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
+                Trace.write("".concat(newValue, " not set to view because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
                 return;
             }
-            const currentValueSource = this[sourceKey] || 0 /* ValueSource.Default */;
+            var currentValueSource = this[sourceKey] || 0 /* ValueSource.Default */;
             // We have localValueSource - NOOP.
             if (currentValueSource === 3 /* ValueSource.Local */) {
                 return;
             }
-            const reset = newValue === unsetValue || newValue === '';
-            let value;
+            var reset = newValue === unsetValue || newValue === '';
+            var value;
             if (reset) {
                 value = defaultValue;
                 delete this[sourceKey];
@@ -573,8 +586,8 @@ export class CssProperty {
                 value = valueConverter && typeof newValue === 'string' ? valueConverter(newValue) : newValue;
                 this[sourceKey] = 2 /* ValueSource.Css */;
             }
-            const oldValue = (key in this ? this[key] : defaultValue);
-            const changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
+            var oldValue = (key in this ? this[key] : defaultValue);
+            var changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
             if (changed) {
                 if (reset) {
                     delete this[key];
@@ -620,10 +633,10 @@ export class CssProperty {
                 if (this.hasListeners(eventName)) {
                     this.notify({
                         object: this,
-                        eventName,
-                        propertyName,
-                        value,
-                        oldValue,
+                        eventName: eventName,
+                        propertyName: propertyName,
+                        value: value,
+                        oldValue: oldValue,
                     });
                 }
                 if (affectsLayout) {
@@ -648,9 +661,9 @@ export class CssProperty {
         };
         cssSymbolPropertyMap[key] = this;
     }
-    register(cls) {
+    CssProperty.prototype.register = function (cls) {
         if (this.registered) {
-            throw new Error(`Property ${this.name} already registered.`);
+            throw new Error("Property ".concat(this.name, " already registered."));
         }
         this.registered = true;
         Object.defineProperty(cls.prototype, this.name, this.localValueDescriptor);
@@ -658,15 +671,17 @@ export class CssProperty {
         if (this.cssLocalName !== this.cssName) {
             Object.defineProperty(cls.prototype, this.cssLocalName, this.localValueDescriptor);
         }
-    }
-    isSet(instance) {
+    };
+    CssProperty.prototype.isSet = function (instance) {
         return this.key in instance;
-    }
-}
+    };
+    return CssProperty;
+}());
+export { CssProperty };
 CssProperty.prototype.isStyleProperty = true;
-export class CssAnimationProperty {
-    constructor(options) {
-        const propertyName = options.name;
+var CssAnimationProperty = /** @class */ (function () {
+    function CssAnimationProperty(options) {
+        var propertyName = options.name;
         this.name = propertyName;
         cssPropertyNames.push(options.cssName);
         CssAnimationProperty.properties[propertyName] = this;
@@ -674,32 +689,32 @@ export class CssAnimationProperty {
             CssAnimationProperty.properties[options.cssName] = this;
         }
         this._valueConverter = options.valueConverter;
-        const cssLocalName = options.cssName || propertyName;
+        var cssLocalName = options.cssName || propertyName;
         this.cssLocalName = cssLocalName;
-        const cssName = 'css:' + cssLocalName;
+        var cssName = 'css:' + cssLocalName;
         this.cssName = cssName;
-        const keyframeName = 'keyframe:' + propertyName;
+        var keyframeName = 'keyframe:' + propertyName;
         this.keyframe = keyframeName;
-        const defaultName = 'default:' + propertyName;
-        const defaultValueKey = Symbol(defaultName);
+        var defaultName = 'default:' + propertyName;
+        var defaultValueKey = Symbol(defaultName);
         this.defaultValueKey = defaultValueKey;
         this.defaultValue = options.defaultValue;
-        const cssValue = Symbol(cssName);
-        const styleValue = Symbol(`local:${propertyName}`);
-        const keyframeValue = Symbol(keyframeName);
-        const computedValue = Symbol('computed-value:' + propertyName);
+        var cssValue = Symbol(cssName);
+        var styleValue = Symbol("local:".concat(propertyName));
+        var keyframeValue = Symbol(keyframeName);
+        var computedValue = Symbol('computed-value:' + propertyName);
         this.key = computedValue;
-        const computedSource = Symbol('computed-source:' + propertyName);
+        var computedSource = Symbol('computed-source:' + propertyName);
         this.source = computedSource;
         this.getDefault = Symbol(propertyName + ':getDefault');
-        const getDefault = this.getDefault;
-        const setNative = (this.setNative = Symbol(propertyName + ':setNative'));
-        const eventName = propertyName + 'Change';
-        const property = this;
+        var getDefault = this.getDefault;
+        var setNative = (this.setNative = Symbol(propertyName + ':setNative'));
+        var eventName = propertyName + 'Change';
+        var property = this;
         function descriptor(symbol, propertySource, enumerable, configurable, getsComputed) {
             return {
-                enumerable,
-                configurable,
+                enumerable: enumerable,
+                configurable: configurable,
                 get: getsComputed
                     ? function () {
                         return this[computedValue];
@@ -707,16 +722,16 @@ export class CssAnimationProperty {
                     : function () {
                         return this[symbol];
                     },
-                set(boxedValue) {
-                    const view = this.viewRef.get();
+                set: function (boxedValue) {
+                    var view = this.viewRef.get();
                     if (!view) {
-                        Trace.write(`${boxedValue} not set to view because ".viewRef" is cleared`, Trace.categories.Animation, Trace.messageType.warn);
+                        Trace.write("".concat(boxedValue, " not set to view because \".viewRef\" is cleared"), Trace.categories.Animation, Trace.messageType.warn);
                         return;
                     }
-                    const oldValue = this[computedValue];
-                    const oldSource = this[computedSource];
-                    const wasSet = oldSource !== 0 /* ValueSource.Default */;
-                    const reset = boxedValue === unsetValue || boxedValue === '';
+                    var oldValue = this[computedValue];
+                    var oldSource = this[computedSource];
+                    var wasSet = oldSource !== 0 /* ValueSource.Default */;
+                    var reset = boxedValue === unsetValue || boxedValue === '';
                     if (reset) {
                         this[symbol] = unsetValue;
                         if (this[computedSource] === propertySource) {
@@ -745,10 +760,10 @@ export class CssAnimationProperty {
                             this[computedValue] = boxedValue;
                         }
                     }
-                    const value = this[computedValue];
-                    const source = this[computedSource];
-                    const isSet = source !== 0 /* ValueSource.Default */;
-                    const computedValueChanged = oldValue !== value && (!options.equalityComparer || !options.equalityComparer(oldValue, value));
+                    var value = this[computedValue];
+                    var source = this[computedSource];
+                    var isSet = source !== 0 /* ValueSource.Default */;
+                    var computedValueChanged = oldValue !== value && (!options.equalityComparer || !options.equalityComparer(oldValue, value));
                     if (computedValueChanged && options.valueChanged) {
                         options.valueChanged(this, oldValue, value);
                     }
@@ -778,22 +793,22 @@ export class CssAnimationProperty {
                     if (computedValueChanged && this.hasListeners(eventName)) {
                         this.notify({
                             object: this,
-                            eventName,
-                            propertyName,
-                            value,
-                            oldValue,
+                            eventName: eventName,
+                            propertyName: propertyName,
+                            value: value,
+                            oldValue: oldValue,
                         });
                     }
                 },
             };
         }
-        const defaultPropertyDescriptor = descriptor(defaultValueKey, 0 /* ValueSource.Default */, false, false, false);
-        const cssPropertyDescriptor = descriptor(cssValue, 2 /* ValueSource.Css */, false, false, false);
-        const stylePropertyDescriptor = descriptor(styleValue, 3 /* ValueSource.Local */, true, true, true);
-        const keyframePropertyDescriptor = descriptor(keyframeValue, 4 /* ValueSource.Keyframe */, false, false, false);
+        var defaultPropertyDescriptor = descriptor(defaultValueKey, 0 /* ValueSource.Default */, false, false, false);
+        var cssPropertyDescriptor = descriptor(cssValue, 2 /* ValueSource.Css */, false, false, false);
+        var stylePropertyDescriptor = descriptor(styleValue, 3 /* ValueSource.Local */, true, true, true);
+        var keyframePropertyDescriptor = descriptor(keyframeValue, 4 /* ValueSource.Keyframe */, false, false, false);
         symbolPropertyMap[computedValue] = this;
         cssSymbolPropertyMap[computedValue] = this;
-        this.register = (cls) => {
+        this.register = function (cls) {
             cls.prototype[computedValue] = options.defaultValue;
             cls.prototype[computedSource] = 0 /* ValueSource.Default */;
             cls.prototype[cssValue] = unsetValue;
@@ -808,47 +823,50 @@ export class CssAnimationProperty {
             Object.defineProperty(cls.prototype, keyframeName, keyframePropertyDescriptor);
         };
     }
-    _initDefaultNativeValue(target) {
-        const view = target.viewRef.get();
+    CssAnimationProperty.prototype._initDefaultNativeValue = function (target) {
+        var view = target.viewRef.get();
         if (!view) {
-            Trace.write(`_initDefaultNativeValue not executed to view because ".viewRef" is cleared`, Trace.categories.Animation, Trace.messageType.warn);
+            Trace.write("_initDefaultNativeValue not executed to view because \".viewRef\" is cleared", Trace.categories.Animation, Trace.messageType.warn);
             return;
         }
-        const defaultValueKey = this.defaultValueKey;
+        var defaultValueKey = this.defaultValueKey;
         if (!(defaultValueKey in target)) {
-            const getDefault = this.getDefault;
+            var getDefault = this.getDefault;
             target[defaultValueKey] = view[getDefault] ? view[getDefault]() : this.defaultValue;
         }
-    }
-    static _getByCssName(name) {
+    };
+    CssAnimationProperty._getByCssName = function (name) {
         return this.properties[name];
-    }
-    static _getPropertyNames() {
+    };
+    CssAnimationProperty._getPropertyNames = function () {
         return Object.keys(CssAnimationProperty.properties);
-    }
-    isSet(instance) {
+    };
+    CssAnimationProperty.prototype.isSet = function (instance) {
         return instance[this.source] !== 0 /* ValueSource.Default */;
-    }
-}
-CssAnimationProperty.properties = {};
+    };
+    CssAnimationProperty.properties = {};
+    return CssAnimationProperty;
+}());
+export { CssAnimationProperty };
 CssAnimationProperty.prototype.isStyleProperty = true;
-export class InheritedCssProperty extends CssProperty {
-    constructor(options) {
-        super(options);
-        const propertyName = options.name;
-        const key = this.key;
-        const sourceKey = this.sourceKey;
-        const getDefault = this.getDefault;
-        const setNative = this.setNative;
-        const defaultValueKey = this.defaultValueKey;
-        const eventName = propertyName + 'Change';
-        let defaultValue = options.defaultValue;
-        let affectsLayout = options.affectsLayout;
-        let equalityComparer = options.equalityComparer;
-        let valueChanged = options.valueChanged;
-        let valueConverter = options.valueConverter;
-        const property = this;
-        this.overrideHandlers = function (options) {
+var InheritedCssProperty = /** @class */ (function (_super) {
+    __extends(InheritedCssProperty, _super);
+    function InheritedCssProperty(options) {
+        var _this = _super.call(this, options) || this;
+        var propertyName = options.name;
+        var key = _this.key;
+        var sourceKey = _this.sourceKey;
+        var getDefault = _this.getDefault;
+        var setNative = _this.setNative;
+        var defaultValueKey = _this.defaultValueKey;
+        var eventName = propertyName + 'Change';
+        var defaultValue = options.defaultValue;
+        var affectsLayout = options.affectsLayout;
+        var equalityComparer = options.equalityComparer;
+        var valueChanged = options.valueChanged;
+        var valueConverter = options.valueConverter;
+        var property = _this;
+        _this.overrideHandlers = function (options) {
             if (typeof options.equalityComparer !== 'undefined') {
                 equalityComparer = options.equalityComparer;
             }
@@ -862,150 +880,159 @@ export class InheritedCssProperty extends CssProperty {
                 valueConverter = options.valueConverter;
             }
         };
-        const setFunc = (valueSource) => function (boxedValue) {
-            const view = this.viewRef.get();
-            if (!view) {
-                Trace.write(`${boxedValue} not set to view's property because ".viewRef" is cleared`, Trace.categories.Style, Trace.messageType.warn);
-                return;
-            }
-            const reset = boxedValue === unsetValue || boxedValue === '';
-            const currentValueSource = this[sourceKey] || 0 /* ValueSource.Default */;
-            if (reset) {
-                // If we want to reset cssValue and we have localValue - return;
-                if (valueSource === 2 /* ValueSource.Css */ && currentValueSource === 3 /* ValueSource.Local */) {
-                    return;
-                }
-            }
-            else {
-                if (currentValueSource > valueSource) {
+        var setFunc = function (valueSource) {
+            return function (boxedValue) {
+                var view = this.viewRef.get();
+                if (!view) {
+                    Trace.write("".concat(boxedValue, " not set to view's property because \".viewRef\" is cleared"), Trace.categories.Style, Trace.messageType.warn);
                     return;
                 }
-            }
-            const oldValue = key in this ? this[key] : defaultValue;
-            let value;
-            let unsetNativeValue = false;
-            if (reset) {
-                // If unsetValue - we want to reset this property.
-                const parent = view.parent;
-                const style = parent ? parent.style : null;
-                // If we have parent and it has non-default value we use as our inherited value.
-                if (style && style[sourceKey] > 0 /* ValueSource.Default */) {
-                    value = style[propertyName];
-                    this[sourceKey] = 1 /* ValueSource.Inherited */;
-                    this[key] = value;
+                var reset = boxedValue === unsetValue || boxedValue === '';
+                var currentValueSource = this[sourceKey] || 0 /* ValueSource.Default */;
+                if (reset) {
+                    // If we want to reset cssValue and we have localValue - return;
+                    if (valueSource === 2 /* ValueSource.Css */ && currentValueSource === 3 /* ValueSource.Local */) {
+                        return;
+                    }
                 }
                 else {
-                    value = defaultValue;
-                    delete this[sourceKey];
-                    delete this[key];
-                    unsetNativeValue = true;
+                    if (currentValueSource > valueSource) {
+                        return;
+                    }
                 }
-            }
-            else {
-                this[sourceKey] = valueSource;
-                if (valueConverter && typeof boxedValue === 'string') {
-                    value = valueConverter(boxedValue);
+                var oldValue = key in this ? this[key] : defaultValue;
+                var value;
+                var unsetNativeValue = false;
+                if (reset) {
+                    // If unsetValue - we want to reset this property.
+                    var parent_2 = view.parent;
+                    var style = parent_2 ? parent_2.style : null;
+                    // If we have parent and it has non-default value we use as our inherited value.
+                    if (style && style[sourceKey] > 0 /* ValueSource.Default */) {
+                        value = style[propertyName];
+                        this[sourceKey] = 1 /* ValueSource.Inherited */;
+                        this[key] = value;
+                    }
+                    else {
+                        value = defaultValue;
+                        delete this[sourceKey];
+                        delete this[key];
+                        unsetNativeValue = true;
+                    }
                 }
                 else {
-                    value = boxedValue;
-                }
-                this[key] = value;
-            }
-            const changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
-            if (changed) {
-                if (valueChanged) {
-                    valueChanged(this, oldValue, value);
-                }
-                if (view[setNative]) {
-                    if (view._suspendNativeUpdatesCount) {
-                        if (view._suspendedUpdates) {
-                            view._suspendedUpdates[propertyName] = property;
-                        }
+                    this[sourceKey] = valueSource;
+                    if (valueConverter && typeof boxedValue === 'string') {
+                        value = valueConverter(boxedValue);
                     }
                     else {
-                        if (unsetNativeValue) {
-                            if (defaultValueKey in this) {
-                                view[setNative](this[defaultValueKey]);
-                                delete this[defaultValueKey];
+                        value = boxedValue;
+                    }
+                    this[key] = value;
+                }
+                var changed = equalityComparer ? !equalityComparer(oldValue, value) : oldValue !== value;
+                if (changed) {
+                    if (valueChanged) {
+                        valueChanged(this, oldValue, value);
+                    }
+                    if (view[setNative]) {
+                        if (view._suspendNativeUpdatesCount) {
+                            if (view._suspendedUpdates) {
+                                view._suspendedUpdates[propertyName] = property;
+                            }
+                        }
+                        else {
+                            if (unsetNativeValue) {
+                                if (defaultValueKey in this) {
+                                    view[setNative](this[defaultValueKey]);
+                                    delete this[defaultValueKey];
+                                }
+                                else {
+                                    view[setNative](defaultValue);
+                                }
                             }
                             else {
-                                view[setNative](defaultValue);
+                                if (!(defaultValueKey in this)) {
+                                    this[defaultValueKey] = view[getDefault] ? view[getDefault]() : defaultValue;
+                                }
+                                view[setNative](value);
+                            }
+                        }
+                    }
+                    if (this.hasListeners(eventName)) {
+                        this.notify({
+                            object: this,
+                            eventName: eventName,
+                            propertyName: propertyName,
+                            value: value,
+                            oldValue: oldValue,
+                        });
+                    }
+                    if (affectsLayout) {
+                        view.requestLayout();
+                    }
+                    view.eachChild(function (child) {
+                        var childStyle = child.style;
+                        var childValueSource = childStyle[sourceKey] || 0 /* ValueSource.Default */;
+                        if (reset) {
+                            if (childValueSource === 1 /* ValueSource.Inherited */) {
+                                setDefaultFunc.call(childStyle, unsetValue);
                             }
                         }
                         else {
-                            if (!(defaultValueKey in this)) {
-                                this[defaultValueKey] = view[getDefault] ? view[getDefault]() : defaultValue;
+                            if (childValueSource <= 1 /* ValueSource.Inherited */) {
+                                setInheritedFunc.call(childStyle, value);
                             }
-                            view[setNative](value);
                         }
-                    }
-                }
-                if (this.hasListeners(eventName)) {
-                    this.notify({
-                        object: this,
-                        eventName,
-                        propertyName,
-                        value,
-                        oldValue,
+                        return true;
                     });
                 }
-                if (affectsLayout) {
-                    view.requestLayout();
-                }
-                view.eachChild((child) => {
-                    const childStyle = child.style;
-                    const childValueSource = childStyle[sourceKey] || 0 /* ValueSource.Default */;
-                    if (reset) {
-                        if (childValueSource === 1 /* ValueSource.Inherited */) {
-                            setDefaultFunc.call(childStyle, unsetValue);
-                        }
-                    }
-                    else {
-                        if (childValueSource <= 1 /* ValueSource.Inherited */) {
-                            setInheritedFunc.call(childStyle, value);
-                        }
-                    }
-                    return true;
-                });
-            }
+            };
         };
-        const setDefaultFunc = setFunc(0 /* ValueSource.Default */);
-        const setInheritedFunc = setFunc(1 /* ValueSource.Inherited */);
-        this.setInheritedValue = setInheritedFunc;
-        this.cssValueDescriptor.set = setFunc(2 /* ValueSource.Css */);
-        this.localValueDescriptor.set = setFunc(3 /* ValueSource.Local */);
-        inheritableCssProperties.push(this);
+        var setDefaultFunc = setFunc(0 /* ValueSource.Default */);
+        var setInheritedFunc = setFunc(1 /* ValueSource.Inherited */);
+        _this.setInheritedValue = setInheritedFunc;
+        _this.cssValueDescriptor.set = setFunc(2 /* ValueSource.Css */);
+        _this.localValueDescriptor.set = setFunc(3 /* ValueSource.Local */);
+        inheritableCssProperties.push(_this);
+        return _this;
     }
-}
-export class ShorthandProperty {
-    constructor(options) {
+    return InheritedCssProperty;
+}(CssProperty));
+export { InheritedCssProperty };
+var ShorthandProperty = /** @class */ (function () {
+    function ShorthandProperty(options) {
         this.name = options.name;
-        const key = Symbol(this.name + ':propertyKey');
+        var key = Symbol(this.name + ':propertyKey');
         this.key = key;
-        this.cssName = `css:${options.cssName}`;
-        this.cssLocalName = `${options.cssName}`;
-        const converter = options.converter;
+        this.cssName = "css:".concat(options.cssName);
+        this.cssLocalName = "".concat(options.cssName);
+        var converter = options.converter;
         function setLocalValue(value) {
-            const view = this.viewRef.get();
+            var _this = this;
+            var view = this.viewRef.get();
             if (!view) {
-                Trace.write(`setLocalValue not executed to view because ".viewRef" is cleared`, Trace.categories.Animation, Trace.messageType.warn);
+                Trace.write("setLocalValue not executed to view because \".viewRef\" is cleared", Trace.categories.Animation, Trace.messageType.warn);
                 return;
             }
-            view._batchUpdate(() => {
-                for (const [p, v] of converter(value)) {
-                    this[p.name] = v;
+            view._batchUpdate(function () {
+                for (var _i = 0, _a = converter(value); _i < _a.length; _i++) {
+                    var _b = _a[_i], p = _b[0], v = _b[1];
+                    _this[p.name] = v;
                 }
             });
         }
         function setCssValue(value) {
-            const view = this.viewRef.get();
+            var _this = this;
+            var view = this.viewRef.get();
             if (!view) {
-                Trace.write(`setCssValue not executed to view because ".viewRef" is cleared`, Trace.categories.Animation, Trace.messageType.warn);
+                Trace.write("setCssValue not executed to view because \".viewRef\" is cleared", Trace.categories.Animation, Trace.messageType.warn);
                 return;
             }
-            view._batchUpdate(() => {
-                for (const [p, v] of converter(value)) {
-                    this[p.cssName] = v;
+            view._batchUpdate(function () {
+                for (var _i = 0, _a = converter(value); _i < _a.length; _i++) {
+                    var _b = _a[_i], p = _b[0], v = _b[1];
+                    _this[p.cssName] = v;
                 }
             });
         }
@@ -1024,17 +1051,19 @@ export class ShorthandProperty {
         this.propertyBagDescriptor = {
             enumerable: false,
             configurable: true,
-            set(value) {
-                converter(value).forEach(([property, value]) => {
-                    this[property.cssLocalName] = value;
+            set: function (value) {
+                var _this = this;
+                converter(value).forEach(function (_a) {
+                    var property = _a[0], value = _a[1];
+                    _this[property.cssLocalName] = value;
                 });
             },
         };
         cssSymbolPropertyMap[key] = this;
     }
-    register(cls) {
+    ShorthandProperty.prototype.register = function (cls) {
         if (this.registered) {
-            throw new Error(`Property ${this.name} already registered.`);
+            throw new Error("Property ".concat(this.name, " already registered."));
         }
         this.registered = true;
         Object.defineProperty(cls.prototype, this.name, this.localValueDescriptor);
@@ -1043,13 +1072,16 @@ export class ShorthandProperty {
             Object.defineProperty(cls.prototype, this.cssLocalName, this.localValueDescriptor);
         }
         Object.defineProperty(cls.prototype.PropertyBag, this.cssLocalName, this.propertyBagDescriptor);
-    }
-}
+    };
+    return ShorthandProperty;
+}());
+export { ShorthandProperty };
 function inheritablePropertyValuesOn(view) {
-    const array = new Array();
-    for (const prop of inheritableProperties) {
-        const sourceKey = prop.sourceKey;
-        const valueSource = view[sourceKey] || 0 /* ValueSource.Default */;
+    var array = new Array();
+    for (var _i = 0, inheritableProperties_1 = inheritableProperties; _i < inheritableProperties_1.length; _i++) {
+        var prop = inheritableProperties_1[_i];
+        var sourceKey = prop.sourceKey;
+        var valueSource = view[sourceKey] || 0 /* ValueSource.Default */;
         if (valueSource !== 0 /* ValueSource.Default */) {
             // use prop.name as it will return value or default value.
             // prop.key will return undefined if property is set the same value as default one.
@@ -1059,10 +1091,11 @@ function inheritablePropertyValuesOn(view) {
     return array;
 }
 function inheritableCssPropertyValuesOn(style) {
-    const array = new Array();
-    for (const prop of inheritableCssProperties) {
-        const sourceKey = prop.sourceKey;
-        const valueSource = style[sourceKey] || 0 /* ValueSource.Default */;
+    var array = new Array();
+    for (var _i = 0, inheritableCssProperties_1 = inheritableCssProperties; _i < inheritableCssProperties_1.length; _i++) {
+        var prop = inheritableCssProperties_1[_i];
+        var sourceKey = prop.sourceKey;
+        var valueSource = style[sourceKey] || 0 /* ValueSource.Default */;
         if (valueSource !== 0 /* ValueSource.Default */) {
             // use prop.name as it will return value or default value.
             // prop.key will return undefined if property is set the same value as default one.
@@ -1071,7 +1104,7 @@ function inheritableCssPropertyValuesOn(style) {
     }
     return array;
 }
-export const initNativeView = profile('"properties".initNativeView', function initNativeView(view) {
+export var initNativeView = profile('"properties".initNativeView', function initNativeView(view) {
     if (view._suspendedUpdates) {
         applyPendingNativeSetters(view);
     }
@@ -1083,15 +1116,15 @@ export const initNativeView = profile('"properties".initNativeView', function in
 });
 export function applyPendingNativeSetters(view) {
     // TODO: Check what happens if a view was suspended and its value was reset, or set back to default!
-    const suspendedUpdates = view._suspendedUpdates;
-    for (const propertyName in suspendedUpdates) {
-        const property = suspendedUpdates[propertyName];
-        const setNative = property.setNative;
+    var suspendedUpdates = view._suspendedUpdates;
+    for (var propertyName in suspendedUpdates) {
+        var property = suspendedUpdates[propertyName];
+        var setNative = property.setNative;
         if (view[setNative]) {
-            const { getDefault, isStyleProperty, defaultValueKey, defaultValue } = property;
-            let value;
+            var getDefault = property.getDefault, isStyleProperty = property.isStyleProperty, defaultValueKey = property.defaultValueKey, defaultValue = property.defaultValue;
+            var value = void 0;
             if (isStyleProperty) {
-                const style = view.style;
+                var style = view.style;
                 if (property.isSet(view.style)) {
                     if (!(defaultValueKey in style)) {
                         style[defaultValueKey] = view[getDefault] ? view[getDefault]() : defaultValue;
@@ -1119,44 +1152,47 @@ export function applyPendingNativeSetters(view) {
     }
 }
 export function applyAllNativeSetters(view) {
-    let symbols = Object.getOwnPropertySymbols(view);
-    for (const symbol of symbols) {
-        const property = symbolPropertyMap[symbol];
+    var symbols = Object.getOwnPropertySymbols(view);
+    for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) {
+        var symbol = symbols_2[_i];
+        var property = symbolPropertyMap[symbol];
         if (!property) {
             continue;
         }
-        const setNative = property.setNative;
-        const getDefault = property.getDefault;
+        var setNative = property.setNative;
+        var getDefault = property.getDefault;
         if (setNative in view) {
-            const defaultValueKey = property.defaultValueKey;
+            var defaultValueKey = property.defaultValueKey;
             if (!(defaultValueKey in view)) {
                 view[defaultValueKey] = view[getDefault] ? view[getDefault]() : property.defaultValue;
             }
-            const value = view[symbol];
+            var value = view[symbol];
             view[setNative](value);
         }
     }
-    const style = view.style;
+    var style = view.style;
     symbols = Object.getOwnPropertySymbols(style);
-    for (const symbol of symbols) {
-        const property = cssSymbolPropertyMap[symbol];
+    for (var _a = 0, symbols_3 = symbols; _a < symbols_3.length; _a++) {
+        var symbol = symbols_3[_a];
+        var property = cssSymbolPropertyMap[symbol];
         if (!property) {
             continue;
         }
         if (view[property.setNative]) {
-            const defaultValueKey = property.defaultValueKey;
+            var defaultValueKey = property.defaultValueKey;
             if (!(defaultValueKey in style)) {
                 style[defaultValueKey] = view[property.getDefault] ? view[property.getDefault]() : property.defaultValue;
             }
-            const value = style[symbol];
+            var value = style[symbol];
             view[property.setNative](value);
         }
     }
 }
 export function resetNativeView(view) {
-    let symbols = Object.getOwnPropertySymbols(view);
-    for (const symbol of symbols) {
-        const property = symbolPropertyMap[symbol];
+    var symbols = Object.getOwnPropertySymbols(view);
+    for (var _i = 0, symbols_4 = symbols; _i < symbols_4.length; _i++) {
+        var symbol = symbols_4[_i];
+        var property = symbolPropertyMap[symbol];
         if (!property) {
             continue;
         }
@@ -1170,10 +1206,11 @@ export function resetNativeView(view) {
             }
         }
     }
-    const style = view.style;
+    var style = view.style;
     symbols = Object.getOwnPropertySymbols(style);
-    for (const symbol of symbols) {
-        const property = cssSymbolPropertyMap[symbol];
+    for (var _a = 0, symbols_5 = symbols; _a < symbols_5.length; _a++) {
+        var symbol = symbols_5[_a];
+        var property = cssSymbolPropertyMap[symbol];
         if (!property) {
             continue;
         }
@@ -1189,24 +1226,27 @@ export function resetNativeView(view) {
     }
 }
 export function clearInheritedProperties(view) {
-    for (const prop of inheritableProperties) {
-        const sourceKey = prop.sourceKey;
+    for (var _i = 0, inheritableProperties_2 = inheritableProperties; _i < inheritableProperties_2.length; _i++) {
+        var prop = inheritableProperties_2[_i];
+        var sourceKey = prop.sourceKey;
         if (view[sourceKey] === 1 /* ValueSource.Inherited */) {
             prop.set.call(view, unsetValue);
         }
     }
-    const style = view.style;
-    for (const prop of inheritableCssProperties) {
-        const sourceKey = prop.sourceKey;
+    var style = view.style;
+    for (var _a = 0, inheritableCssProperties_2 = inheritableCssProperties; _a < inheritableCssProperties_2.length; _a++) {
+        var prop = inheritableCssProperties_2[_a];
+        var sourceKey = prop.sourceKey;
         if (style[sourceKey] === 1 /* ValueSource.Inherited */) {
             prop.setInheritedValue.call(style, unsetValue);
         }
     }
 }
 export function resetCSSProperties(style) {
-    const symbols = Object.getOwnPropertySymbols(style);
-    for (const symbol of symbols) {
-        let cssProperty;
+    var symbols = Object.getOwnPropertySymbols(style);
+    for (var _i = 0, symbols_6 = symbols; _i < symbols_6.length; _i++) {
+        var symbol = symbols_6[_i];
+        var cssProperty = void 0;
         if ((cssProperty = cssSymbolPropertyMap[symbol])) {
             style[cssProperty.cssName] = unsetValue;
             if (cssProperty instanceof CssAnimationProperty) {
@@ -1216,40 +1256,47 @@ export function resetCSSProperties(style) {
     }
 }
 export function propagateInheritableProperties(view, child) {
-    const inheritablePropertyValues = inheritablePropertyValuesOn(view);
-    for (const pair of inheritablePropertyValues) {
-        const prop = pair.property;
-        const sourceKey = prop.sourceKey;
-        const currentValueSource = child[sourceKey] || 0 /* ValueSource.Default */;
+    var inheritablePropertyValues = inheritablePropertyValuesOn(view);
+    for (var _i = 0, inheritablePropertyValues_1 = inheritablePropertyValues; _i < inheritablePropertyValues_1.length; _i++) {
+        var pair = inheritablePropertyValues_1[_i];
+        var prop = pair.property;
+        var sourceKey = prop.sourceKey;
+        var currentValueSource = child[sourceKey] || 0 /* ValueSource.Default */;
         if (currentValueSource <= 1 /* ValueSource.Inherited */) {
             prop.setInheritedValue.call(child, pair.value);
         }
     }
 }
 export function propagateInheritableCssProperties(parentStyle, childStyle) {
-    const inheritableCssPropertyValues = inheritableCssPropertyValuesOn(parentStyle);
-    for (const pair of inheritableCssPropertyValues) {
-        const prop = pair.property;
-        const sourceKey = prop.sourceKey;
-        const currentValueSource = childStyle[sourceKey] || 0 /* ValueSource.Default */;
+    var inheritableCssPropertyValues = inheritableCssPropertyValuesOn(parentStyle);
+    for (var _i = 0, inheritableCssPropertyValues_1 = inheritableCssPropertyValues; _i < inheritableCssPropertyValues_1.length; _i++) {
+        var pair = inheritableCssPropertyValues_1[_i];
+        var prop = pair.property;
+        var sourceKey = prop.sourceKey;
+        var currentValueSource = childStyle[sourceKey] || 0 /* ValueSource.Default */;
         if (currentValueSource <= 1 /* ValueSource.Inherited */) {
             prop.setInheritedValue.call(childStyle, pair.value, 1 /* ValueSource.Inherited */);
         }
     }
 }
-export function makeValidator(...values) {
-    const set = new Set(values);
-    return (value) => set.has(value);
+export function makeValidator() {
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        values[_i] = arguments[_i];
+    }
+    var set = new Set(values);
+    return function (value) { return set.has(value); };
 }
-export function makeParser(isValid, allowNumbers = false) {
-    return (value) => {
-        const lower = value && value.toLowerCase();
+export function makeParser(isValid, allowNumbers) {
+    if (allowNumbers === void 0) { allowNumbers = false; }
+    return function (value) {
+        var lower = value && value.toLowerCase();
         if (isValid(lower)) {
             return lower;
         }
         else {
             if (allowNumbers) {
-                const convNumber = +value;
+                var convNumber = +value;
                 if (!isNaN(convNumber)) {
                     return value;
                 }
@@ -1259,25 +1306,27 @@ export function makeParser(isValid, allowNumbers = false) {
     };
 }
 export function getSetProperties(view) {
-    const result = [];
-    Object.getOwnPropertyNames(view).forEach((prop) => {
+    var result = [];
+    Object.getOwnPropertyNames(view).forEach(function (prop) {
         result.push([prop, view[prop]]);
     });
-    const symbols = Object.getOwnPropertySymbols(view);
-    for (const symbol of symbols) {
-        const property = symbolPropertyMap[symbol];
+    var symbols = Object.getOwnPropertySymbols(view);
+    for (var _i = 0, symbols_7 = symbols; _i < symbols_7.length; _i++) {
+        var symbol = symbols_7[_i];
+        var property = symbolPropertyMap[symbol];
         if (!property) {
             continue;
         }
-        const value = view[property.key];
+        var value = view[property.key];
         result.push([property.name, value]);
     }
     return result;
 }
 export function getComputedCssValues(view) {
-    const result = [];
-    const style = view.style;
-    for (const prop of cssPropertyNames) {
+    var result = [];
+    var style = view.style;
+    for (var _i = 0, cssPropertyNames_1 = cssPropertyNames; _i < cssPropertyNames_1.length; _i++) {
+        var prop = cssPropertyNames_1[_i];
         result.push([prop, style[prop]]);
     }
     // Add these to enable box model in chrome-devtools styles tab