Gets the value of a prop in a given inline style string
@param {String} style inline styles
@param {String} prop  prop to get

@return {String} style
342311
function getProp (style = '', prop) {
  prop = prop.trim().toLowerCase()
  const decls = style.split(';')

  let value = false

  decls.forEach((decl) => {
    if (decl.trim().toLowerCase().startsWith(`${prop}:`)) {
      value = decl.split(':')[1].trim()
    }
  })

  return value
}
110229
public String getProperty(String prop)
    {
        // assuming Properties are initialized with this call
        return prop != null ? getProperties().getProperty(prop) : null;
    }
1080345
function merge(Style $style)
    {
        $shorthand_properties = array("background", "border", "border_bottom", "border_color", "border_left", "border_radius", "border_right", "border_style", "border_top", "border_width", "flex", "font", "list_style", "margin", "padding", "transform");
        //treat the !important attribute
        //if old rule has !important attribute, override with new rule only if
        //the new rule is also !important
        foreach ($style->_props as $prop => $val) {
            $can_merge = false;
            if (isset($style->_important_props[$prop])) {
                $this->_important_props[$prop] = true;
                $can_merge = true;
            } else if (!isset($this->_important_props[$prop])) {
                $can_merge = true;
            }

            if ($can_merge) {
                //see __set and __get, on all assignments clear cache!
                $this->_prop_cache[$prop] = null;
                $this->_props[$prop] = $val;

                // Clear out "inherit" shorthand properties if specific properties have been set
                $shorthands = array_filter($shorthand_properties, function($el) use ($prop) {
                    return ( strpos($prop, $el."_") !== false );
                });
                foreach ($shorthands as $shorthand) {
                    if (array_key_exists($shorthand, $this->_props) && $this->_props[$shorthand] === "inherit") {
                        unset($this->_props[$shorthand]);
                    }
                } 
            }
        }

        if (isset($style->_props["font_size"])) {
            $this->__font_size_calculated = false;
        }
    }
1334290
function(props, val) {
      if (/^o/.test(typeof props)) {
        for(var prop in props) {
          var prefixed = u.prfx(prop);
          if (props.hasOwnProperty(prop)) {
            this.each(function(index, el) {
              el.style[prefixed] = props[prop];
            });
          }
        }
        return this;
      }
      else {
        return val === undefined ? (this.length ? getComputedStyle(this[0])[props] : null) : this.each(function(index, el) {
          var prefixed = u.prfx(props);
          el.style[prefixed] = val;
        });
      }
    }
990674
function css(property) {
        if (cssCache[property] === undefined) {
            var domProperty = property.
                replace(/(-[\s\S])/g, function(c) { return c.charAt(1).toUpperCase(); });
            var prefixedDom = style(domProperty);
            cssCache[property] = domToCss(prefixedDom);
        }
        return cssCache[property];
    }
236940
function getStyle(el, prop) {
    return window.getComputedStyle !== undefined ? window.getComputedStyle(el, null).getPropertyValue(prop) : el.currentStyle[prop];
  }
1317960
function(style)
	{
		var result = [];
		
		if (style != null)
		{
			var pairs = style.split(';');
			
			for (var i = 0; i < pairs.length; i++)
			{
				if (pairs[i].indexOf('=') < 0)
				{
					result.push(pairs[i]);
				}
			}
		}
				
		return result;
	}
653782
function(el, prop) {
    var value = _getComputedStyle(el, null).getPropertyValue(prop);
    if (prop === "cursor") {
      if (!value || value === "auto") {
        if (el.nodeName === "A") {
          return "pointer";
        }
      }
    }
    return value;
  }
471985
private static function getBindingValue ($prop, Component $component, &$error)
  {
    $error = $l = false;
    try {
      $l = ob_get_level ();
      $v = $component->getComputedPropValue ($prop);
    }
    catch (\Exception $e) {
      $error = true;
      while (ob_get_level () > $l)
        ob_end_clean ();
      return "<b style='color:red'>ERROR</b>";
    }
    return $v;
  }
347569
function (key, styles) {
    key = camelToKebab(key)
    let stylesText = ''
    for (const k in styles) {
      if (styles.hasOwnProperty(k)) {
        stylesText += camelToKebab(k) + ':' + styles[k] + ';'
      }
    }
    const styleText = `@${key}{${stylesText}}`
    appendCss(styleText, 'dom-added-rules')
  }
660543
function( element, property )
    {
        var styles = window.getComputedStyle( element, null );

        if ( styles ) {
          // element.style[..] is undefined for browser specific styles
          // as 'filter'.
          return styles[ property ] || styles.getPropertyValue( property ) || '';
        }
        return "";
    }
606859
function ( target ) {
        var props = {};

        String(target).replace( this.REG_CSS, function ( str, n, v ) {
            var obj = $B.style.parseValue( v );
            props[ $B.string.camelCase(n) ] = {name: n, value: obj.value, unit: obj.unit};
        });
        return props;
    }
1312587
function getStyles(props) {
  const { toolbar } = props.theme;

  return {
    container: [toolbar.container, props.style.container],
  };
}
1108325
function( property, includeNonDefault = true ){
    let ele = this[0];
    let cy = ele.cy();

    if( !cy.styleEnabled() ){ return; }

    if( ele ){
      let overriddenStyle = ele._private.style[ property ];

      if( overriddenStyle != null ){
        return overriddenStyle;
      } else if( includeNonDefault ){
        return cy.style().getDefaultProperty( property );
      } else {
        return null;
      }
    }
  }
299193
public function getString($prop) {

			// Get property
			$val = $this->get($prop);

			// Parse as a string
			if (is_string($val)) {
				return strval($val);
			} else {
				return null;
			}

		}
1026406
function(prop) {
			var vendors = this._vendors,
				fixt = prop;
			var element = document.documentElement;
			prop = String(prop);
			if (prop.startsWith("-beta-")) {
				vendors.every(function(vendor) {
					var test = this._camelcase(prop.replace("-beta-", vendor));
					if (element.style[test] !== undefined) {
						fixt = test;
						return false;
					}
					return true;
				}, this);
			} else {
				fixt = this._camelcase(fixt);
			}
			return fixt;
		}
914154
function (styles) {
        const symbol = this._getInternalSymbol();
        const stylesToAnimate = {};
        for (const p in styles) {
            if (styles.hasOwnProperty(p)) {
                const v = styles[p];
                if (p !== 'translate' && p !== 'symbol') {
                    //this.getRadius() / this.getWidth(), etc.
                    const fnName = 'get' + p[0].toUpperCase() + p.substring(1);
                    const current = this[fnName]();
                    stylesToAnimate[p] = [current, v];
                } else if (p === 'symbol') {
                    let symbolToAnimate;
                    if (Array.isArray(styles['symbol'])) {
                        if (!Array.isArray(symbol)) {
                            throw new Error('geometry\'symbol isn\'t a composite symbol, while the symbol in styles is.');
                        }
                        symbolToAnimate = [];
                        const symbolInStyles = styles['symbol'];
                        for (let i = 0; i < symbolInStyles.length; i++) {
                            if (!symbolInStyles[i]) {
                                symbolToAnimate.push(null);
                                continue;
                            }
                            const a = {};
                            for (const sp in symbolInStyles[i]) {
                                if (symbolInStyles[i].hasOwnProperty(sp)) {
                                    a[sp] = [symbol[i][sp], symbolInStyles[i][sp]];
                                }
                            }
                            symbolToAnimate.push(a);
                        }
                    } else {
                        if (Array.isArray(symbol)) {
                            throw new Error('geometry\'symbol is a composite symbol, while the symbol in styles isn\'t.');
                        }
                        symbolToAnimate = {};
                        for (const sp in v) {
                            if (v.hasOwnProperty(sp)) {
                                symbolToAnimate[sp] = [symbol[sp], v[sp]];
                            }
                        }
                    }
                    stylesToAnimate['symbol'] = symbolToAnimate;
                } else if (p === 'translate') {
                    stylesToAnimate['translate'] = new Coordinate(v);
                }
            }
        }
        return stylesToAnimate;
    }