whether support css transform 3d
@returns {boolean}
508473
function () {
            if (isTransform3dSupported !== undefined) {
                return isTransform3dSupported;
            }
            if (!documentElement || !getVendorInfo('transform')) {
                isTransform3dSupported = false;
            } else {
                // https://gist.github.com/lorenzopolidori/3794226
                // ie9 does not support 3d transform
                // http://msdn.microsoft.com/en-us/ie/ff468705
                try {
                    var el = doc.createElement('p');
                    var transformProperty = getVendorInfo('transform').propertyName;
                    documentElement.insertBefore(el, documentElement.firstChild);
                    el.style[transformProperty] = 'translate3d(1px,1px,1px)';
                    var computedStyle = win.getComputedStyle(el);
                    var has3d = computedStyle.getPropertyValue(transformProperty) || computedStyle[transformProperty];
                    documentElement.removeChild(el);
                    isTransform3dSupported = has3d !== undefined && has3d.length > 0 && has3d !== 'none';
                } catch (e) {
                    // https://github.com/kissyteam/kissy/issues/563
                    isTransform3dSupported = true;
                }
            }
            return isTransform3dSupported;
        }
1123041
function(name, structure, mode, opts) {
    var found = false;
    for (var i = 0; i < this.RENDER_MODES.length; ++i) {
      if (this.RENDER_MODES[i] === mode) {
        found = true;
        break;
      }
    }
    if (!found) {
      console.error('render mode', mode, 'not supported');
      return;
    }

    return this[mode](name, structure, opts);
  }
465759
function () {
            var outerWidth = this._outerWidth;
            var newValue;
            if (outerWidth < 0) {
                newValue = -1;
            } else {
                newValue = outerWidth - this._iconsWidth;
                if (newValue < 0) {
                    newValue = 0;
                }
            }
            if (this._frameWidth !== newValue) {
                this._frameWidth = newValue;
                return true;
            }
            return false;
        }
612482
function getTransformPropertyName(globalObj, forceRefresh = false) {
  if (storedTransformPropertyName === undefined || forceRefresh) {
    const el = globalObj.document.createElement('div');
    storedTransformPropertyName =
      'transform' in el.style ? 'transform' : 'webkitTransform';
  }

  return storedTransformPropertyName;
}
1137539
function (vnode, callback) {
    const { isArray } = utils
    if (isArray(vnode)) {
      if (process.env.NODE_ENV === 'development') {
        console.warn(
          '[vue-render] the ref passed to animation.transitionOnce is a array.'
        )
      }
      vnode = vnode[0]
    }
    let direction = 'ltr'
    if (vnode && vnode === 'viewport') {
      direction = getComputedStyle(document.documentElement)['direction']
    }
    else if (vnode) {
      const el = vnode instanceof HTMLElement ? vnode : vnode.$el
      direction = getComputedStyle(el)['direction']
    }
    callback && callback(direction)
    return direction
  }
80576
function customPropertiesSupported () {
  if (typeof cachedReturnVal !== 'undefined') return cachedReturnVal
  return cachedReturnVal = (
    canUseDOM &&
    !(Browser.msedge) && // polyfill edge until improved css variable support
    window.CSS && window.CSS.supports && window.CSS.supports('color', 'var(--primary)')
  )
}
721419
function setTransform(element, transform) {
  element.style['transform-origin'] = 'top left';

  [ '', '-ms-', '-webkit-' ].forEach(function(prefix) {
    element.style[prefix + 'transform'] = transform;
  });
}
332363
function Converter(css) {
  var parse = require('css-parse');
  this.css = css;
  this.root = parse(css, { position: false });
  this.indents = 0;
}
78390
@Override
	public void transform(Transform3D transform) {
		if (transform!=null) {
			Point3D p = new Point3f();
			for(int i=0; i<this.numCoords;) {
				p.set(this.coords[i], this.coords[i+1], this.coords[i+2]);
				transform.transform(p);
				this.coords[i++] = p.getX();
				this.coords[i++] = p.getY();
				this.coords[i++] = p.getZ();
			}
			this.graphicalBounds = null;
			this.logicalBounds = null;
		}
	}
280387
public boolean fitsInside3D(Dimension dimension) {
		return fitsInside3D(dimension.getWidth(), dimension.getDepth(), dimension.getHeight());
	}
707828
function() {
		var s = document.createElement('p').style, // 's' for style. better to create an element if body yet to exist
			v = ['ms','O','Moz','Webkit']; // 'v' for vendor

		if( s['transition'] !== undefined ) {
			return true; 
		}
			
		while( v.length ) {
			if( v.pop() + 'Transition' in s ) {
				return true;
			}
		}
				
		return false;
	}
757256
function Vector3D( x , y , z ) {
	this.x = + x ;
	this.y = + y ;
	this.z = + z ;
}
1251719
function(raw) {
      var css = { };
      var lookups = 'left top right bottom width height x y min-width min-height max-width max-height';

      angular.forEach(raw, function(value,key) {
        if (angular.isUndefined(value)) return;

        if (lookups.indexOf(key) >= 0) {
          css[key] = value + 'px';
        } else {
          switch (key) {
            case 'transition':
              convertToVendor(key, $mdConstant.CSS.TRANSITION, value);
              break;
            case 'transform':
              convertToVendor(key, $mdConstant.CSS.TRANSFORM, value);
              break;
            case 'transformOrigin':
              convertToVendor(key, $mdConstant.CSS.TRANSFORM_ORIGIN, value);
              break;
            case 'font-size':
              css['font-size'] = value; // font sizes aren't always in px
              break;
          }
        }
      });

      return css;

      function convertToVendor(key, vendor, value) {
        angular.forEach(vendor.split(' '), function (key) {
          css[key] = value;
        });
      }
    }
1154406
function (transform, addTransition, transition) {
      var css = {};
      angular.forEach($mdConstant.CSS.TRANSFORM.split(' '), function (key) {
        css[key] = transform;
      });

      if (addTransition) {
        transition = transition || "all 0.4s cubic-bezier(0.25, 0.8, 0.25, 1) !important";
        css.transition = transition;
      }

      return css;
    }
1272592
function shouldPreStyle(f) {

    var preStyle = false;

    // if we already tested for prestyling we don't have to do it again
    if (f.preStyleTestCompleted) {
      return false;
    }

    // should have an inline style, if not, apply
    if (!/inline-/.test(f.display)) {
      preStyle = true;
      f.display = 'inline-block';
    }

    // to correctly calculate dimensions the element should have whiteSpace set to nowrap
    if (f.whiteSpace !== 'nowrap') {
      preStyle = true;
      f.whiteSpace = 'nowrap';
    }

    // we don't have to do this twice
    f.preStyleTestCompleted = true;

    return preStyle;
  }
1258345
function() {
		if ( !this.force2D && WebGLRenderer.isSupported( this.el ) ) {
			this.renderer = new WebGLRenderer( this.el );
		} else if ( Canvas2DRenderer.isSupported( this.el ) ) {
			this.renderer = new Canvas2DRenderer( this.el );
		} else {
			throw new Error( "No supported renderer!" );
		}
	}
1285621
function getCss(shapes, options) {
	const spriteRelative = path.relative(options.styleOutput, options.spritePath);
	return new CSS(shapes, {
		nameSpace: options.nameSpace,
		block: options.dirname,
		separator: options.cssSeparator,
		spriteRelative: path.normalize(spriteRelative).replace(/\\/g, '/')
	}).getCss();
}