@hps1978/react-native-web-tv 0.21.2-tv.0

package/dist/cjs/exports/StyleSheet/dom/createCSSStyleSheet.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = createCSSStyleSheet;
+var _canUseDom = _interopRequireDefault(require("../../../modules/canUseDom"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+// $FlowFixMe: HTMLStyleElement is incorrectly typed - https://github.com/facebook/flow/issues/2696
+function createCSSStyleSheet(id, rootNode, textContent) {
+  if (_canUseDom.default) {
+    var root = rootNode != null ? rootNode : document;
+    var element = root.getElementById(id);
+    if (element == null) {
+      element = document.createElement('style');
+      element.setAttribute('id', id);
+      if (typeof textContent === 'string') {
+        element.appendChild(document.createTextNode(textContent));
+      }
+      if (root instanceof ShadowRoot) {
+        root.insertBefore(element, root.firstChild);
+      } else {
+        var head = root.head;
+        if (head) {
+          head.insertBefore(element, head.firstChild);
+        }
+      }
+    }
+    // $FlowFixMe: HTMLElement is incorrectly typed
+    return element.sheet;
+  } else {
+    return null;
+  }
+}
+module.exports = exports.default;

package/dist/cjs/exports/StyleSheet/dom/createOrderedCSSStyleSheet.js

@@ -0,0 +1,168 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = createOrderedCSSStyleSheet;
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var slice = Array.prototype.slice;
+
+/**
+ * Order-based insertion of CSS.
+ *
+ * Each rule is associated with a numerically defined group.
+ * Groups are ordered within the style sheet according to their number, with the
+ * lowest first.
+ *
+ * Groups are implemented using marker rules. The selector of the first rule of
+ * each group is used only to encode the group number for hydration. An
+ * alternative implementation could rely on CSSMediaRule, allowing groups to be
+ * treated as a sub-sheet, but the Edge implementation of CSSMediaRule is
+ * broken.
+ * https://developer.mozilla.org/en-US/docs/Web/API/CSSMediaRule
+ * https://gist.github.com/necolas/aa0c37846ad6bd3b05b727b959e82674
+ */
+function createOrderedCSSStyleSheet(sheet) {
+  var groups = {};
+  var selectors = {};
+
+  /**
+   * Hydrate approximate record from any existing rules in the sheet.
+   */
+  if (sheet != null) {
+    var group;
+    slice.call(sheet.cssRules).forEach((cssRule, i) => {
+      var cssText = cssRule.cssText;
+      // Create record of existing selectors and rules
+      if (cssText.indexOf('stylesheet-group') > -1) {
+        group = decodeGroupRule(cssRule);
+        groups[group] = {
+          start: i,
+          rules: [cssText]
+        };
+      } else {
+        var selectorText = getSelectorText(cssText);
+        if (selectorText != null) {
+          selectors[selectorText] = true;
+          groups[group].rules.push(cssText);
+        }
+      }
+    });
+  }
+  function sheetInsert(sheet, group, text) {
+    var orderedGroups = getOrderedGroups(groups);
+    var groupIndex = orderedGroups.indexOf(group);
+    var nextGroupIndex = groupIndex + 1;
+    var nextGroup = orderedGroups[nextGroupIndex];
+    // Insert rule before the next group, or at the end of the stylesheet
+    var position = nextGroup != null && groups[nextGroup].start != null ? groups[nextGroup].start : sheet.cssRules.length;
+    var isInserted = insertRuleAt(sheet, text, position);
+    if (isInserted) {
+      // Set the starting index of the new group
+      if (groups[group].start == null) {
+        groups[group].start = position;
+      }
+      // Increment the starting index of all subsequent groups
+      for (var i = nextGroupIndex; i < orderedGroups.length; i += 1) {
+        var groupNumber = orderedGroups[i];
+        var previousStart = groups[groupNumber].start || 0;
+        groups[groupNumber].start = previousStart + 1;
+      }
+    }
+    return isInserted;
+  }
+  var OrderedCSSStyleSheet = {
+    /**
+     * The textContent of the style sheet.
+     */
+    getTextContent() {
+      return getOrderedGroups(groups).map(group => {
+        var rules = groups[group].rules;
+        // Sorting provides deterministic order of styles in group for
+        // build-time extraction of the style sheet.
+        var marker = rules.shift();
+        rules.sort();
+        rules.unshift(marker);
+        return rules.join('\n');
+      }).join('\n');
+    },
+    /**
+     * Insert a rule into the style sheet
+     */
+    insert(cssText, groupValue) {
+      var group = Number(groupValue);
+
+      // Create a new group.
+      if (groups[group] == null) {
+        var markerRule = encodeGroupRule(group);
+        // Create the internal record.
+        groups[group] = {
+          start: null,
+          rules: [markerRule]
+        };
+        // Update CSSOM.
+        if (sheet != null) {
+          sheetInsert(sheet, group, markerRule);
+        }
+      }
+
+      // selectorText is more reliable than cssText for insertion checks. The
+      // browser excludes vendor-prefixed properties and rewrites certain values
+      // making cssText more likely to be different from what was inserted.
+      var selectorText = getSelectorText(cssText);
+      if (selectorText != null && selectors[selectorText] == null) {
+        // Update the internal records.
+        selectors[selectorText] = true;
+        groups[group].rules.push(cssText);
+        // Update CSSOM.
+        if (sheet != null) {
+          var isInserted = sheetInsert(sheet, group, cssText);
+          if (!isInserted) {
+            // Revert internal record change if a rule was rejected (e.g.,
+            // unrecognized pseudo-selector)
+            groups[group].rules.pop();
+          }
+        }
+      }
+    }
+  };
+  return OrderedCSSStyleSheet;
+}
+
+/**
+ * Helper functions
+ */
+
+function encodeGroupRule(group) {
+  return "[stylesheet-group=\"" + group + "\"]{}";
+}
+var groupPattern = /["']/g;
+function decodeGroupRule(cssRule) {
+  return Number(cssRule.selectorText.split(groupPattern)[1]);
+}
+function getOrderedGroups(obj) {
+  return Object.keys(obj).map(Number).sort((a, b) => a > b ? 1 : -1);
+}
+var selectorPattern = /\s*([,])\s*/g;
+function getSelectorText(cssText) {
+  var selector = cssText.split('{')[0].trim();
+  return selector !== '' ? selector.replace(selectorPattern, '$1') : null;
+}
+function insertRuleAt(root, cssText, position) {
+  try {
+    // $FlowFixMe: Flow is missing CSSOM types needed to type 'root'.
+    root.insertRule(cssText, position);
+    return true;
+  } catch (e) {
+    // JSDOM doesn't support `CSSSMediaRule#insertRule`.
+    // Also ignore errors that occur from attempting to insert vendor-prefixed selectors.
+    return false;
+  }
+}
+module.exports = exports.default;

package/dist/cjs/exports/StyleSheet/dom/index.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.createSheet = createSheet;
+var _canUseDom = _interopRequireDefault(require("../../../modules/canUseDom"));
+var _createCSSStyleSheet = _interopRequireDefault(require("./createCSSStyleSheet"));
+var _createOrderedCSSStyleSheet = _interopRequireDefault(require("./createOrderedCSSStyleSheet"));
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var defaultId = 'react-native-stylesheet';
+var roots = new WeakMap();
+var sheets = [];
+var initialRules = [
+// minimal top-level reset
+'html{-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:rgba(0,0,0,0);}', 'body{margin:0;}',
+// minimal form pseudo-element reset
+'button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0;}', 'input::-webkit-search-cancel-button,input::-webkit-search-decoration,input::-webkit-search-results-button,input::-webkit-search-results-decoration{display:none;}'];
+function createSheet(root, id) {
+  if (id === void 0) {
+    id = defaultId;
+  }
+  var sheet;
+  if (_canUseDom.default) {
+    var rootNode = root != null ? root.getRootNode() : document;
+    // Create the initial style sheet
+    if (sheets.length === 0) {
+      sheet = (0, _createOrderedCSSStyleSheet.default)((0, _createCSSStyleSheet.default)(id));
+      initialRules.forEach(rule => {
+        sheet.insert(rule, 0);
+      });
+      roots.set(rootNode, sheets.length);
+      sheets.push(sheet);
+    } else {
+      var index = roots.get(rootNode);
+      if (index == null) {
+        var initialSheet = sheets[0];
+        // If we're creating a new sheet, populate it with existing styles
+        var textContent = initialSheet != null ? initialSheet.getTextContent() : '';
+        // Cast rootNode to 'any' because Flow types for getRootNode are wrong
+        sheet = (0, _createOrderedCSSStyleSheet.default)((0, _createCSSStyleSheet.default)(id, rootNode, textContent));
+        roots.set(rootNode, sheets.length);
+        sheets.push(sheet);
+      } else {
+        sheet = sheets[index];
+      }
+    }
+  } else {
+    // Create the initial style sheet
+    if (sheets.length === 0) {
+      sheet = (0, _createOrderedCSSStyleSheet.default)((0, _createCSSStyleSheet.default)(id));
+      initialRules.forEach(rule => {
+        sheet.insert(rule, 0);
+      });
+      sheets.push(sheet);
+    } else {
+      sheet = sheets[0];
+    }
+  }
+  return {
+    getTextContent() {
+      return sheet.getTextContent();
+    },
+    id,
+    insert(cssText, groupValue) {
+      sheets.forEach(s => {
+        s.insert(cssText, groupValue);
+      });
+    }
+  };
+}

package/dist/cjs/exports/StyleSheet/index.js

@@ -0,0 +1,190 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.default = void 0;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutPropertiesLoose2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutPropertiesLoose"));
+var _compiler = require("./compiler");
+var _dom = require("./dom");
+var _transformLocalizeStyle = require("styleq/transform-localize-style");
+var _preprocess = require("./preprocess");
+var _styleq = require("styleq");
+var _validate = require("./validate");
+var _canUseDom = _interopRequireDefault(require("../../modules/canUseDom"));
+var _excluded = ["writingDirection"];
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+var staticStyleMap = new WeakMap();
+var sheet = (0, _dom.createSheet)();
+var defaultPreprocessOptions = {
+  shadow: true,
+  textShadow: true
+};
+function customStyleq(styles, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _options = options,
+    writingDirection = _options.writingDirection,
+    preprocessOptions = (0, _objectWithoutPropertiesLoose2.default)(_options, _excluded);
+  var isRTL = writingDirection === 'rtl';
+  return _styleq.styleq.factory({
+    transform(style) {
+      var compiledStyle = staticStyleMap.get(style);
+      if (compiledStyle != null) {
+        return (0, _transformLocalizeStyle.localizeStyle)(compiledStyle, isRTL);
+      }
+      return (0, _preprocess.preprocess)(style, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, defaultPreprocessOptions), preprocessOptions));
+    }
+  })(styles);
+}
+function insertRules(compiledOrderedRules) {
+  compiledOrderedRules.forEach(_ref => {
+    var rules = _ref[0],
+      order = _ref[1];
+    if (sheet != null) {
+      rules.forEach(rule => {
+        sheet.insert(rule, order);
+      });
+    }
+  });
+}
+function compileAndInsertAtomic(style) {
+  var _atomic = (0, _compiler.atomic)((0, _preprocess.preprocess)(style, defaultPreprocessOptions)),
+    compiledStyle = _atomic[0],
+    compiledOrderedRules = _atomic[1];
+  insertRules(compiledOrderedRules);
+  return compiledStyle;
+}
+function compileAndInsertReset(style, key) {
+  var _classic = (0, _compiler.classic)(style, key),
+    compiledStyle = _classic[0],
+    compiledOrderedRules = _classic[1];
+  insertRules(compiledOrderedRules);
+  return compiledStyle;
+}
+
+/* ----- API ----- */
+
+var absoluteFillObject = {
+  position: 'absolute',
+  left: 0,
+  right: 0,
+  top: 0,
+  bottom: 0
+};
+var absoluteFill = create({
+  x: (0, _objectSpread2.default)({}, absoluteFillObject)
+}).x;
+
+/**
+ * create
+ */
+function create(styles) {
+  Object.keys(styles).forEach(key => {
+    var styleObj = styles[key];
+    // Only compile at runtime if the style is not already compiled
+    if (styleObj != null && styleObj.$$css !== true) {
+      var compiledStyles;
+      if (key.indexOf('$raw') > -1) {
+        compiledStyles = compileAndInsertReset(styleObj, key.split('$raw')[0]);
+      } else {
+        if (process.env.NODE_ENV !== 'production') {
+          (0, _validate.validate)(styleObj);
+          styles[key] = Object.freeze(styleObj);
+        }
+        compiledStyles = compileAndInsertAtomic(styleObj);
+      }
+      staticStyleMap.set(styleObj, compiledStyles);
+    }
+  });
+  return styles;
+}
+
+/**
+ * compose
+ */
+function compose(style1, style2) {
+  if (process.env.NODE_ENV !== 'production') {
+    /* eslint-disable prefer-rest-params */
+    var len = arguments.length;
+    if (len > 2) {
+      var readableStyles = [...arguments].map(a => flatten(a));
+      throw new Error("StyleSheet.compose() only accepts 2 arguments, received " + len + ": " + JSON.stringify(readableStyles));
+    }
+    /* eslint-enable prefer-rest-params */
+    /*
+    console.warn(
+      'StyleSheet.compose(a, b) is deprecated; use array syntax, i.e., [a,b].'
+    );
+    */
+  }
+  return [style1, style2];
+}
+
+/**
+ * flatten
+ */
+function flatten() {
+  for (var _len = arguments.length, styles = new Array(_len), _key = 0; _key < _len; _key++) {
+    styles[_key] = arguments[_key];
+  }
+  var flatArray = styles.flat(Infinity);
+  var result = {};
+  for (var i = 0; i < flatArray.length; i++) {
+    var style = flatArray[i];
+    if (style != null && typeof style === 'object') {
+      // $FlowFixMe
+      Object.assign(result, style);
+    }
+  }
+  return result;
+}
+
+/**
+ * getSheet
+ */
+function getSheet() {
+  return {
+    id: sheet.id,
+    textContent: sheet.getTextContent()
+  };
+}
+
+/**
+ * resolve
+ */
+
+function StyleSheet(styles, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var isRTL = options.writingDirection === 'rtl';
+  var styleProps = customStyleq(styles, options);
+  if (Array.isArray(styleProps) && styleProps[1] != null) {
+    styleProps[1] = (0, _compiler.inline)(styleProps[1], isRTL);
+  }
+  return styleProps;
+}
+StyleSheet.absoluteFill = absoluteFill;
+StyleSheet.absoluteFillObject = absoluteFillObject;
+StyleSheet.create = create;
+StyleSheet.compose = compose;
+StyleSheet.flatten = flatten;
+StyleSheet.getSheet = getSheet;
+// `hairlineWidth` is not implemented using screen density as browsers may
+// round sub-pixel values down to `0`, causing the line not to be rendered.
+StyleSheet.hairlineWidth = 1;
+if (_canUseDom.default && window.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
+  window.__REACT_DEVTOOLS_GLOBAL_HOOK__.resolveRNStyle = StyleSheet.flatten;
+}
+var stylesheet = StyleSheet;
+var _default = exports.default = stylesheet;
+module.exports = exports.default;

package/dist/cjs/exports/StyleSheet/preprocess.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+exports.__esModule = true;
+exports.preprocess = exports.default = exports.createTransformValue = exports.createTransformOriginValue = exports.createTextShadowValue = exports.createBoxShadowValue = exports.createBoxShadowArrayValue = void 0;
+var _normalizeColor = _interopRequireDefault(require("./compiler/normalizeColor"));
+var _normalizeValueWithProperty = _interopRequireDefault(require("./compiler/normalizeValueWithProperty"));
+var _warnOnce = require("../../modules/warnOnce");
+/**
+ * Copyright (c) Nicolas Gallagher.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+var emptyObject = {};
+
+/**
+ * Shadows
+ */
+
+var defaultOffset = {
+  height: 0,
+  width: 0
+};
+var createBoxShadowValue = style => {
+  var shadowColor = style.shadowColor,
+    shadowOffset = style.shadowOffset,
+    shadowOpacity = style.shadowOpacity,
+    shadowRadius = style.shadowRadius;
+  var _ref = shadowOffset || defaultOffset,
+    height = _ref.height,
+    width = _ref.width;
+  var offsetX = (0, _normalizeValueWithProperty.default)(width);
+  var offsetY = (0, _normalizeValueWithProperty.default)(height);
+  var blurRadius = (0, _normalizeValueWithProperty.default)(shadowRadius || 0);
+  var color = (0, _normalizeColor.default)(shadowColor || 'black', shadowOpacity);
+  if (color != null && offsetX != null && offsetY != null && blurRadius != null) {
+    return offsetX + " " + offsetY + " " + blurRadius + " " + color;
+  }
+};
+exports.createBoxShadowValue = createBoxShadowValue;
+var createTextShadowValue = style => {
+  var textShadowColor = style.textShadowColor,
+    textShadowOffset = style.textShadowOffset,
+    textShadowRadius = style.textShadowRadius;
+  var _ref2 = textShadowOffset || defaultOffset,
+    height = _ref2.height,
+    width = _ref2.width;
+  var radius = textShadowRadius || 0;
+  var offsetX = (0, _normalizeValueWithProperty.default)(width);
+  var offsetY = (0, _normalizeValueWithProperty.default)(height);
+  var blurRadius = (0, _normalizeValueWithProperty.default)(radius);
+  var color = (0, _normalizeValueWithProperty.default)(textShadowColor, 'textShadowColor');
+  if (color && (height !== 0 || width !== 0 || radius !== 0) && offsetX != null && offsetY != null && blurRadius != null) {
+    return offsetX + " " + offsetY + " " + blurRadius + " " + color;
+  }
+};
+
+// { offsetX: 1, offsetY: 2, blurRadius: 3, spreadDistance: 4, color: 'rgba(255, 0, 0)', inset: true }
+// => 'rgba(255, 0, 0) 1px 2px 3px 4px inset'
+exports.createTextShadowValue = createTextShadowValue;
+var mapBoxShadow = boxShadow => {
+  if (typeof boxShadow === 'string') {
+    return boxShadow;
+  }
+  var offsetX = (0, _normalizeValueWithProperty.default)(boxShadow.offsetX) || 0;
+  var offsetY = (0, _normalizeValueWithProperty.default)(boxShadow.offsetY) || 0;
+  var blurRadius = (0, _normalizeValueWithProperty.default)(boxShadow.blurRadius) || 0;
+  var spreadDistance = (0, _normalizeValueWithProperty.default)(boxShadow.spreadDistance) || 0;
+  var color = (0, _normalizeColor.default)(boxShadow.color) || 'black';
+  var position = boxShadow.inset ? 'inset ' : '';
+  return "" + position + offsetX + " " + offsetY + " " + blurRadius + " " + spreadDistance + " " + color;
+};
+var createBoxShadowArrayValue = value => {
+  return value.map(mapBoxShadow).join(', ');
+};
+
+// { scale: 2 } => 'scale(2)'
+// { translateX: 20 } => 'translateX(20px)'
+// { matrix: [1,2,3,4,5,6] } => 'matrix(1,2,3,4,5,6)'
+exports.createBoxShadowArrayValue = createBoxShadowArrayValue;
+var mapTransform = transform => {
+  var type = Object.keys(transform)[0];
+  var value = transform[type];
+  if (type === 'matrix' || type === 'matrix3d') {
+    return type + "(" + value.join(',') + ")";
+  } else {
+    var normalizedValue = (0, _normalizeValueWithProperty.default)(value, type);
+    return type + "(" + normalizedValue + ")";
+  }
+};
+var createTransformValue = value => {
+  return value.map(mapTransform).join(' ');
+};
+
+// [2, '30%', 10] => '2px 30% 10px'
+exports.createTransformValue = createTransformValue;
+var createTransformOriginValue = value => {
+  return value.map(v => (0, _normalizeValueWithProperty.default)(v)).join(' ');
+};
+exports.createTransformOriginValue = createTransformOriginValue;
+var PROPERTIES_STANDARD = {
+  borderBottomEndRadius: 'borderEndEndRadius',
+  borderBottomStartRadius: 'borderEndStartRadius',
+  borderTopEndRadius: 'borderStartEndRadius',
+  borderTopStartRadius: 'borderStartStartRadius',
+  borderEndColor: 'borderInlineEndColor',
+  borderEndStyle: 'borderInlineEndStyle',
+  borderEndWidth: 'borderInlineEndWidth',
+  borderStartColor: 'borderInlineStartColor',
+  borderStartStyle: 'borderInlineStartStyle',
+  borderStartWidth: 'borderInlineStartWidth',
+  end: 'insetInlineEnd',
+  marginEnd: 'marginInlineEnd',
+  marginHorizontal: 'marginInline',
+  marginStart: 'marginInlineStart',
+  marginVertical: 'marginBlock',
+  paddingEnd: 'paddingInlineEnd',
+  paddingHorizontal: 'paddingInline',
+  paddingStart: 'paddingInlineStart',
+  paddingVertical: 'paddingBlock',
+  start: 'insetInlineStart'
+};
+var ignoredProps = {
+  elevation: true,
+  overlayColor: true,
+  resizeMode: true,
+  tintColor: true
+};
+
+/**
+ * Preprocess styles
+ */
+var preprocess = exports.preprocess = function preprocess(originalStyle, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var style = originalStyle || emptyObject;
+  var nextStyle = {};
+
+  // Convert shadow styles
+  if (options.shadow === true, style.shadowColor != null || style.shadowOffset != null || style.shadowOpacity != null || style.shadowRadius != null) {
+    (0, _warnOnce.warnOnce)('shadowStyles', "\"shadow*\" style props are deprecated. Use \"boxShadow\".");
+    var boxShadowValue = createBoxShadowValue(style);
+    if (boxShadowValue != null) {
+      nextStyle.boxShadow = boxShadowValue;
+    }
+  }
+
+  // Convert text shadow styles
+  if (options.textShadow === true, style.textShadowColor != null || style.textShadowOffset != null || style.textShadowRadius != null) {
+    (0, _warnOnce.warnOnce)('textShadowStyles', "\"textShadow*\" style props are deprecated. Use \"textShadow\".");
+    var textShadowValue = createTextShadowValue(style);
+    if (textShadowValue != null && nextStyle.textShadow == null) {
+      var textShadow = style.textShadow;
+      var value = textShadow ? textShadow + ", " + textShadowValue : textShadowValue;
+      nextStyle.textShadow = value;
+    }
+  }
+  for (var originalProp in style) {
+    if (
+    // Ignore some React Native styles
+    ignoredProps[originalProp] != null || originalProp === 'shadowColor' || originalProp === 'shadowOffset' || originalProp === 'shadowOpacity' || originalProp === 'shadowRadius' || originalProp === 'textShadowColor' || originalProp === 'textShadowOffset' || originalProp === 'textShadowRadius') {
+      continue;
+    }
+    var originalValue = style[originalProp];
+    var prop = PROPERTIES_STANDARD[originalProp] || originalProp;
+    var _value = originalValue;
+    if (!Object.prototype.hasOwnProperty.call(style, originalProp) || prop !== originalProp && style[prop] != null) {
+      continue;
+    }
+    if (prop === 'aspectRatio' && typeof _value === 'number') {
+      nextStyle[prop] = _value.toString();
+    } else if (prop === 'boxShadow') {
+      if (Array.isArray(_value)) {
+        _value = createBoxShadowArrayValue(_value);
+      }
+      var boxShadow = nextStyle.boxShadow;
+      nextStyle.boxShadow = boxShadow ? _value + ", " + boxShadow : _value;
+    } else if (prop === 'fontVariant') {
+      if (Array.isArray(_value) && _value.length > 0) {
+        /*
+        warnOnce(
+          'fontVariant',
+          '"fontVariant" style array value is deprecated. Use space-separated values.'
+        );
+        */
+        _value = _value.join(' ');
+      }
+      nextStyle[prop] = _value;
+    } else if (prop === 'textAlignVertical') {
+      /*
+      warnOnce(
+        'textAlignVertical',
+        '"textAlignVertical" style is deprecated. Use "verticalAlign".'
+      );
+      */
+      if (style.verticalAlign == null) {
+        nextStyle.verticalAlign = _value === 'center' ? 'middle' : _value;
+      }
+    } else if (prop === 'transform') {
+      if (Array.isArray(_value)) {
+        _value = createTransformValue(_value);
+      }
+      nextStyle.transform = _value;
+    } else if (prop === 'transformOrigin') {
+      if (Array.isArray(_value)) {
+        _value = createTransformOriginValue(_value);
+      }
+      nextStyle.transformOrigin = _value;
+    } else {
+      nextStyle[prop] = _value;
+    }
+  }
+
+  // $FlowIgnore
+  return nextStyle;
+};
+var _default = exports.default = preprocess;