Computes and returns the CSS styles for the given position.

@private
7445
function(oPosition) {
		var oPos = oPosition.getComputedPosition();

		var addStyle = function(oPosition, aBuffer, sPos, sVal){
			if (sVal) {
				aBuffer.push(sPos + ":" + sVal + ";");
			}
		};

		var aBuffer = [];
		addStyle(oPosition, aBuffer, "top", oPos.top);
		addStyle(oPosition, aBuffer, "bottom", oPos.bottom);
		addStyle(oPosition, aBuffer, "left", oPos.left);
		addStyle(oPosition, aBuffer, "right", oPos.right);
		addStyle(oPosition, aBuffer, "width", oPos.width);
		addStyle(oPosition, aBuffer, "height", oPos.height);

		return aBuffer.join("");
	}
140416
function getStyle(element) {
    const style = element.style;
    const styles = {};
    for (let i = 0; i < style.length; i++) {
        const name = style.item(i);
        const transformedName = transformName(name);
        styles[transformedName] = style.getPropertyValue(name);
    }
    return styles;
}
772645
function getBordersSize(styles, ...positions) {
    return positions.reduce((size, position) => {
        const value = styles['border-' + position + '-width'];

        return size + toFloat(value);
    }, 0);
}
342504
def css(self, css):
    
    return [self.get_node_factory().create(node_id)
            for node_id in self._get_css_ids(css).split(",")
            if node_id]
469733
function stylesheet() {
    var rulesList = rules();

    return {
      type: 'stylesheet',
      stylesheet: {
        source: options.source,
        rules: rulesList,
        parsingErrors: errorsList
      }
    };
  }
9498
function (position) {
        var style = this.cvsDiv.style;
        style.left = position.x + "px";
        style.top = position.y + "px";

        this.position = position;
    }
1221974
function(pos) {
                                var l = pos.left < 0 ? 0 : pos.left,
                                t = pos.top < 0 ? 0 : pos.top;

                                $(this).css({
                                    left: l,
                                    top: t
                                });
                            }
549740
function fetchStyle(id) {
    for (var i = 0; i < styles.length; i++)
      if (styles[i].id === id) return styles[i];
  }
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;
	}
1312587
function getStyles(props) {
  const { toolbar } = props.theme;

  return {
    container: [toolbar.container, props.style.container],
  };
}
87926
function computeStyle(elem, prop) {
        if (!win.getComputedStyle) {
          win.getComputedStyle = function(el, pseudo) {
            this.el = el;
            this.getPropertyValue = function(prop) {
              var re = /(\-([a-z]){1})/g;
              if (prop == 'float') prop = 'styleFloat';
              if (re.test(prop)) {
                prop = prop.replace(re, function() {
                  return arguments[2].toUpperCase();
                });
              }
              return el.currentStyle && el.currentStyle[prop] ? el.currentStyle[prop] : null;
            };
            return this;
          };
        }

        return win.getComputedStyle(elem, null).getPropertyValue(prop);
      }
794562
async function getCustomPropertiesFromCSSFile(from) {
	const css = await readFile(from);
	const root = postcss.parse(css, { from });

	return getCustomPropertiesFromRoot(root, { preserve: true });
}
760200
def _lookup_style(element, names):
    '''
    
    '''
    return _STYLES.get('_'+element, '') + \
        ''.join([_STYLES.get(name, '') for name in names])
259110
function loadStyles(css, doc) {
            // default to the global `document` object
            if (!doc) doc = document;

            var head = doc.head || doc.getElementsByTagName('head')[0];

            // no <head> node? create one...
            if (!head) {
                head = doc.createElement('head');
                var body = doc.body || doc.getElementsByTagName('body')[0];
                if (body) {
                    body.parentNode.insertBefore(head, body);
                } else {
                    doc.documentElement.appendChild(head);
                }
            }

            var style = doc.createElement('style');
            style.type = 'text/css';
            if (style.styleSheet) {
                // IE
                style.styleSheet.cssText = css;
            } else {
                // the world
                style.appendChild(doc.createTextNode(css));
            }
            head.appendChild(style);

            return style;
        }
261918
function(styles) {

	var computedStyles = document.defaultView.getComputedStyle(this._node),
		i,
		eachStyle,
		cssMap = {}

	// String case, just return the correct style
	if (typeof styles == "string") {
		return computedStyles[styles]
	}

	for (i=0; eachStyle = styles[i]; i++) {
		cssMap[eachStyle] = computedStyles[eachStyle]
	}
	return cssMap
}
632835
function getCSSText(className) {
			if (typeof document.styleSheets != "object") return "";
			if (document.styleSheets.length <= 0) return "";
			var classes = document.styleSheets[0].rules || document.styleSheets[0].cssRules;
			for (var x = 0; x < classes.length; x++) {
				if (classes[x].selectorText == "." + className || classes[x].selectorText == "#" + className) {
					return ((classes[x].cssText) ? (classes[x].cssText) : (classes[x].style.cssText));
				}
			}
			return "";
		}
846176
function getStyles(element, property, extra) {
  const styles = element.ownerDocument.defaultView.getComputedStyle(
    element,
    null
  );
  if (property) {
    const cssValue = styles.getPropertyValue(property) || styles[property];
    if (extra) {
      const num = parseFloat(cssValue);
      return extra === true || isFinite(num) ? num || 0 : cssValue;
    }
    return cssValue;
  }
  return styles;
}