Maintain prepared stylesheets in memory for reuse
346156
private Templates tryCache(String url) throws Exception {
        Templates x = (Templates) m_cache.get(url);
        if (x == null) {
            synchronized (m_cache) {
                if (!m_cache.containsKey(url)) {
                    TransformerFactory factory = TransformerFactory.newInstance();
                    if (factory.getClass().getName().equals("net.sf.saxon.TransformerFactoryImpl")) {
                        factory.setAttribute(FeatureKeys.VERSION_WARNING, Boolean.FALSE);
                    }
                    StreamSource ss = new StreamSource(getInputStream(url));
                    ss.setSystemId(url);
                    x = factory.newTemplates(ss);
                    m_cache.put(url, x);
                }
            }
        }
        return x;
    }
830693
function remove_inline_stylesheets(){
      for (var i = 0; i < styles.length; i++) {
        if (styles[i].length && styles[i] !== "\n") {
          html = html.replace(styles[i], "");
        }
      }
    }
287426
function () {
            var $loadStylesheetPromise,
                $loadMetadataPromise,
                $pageOneContentPromise,
                $pageOneTextPromise;

            if ($assetsPromise) {
                return;
            }

            $loadMetadataPromise = scope.get('metadata');
            $loadMetadataPromise.then(function handleMetadataResponse(metadata) {
                config.metadata = metadata;
            });

            // don't load the stylesheet for IE < 9
            if (browser.ielt9) {
                stylesheetEl = util.insertCSS('');
                config.stylesheet = stylesheetEl.styleSheet;
                $loadStylesheetPromise = $.when('').promise({
                    abort: function () {}
                });
            } else {
                $loadStylesheetPromise = scope.get('stylesheet');
                $loadStylesheetPromise.then(function handleStylesheetResponse(cssText) {
                    stylesheetEl = util.insertCSS(cssText);
                    config.stylesheet = stylesheetEl.sheet;
                });
            }


            // load page 1 assets immediately if necessary
            if (config.autoloadFirstPage &&
                (!config.pageStart || config.pageStart === 1)) {
                if (support.svg && config.useSVG) {
                    $pageOneContentPromise = scope.get('page-svg', 1);
                } else if (config.conversionIsComplete) {
                    // unfortunately, page-1.png is not necessarily available
                    // on View API's document.viewable event, so we can only
                    // prefetch page-1.png if conversion is complete
                    $pageOneContentPromise = scope.get('page-img', 1);
                }
                if (config.enableTextSelection) {
                    $pageOneTextPromise = scope.get('page-text', 1);
                }
            }

            // when both metatadata and stylesheet are done or if either fails...
            $assetsPromise = $.when($loadMetadataPromise, $loadStylesheetPromise)
                .fail(function (error) {
                    if ($assetsPromise) {
                        $assetsPromise.abort();
                    }
                    scope.ready();
                    scope.broadcast('asseterror', error);
                    scope.broadcast('fail', error);
                })
                .then(completeInit)
                .promise({
                    abort: function () {
                        $assetsPromise = null;
                        $loadMetadataPromise.abort();
                        $loadStylesheetPromise.abort();
                        if ($pageOneContentPromise) {
                            $pageOneContentPromise.abort();
                        }
                        if ($pageOneTextPromise) {
                            $pageOneTextPromise.abort();
                        }
                    }
                });
        }
697406
def create_stylesheets
      template 'stylesheets/myg.scss', "#{stylesheets_dir}/myg.scss"
      template 'stylesheets/variables/_action-button.scss',
               "#{stylesheets_dir}/variables/_action-button.scss"
      template 'stylesheets/variables/_animate.scss',
               "#{stylesheets_dir}/variables/_animate.scss"
      template 'stylesheets/variables/_base.scss',
               "#{stylesheets_dir}/variables/_base.scss"
      template 'stylesheets/variables/_font.scss',
               "#{stylesheets_dir}/variables/_font.scss"
      template 'stylesheets/variables/_footer.scss',
               "#{stylesheets_dir}/variables/_footer.scss"
      template 'stylesheets/variables/_grid.scss',
               "#{stylesheets_dir}/variables/_grid.scss"
      template 'stylesheets/variables/_layout.scss',
               "#{stylesheets_dir}/variables/_layout.scss"
      template 'stylesheets/variables/_spacing.scss',
               "#{stylesheets_dir}/variables/_spacing.scss"
      template 'stylesheets/variables/_text.scss',
               "#{stylesheets_dir}/variables/_text.scss"
      template 'stylesheets/variables/_theme.scss',
               "#{stylesheets_dir}/variables/_theme.scss"
      template 'stylesheets/theme/theme.scss',
               "#{stylesheets_dir}/theme/theme.scss"
      template 'stylesheets/theme/_custom.scss',
               "#{stylesheets_dir}/theme/_custom.scss"
    end
470486
function(stylesheet, refresh){
		if( icons && !refresh ){
			return icons;
		}

		icons = {};

		// get grunticon stylesheet by its href
		var svgss,
			rules, cssText,
			iconClass, iconSVGEncoded, iconSVGRaw;

		svgss = stylesheet.sheet;

		if( !svgss ){ return icons; }

		rules = svgss.cssRules ? svgss.cssRules : svgss.rules;
		for( var i = 0; i < rules.length; i++ ){
			cssText = rules[ i ].cssText;
			iconClass = selectorPlaceholder + rules[ i ].selectorText;
			iconSVGEncoded = cssText.split( ");" )[ 0 ].match( /US\-ASCII\,([^"']+)/ );
			if( iconSVGEncoded && iconSVGEncoded[ 1 ] ){
				iconSVGRaw = decodeURIComponent( iconSVGEncoded[ 1 ] );
				icons[ iconClass ] = iconSVGRaw;

			}
		}
		return icons;
	}
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
}
1363392
function () {
        /**
         * Cache for the supported CSS styles.
         * @type Object
         * @private
         */
        this._styleCache = {};

        /**
         * Cache for properties computed by <em>init</em> for a given user agent.
         * @type Object
         * @private
         */
        this._propertiesCache = {};

        ////////////////////////////////////////////////////////////////////////
        // User agent
        ////////////////////////////////////////////////////////////////////////

        /**
         * The user agent.
         * @type String
         */
        this.ua = "";



        ////////////////////////////////////////////////////////////////////////
        // Browser
        ////////////////////////////////////////////////////////////////////////

        /**
         * Browser name.
         * @type String
         */
        this.name = "";

        /**
         * Browser version.
         * @type String
         */
        this.version = "";

        /**
         * Browser major version.
         * @type Integer
         */
        this.majorVersion = 0;

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        /**
         * <b>Deprecated, use <em>aria.core.Browser.name instead</em>.</b>
         *
         * <p>
         * Browser name.
         * </p>
         *
         * @type String
         * @deprecated use aria.core.Browser.name instead
         */
        this.browserType = "";

        /**
         * <b>Deprecated, use <em>aria.core.Browser.version instead</em>.</b>
         *
         * <p>
         * Browser version.
         * </p>
         *
         * @type String
         * @deprecated use aria.core.Browser.version instead
         */
        this.browserVersion = "";
         */

        /**
         * <em>true</em> if the browser is any version of Internet Explorer.
         * @type Boolean
         */
        this.isIE = false;

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        /**
         * <b>Deprecated, <em>isIE6</em> is not supported anymore.</b>
         *
         * <em>true</em> if the browser is Internet Explorer 6.
         *
         * @type Boolean
         * @deprecated isIE6 is not supported anymore
         */
        this.isIE6 = false;
         */

        /**
         * <em>true</em> if the browser is Internet Explorer 7.
         * @type Boolean
         */
        this.isIE7 = false;

        /**
         * <em>true</em> if the browser is Internet Explorer 8.
         * @type Boolean
         */
        this.isIE8 = false;

        /**
         * <em>true</em> if the browser is Internet Explorer 9.
         * @type Boolean
         */
        this.isIE9 = false;

        /**
         * <em>true</em> if the browser is Internet Explorer 10.
         * @type Boolean
         */
        this.isIE10 = false;

        /**
         * <em>true</em> if the browser is Internet Explorer 11.
         * @type Boolean
         */
        this.isIE11 = false;

        /**
         * <em>true</em> if the browser is Internet Explorer 10 or less.
         * @type Boolean
         */
        this.isOldIE = false;

        /**
         * <em>true</em> if the browser is Internet Explorer 11 or more.
         * @type Boolean
         */
        this.isModernIE = false;

        /**
         * <em>true</em> if the browser is any version of Firefox.
         * Some reference: http://hacks.mozilla.org/2010/09/final-user-agent-string-for-firefox-4/
         * @type Boolean
         */
        this.isFirefox = false;

        /**
         * <em>true</em> if the browser is any version of Microsoft Edge.
         * Some reference: https://msdn.microsoft.com/en-us/library/hh869301%28v=vs.85%29.aspx#edge
         * @type Boolean
         */
        this.isEdge = false;

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        /**
         * <b>Deprecated, use <em>aria.core.Browser.isFirefox instead</em>.</b>
         *
         * <p>
         * <em>true</em> if the browser is any version of Firefox.
         * </p>
         *
         * @type Boolean
         * @deprecated use aria.core.Browser.isFirefox instead
         */
        this.isFF = false;
         */

        /**
         * <em>true</em> if the browser is any version of Chrome.
         * @type Boolean
         */
        this.isChrome = false;

        /**
         * <em>true</em> if the browser is any version of Safari.
         * @type Boolean
         */
        this.isSafari = false;

        /**
         * <em>true</em> if the browser is any version of Opera.
         * @type Boolean
         */
        this.isOpera = false;

        /**
         * <em>true</em> if the browser is any version of BlackBerry.
         * @type Boolean
         */
        this.isBlackBerryBrowser = false;

        /**
         * <em>true</em> if the browser is any version of Android.
         * @type Boolean
         */
        this.isAndroidBrowser = false;

        /**
         * <em>true</em> if the browser is any version of Safari Mobile.
         * @type Boolean
         */
        this.isSafariMobile = false;

        /**
         * <em>true</em> if the browser is any version of IE Mobile.
         * @type Boolean
         */
        this.isIEMobile = false;

        /**
         * <em>true</em> if the browser is any version of Opera Mobile.
         * @type Boolean
         */
        this.isOperaMobile = false;

        /**
         * <em>true</em> if the browser is any version of Opera Mini.
         * @type Boolean
         */
        this.isOperaMini = false;

        /**
         * <em>true</em> if the browser is any version of S60.
         * @type Boolean
         */
        this.isS60 = false;

        /**
         * <em>true</em> if the browser is any version of PhantomJS.
         * @type Boolean
         */
        this.isPhantomJS = false;

        /**
         * <em>true</em> if browser is not a known one.
         * @type Boolean
         */
        this.isOtherBrowser = false;



        ////////////////////////////////////////////////////////////////////////
        // Rendering engine
        ////////////////////////////////////////////////////////////////////////

        /**
         * <em>true</em> if the rendering engine is Webkit.
         * @type Boolean
         */
        this.isWebkit = false;

        /**
         * <em>true</em> if the rendering engine is Gecko.
         * @type Boolean
         */
        this.isGecko = false;



        ////////////////////////////////////////////////////////////////////////
        // OS
        ////////////////////////////////////////////////////////////////////////

        /**
         * Name of the operating system on which the browser runs.
         * @type String
         */
        this.osName = "";

        /**
         * Version of the operating system on which the browser runs.
         * @type String
         */
        this.osVersion = "";

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        /**
         * <b>Deprecated, use <em>aria.core.Browser.osName instead</em>.</b>
         *
         * <p>
         * MacOS or Windows.
         * </p>
         *
         * @type String
         * @deprecated use aria.core.Browser.osName instead
         */
        this.environment = "";
         */

        /**
         * <em>true</em> if the operating system is Windows.
         * @type Boolean
         */
        this.isWindows = false;

        /**
         * <em>true</em> if the operating system is Mac OS.
         * @type Boolean
         */
        this.isMac = false;

        /**
         * <em>true</em> if operating system is iOS.
         * @type Boolean
         */
        this.isIOS = false;

        /**
         * <em>true</em> if operating system is Android.
         * @type Boolean
         */
        this.isAndroid = false;

        /**
         * <em>true</em> if operating system is Windows.
         * @type Boolean
         */
        this.isWindowsPhone = false;

        /**
         * <em>true</em> if operating system is BlackBerry.
         * @type Boolean
         */
        this.isBlackBerry = false;

        /**
         * <em>true</em> if operating system is Symbian.
         * @type Boolean
         */
        this.isSymbian = false;

        /**
         * <em>true</em> if operating system is not a known one.
         * @type Boolean
         */
        this.isOtherOS = false;

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        /**
         * <b>Deprecated, use <em>aria.core.Browser.isOtherOS instead</em>.</b>
         *
         * <p>
         * <em>true</em> if operating system is not a known one.
         * </p>
         *
         * @type Boolean
         * @deprecated use aria.core.Browser.isOtherOS instead
         */
        this.isOtherMobile = false;
         */



        ////////////////////////////////////////////////////////////////////////
        // Mobile browser specific properties
        //
        // Only for Window Phone with IE+9
        ////////////////////////////////////////////////////////////////////////

        // Only for Window Phone with IE+9
        /**
         * <em>true</em> if view type is Mobile.
         * @type Boolean
         */
        this.isMobileView = false;

        /**
         * <em>true</em> if view type is Desktop.
         * @type Boolean
         */
        this.isDesktopView = false;

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        /**
         * <b>Deprecated, use <em>aria.core.Browser.isDesktopView instead</em>.</b>
         *
         * <p>
         * <em>true</em> if view type is Desktop.
         * </p>
         *
         * @type Boolean
         * @deprecated use aria.core.Browser.isDesktopView instead
         */
        this.DesktopView = false;
         */



        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        ////////////////////////////////////////////////////////////////////////
        // Device properties
        ////////////////////////////////////////////////////////////////////////

        // For Mobile Browsers
        /**
         * <b>Deprecated, use <em>aria.utils.Device.isPhone instead</em>.</b>
         *
         * <p>
         * <em>true</em> if the device is of type phone.
         * </p>
         *
         * @type Boolean
         * @deprecated use aria.utils.Device.isPhone instead
         */
        this.isPhone = false;

        /**
         * <b>Deprecated, use <em>aria.utils.Device.isTablet instead</em>.</b>
         *
         * <p>
         * <em>true</em> if the device is of type tablet.
         * </p>
         *
         * @type Boolean
         * @deprecated use aria.utils.Device.isTablet instead
         */
        this.isTablet = false;

        /**
         * <b>Deprecated, use <em>aria.utils.Device.deviceName instead</em>.</b>
         *
         * <p>
         * Name of the device, combining the vendor and the model.
         * </p>
         *
         * @type String
         * @deprecated use aria.utils.Device.deviceName instead
         */
        this.deviceName = "";
         */



        ////////////////////////////////////////////////////////////////////////
        // Initialization
        ////////////////////////////////////////////////////////////////////////

        /* BACKWARD-COMPATIBILITY-BEGIN (GitHub #1397) */
        var properties = [
            "isIE6",
            "environment",
            {
                name: "isFF",
                synonym: "isFirefox"
            },
            {
                name: "browserType",
                synonym: "name"
            },
            {
                name: "browserVersion",
                synonym: "version"
            },

            {
                name: "isOtherMobile",
                synonym: "isOtherOS"
            },

            {
                name: "DesktopView",
                synonym: "isDesktopView"
            },

            {
                name: "isPhone",
                alternative: "aria.utils.Device.isPhone"
            },
            {
                name: "isTablet",
                alternative: "aria.utils.Device.isTablet"
            },
            {
                name: "deviceName",
                alternative: "aria.utils.Device.deviceName"
            },
            {
                name: "toString",
                type: "method"
            }
        ];

        var deprecatedProperties = [];
        var isString = ariaUtilsType.isString;
        ariaUtilsArray.forEach(properties, function(property) {
            // ------------------------------------------------ property factory

            if (isString(property)) {
                property = {name: property};
            }

            // ------------------------------------------------------------ name

            var name = property.name;

            // ------------------------------------------------------------ type

            var type = property.type;

            if (type == null) {
                type = "attribute";
            }

            property.type = type;

            // ----------------------------------------------- underlying method

            if (type == "method") {
                var underlyingContainer = this;
                var underlyingName = name;
                var underlying = underlyingContainer[underlyingName];

                property.underlying = underlying;
            }

            // --------------------------------------------------------- synonym

            var possibleAlternative;

            var synonym = property.synonym;

            possibleAlternative = synonym;

            // ----------------------------------------------------- alternative

            var alternative = property.alternative;

            if (alternative == null && possibleAlternative != null) {
                alternative = possibleAlternative;
            }

            property.alternative = alternative;

            // --------------------------------------------------- extrapolation

            var loggingMessage;
            var loggingMessageArguments = [name];

            if (alternative != null) {
                loggingMessage = type == "attribute" ? "DEPRECATED_REPLACED_PROPERTY" : "DEPRECATED_REPLACED_METHOD";
                loggingMessageArguments.push(alternative);
            } else {
                loggingMessage = type == "attribute" ? "DEPRECATED_REMOVED_PROPERTY" : "DEPRECATED_REMOVED_METHOD";
            }

            property.loggingMessage = this[loggingMessage];
            property.loggingMessageArguments = loggingMessageArguments;

            // ---------------------------------------------------------- result

            deprecatedProperties.push(property);
        }, this);

        this._deprecatedProperties = deprecatedProperties;
        this.__deprecateProperties();
         */

        this.init();
    }
1260622
def import_styles(self, subs, overwrite=True):
        
        if not isinstance(subs, SSAFile):
            raise TypeError("Must supply an SSAFile.")

        for name, style in subs.styles.items():
            if name not in self.styles or overwrite:
                self.styles[name] = style
644175
def reapply_styles
      selected.each do |selected_view|
        selected_view.rmq_data.styles.each do |style_name|
          apply_style_to_view selected_view, style_name
        end
      end
      self
    end
1202345
function copyCss() {
  return gulp.src(['./src/assets/stylesheets/*.css'], {base: './src/assets/stylesheets'})
    .pipe(gulp.dest(function (file) {
      return libraryDist + '/dist/css' + file.base.slice(__dirname.length); // save directly to dist
    }));
}
838113
function style(styles, options = {}) {

	return Class => {

        initCoreMap(storage, Class);
        initStyleMap(storage, Class);

        let map = storage.get(Class);
        let styleMap = map.get('@style');

        // Stylesheets holds the styles (ast) that
        // are passed by the @style decorator
        styleMap.set('stylesheets', styles);

        // referenceNodes holds the current created domNodes (customElements)
        let nodes = styleMap.get('referenceNodes');

        // stylesheetStates holds the event state (event reached or not)
        // of each style-ast in styles object
        let stylesheetStates = styleMap.get('stylesheetStates');

        /**
         * Its required when we use @style multiple times!
         * Only once registration!
         */
        if(map.get('@style').get('callbacksDefined')){
            return;
        }

        let createdAndAttached = domNode => {
            setPath(domNode, '$stylesheets', []);
            // create stylesheet node when no referenceNodes (customelement) exists
            if(!nodes.size) {
                // default state of each style-ast is false (undefined)
                let stylesheetStates = styleMap.get('stylesheetStates');
                createStylesheet(Class, styles, domNode, options, stylesheetStates);
            }
            !nodes.has(domNode) && nodes.set(domNode, domNode);
        };

        map.get('@callbacks').get('created' ).push(createdAndAttached);
        map.get('@callbacks').get('attached').push(createdAndAttached);
        map.get('@callbacks').get('detached').push(domNode => {

            // cleanup
            domNode.$stylesheets.forEach(stylesheet => stylesheet.destroy());

            // remove detached node from referenceNodes
            nodes.has(domNode) && nodes.delete(domNode);

            // not each domNode has $stylesheets, so return when no once found.
            if(!domNode.$stylesheets.length) {
                return null;
            }

            // stylesheetStates (attachOn) are the event state (reached or not reached) of each
            // array object (styles, imports, ...) that are passed by style decorator.
            // The state of an array object is required ...
            // [
            //   {
            //      attachOn: 'load',
            //      type: 'on',
            //      imports: ["a.css", "b.css", "c.css"],
            //      styles: '.baz {color: green;}',
            //   },
            //   {
            //      attachOn: 'immediately',
            //      type: 'lala',
            //      imports: [],
            //      styles: '.laz {color: green;}',
            //   }
            // ]
            stylesheetStates = syncStylesheetStates(domNode.$stylesheets, stylesheetStates) || [];

            // when elements detached from document.body, we need a new node that take the role of $stylesheet
            let node = (nodes.values()).next().value;

            // when node is valid, create fresh stylesheet
            if(node) {
                createStylesheet(Class, styles, node, options, stylesheetStates);
            }

            // save the stylesheetStates
            styleMap.set('stylesheetStates', stylesheetStates);
            //cleanup
            delete domNode.$stylesheets;

        });

        map.get('@style').set('callbacksDefined', true);
	}
}
34206
function(destPath) {

    // Store all the css/js abspaths
    var cssAbspaths = [];
    var jsAbspaths = [];
    grunt.file.recurse(destPath, function(abspath, rootdir, subdir, filename) {
        if (abspath.match(/\.css$/i)) {
            cssAbspaths.push(abspath);
        } else if (abspath.match(/\.js$/i)) {
            jsAbspaths.push(abspath);
        }
    });

    var beginminInfos = applyminGlobal.beginminInfos;
    for (var templateFilename in beginminInfos) {
        var beginminInfo = beginminInfos[templateFilename];
        // Will be used to replace the html template later.
        var replaceContent = {};

        for (var targetFilePath in beginminInfo) {
            var targetUrlPath = beginminInfo[targetFilePath].targetUrlPath;
            var beginEndMinBlock = beginminInfo[targetFilePath].beginEndMinBlock;

            var abspaths = null;
            var isJsOrCss = true; /* true means Js, otherwise means Css. */
            if (targetFilePath.match(/\.css$/i)) {
                abspaths = cssAbspaths;
                isJsOrCss = false;
            } else if (targetFilePath.match(/\.js$/i)) {
                abspaths = jsAbspaths;
            }
            var revTargetFilePath = _getRevTargetFilePath(targetFilePath, abspaths);

            // Fill up replaceContent
            var targetUrlPath = targetUrlPath.replace(new RegExp(targetFilePath, 'i'), revTargetFilePath);
            if (isJsOrCss) {
                targetUrlPath = '<script src="' + targetUrlPath + '"></script>';
            } else {
                targetUrlPath = '<link href="' + targetUrlPath + '" rel="stylesheet" media="screen">';
            }
            replaceContent[targetUrlPath] = beginEndMinBlock;
        }
        var fileContent = grunt.file.read(templateFilename);
        for (var targetUrlPath in replaceContent) {
            var beginEndMinBlock = replaceContent[targetUrlPath];
            while (fileContent.indexOf(beginEndMinBlock) !== -1) { // replace all for string as the first parameter instead of regexp.
                grunt.log.writeln('Change:\n' + beginEndMinBlock);
                fileContent = fileContent.replace(beginEndMinBlock, targetUrlPath);
                grunt.log.writeln('To:\n' + targetUrlPath);
                grunt.log.writeln();
            }
        }
        grunt.file.write(templateFilename, fileContent);
        grunt.log.write('The file named: ' + templateFilename + ' has been changed...').ok();
    }
  }
829069
function fixStyle(style) {
  Object.keys(style.sources).forEach(function (sourceId) {
    style.sources[sourceId] = fixRasterSource(style.sources[sourceId]);
  });
  return style;
}
846523
def generate_stylesheets
      return @contents = Jammit.packager.pack_stylesheets(@package, @variant) unless @variant == :mhtml
      @mtime      = Time.now
      request_url = prefix_url(request.fullpath)
      cached_url  = prefix_url(Jammit.asset_url(@package, @extension, @variant, @mtime))
      css         = Jammit.packager.pack_stylesheets(@package, @variant, request_url)
      @contents   = css.gsub(request_url, cached_url) if perform_caching
      css
    end
367251
function genStyleSection(style, styles, options) {
    if (shouldReplaceCurrentSection(style, styles, options)) {
        replaceWithSpacer(style);
    }

    // Remove the 'id', theme' and 'replace' attributes from the output set of
    // attributes since they're not really valid SFC <style> attributes
    _.set(style, 'attrs', _.omit(style.attrs, 'id', 'theme', 'replace'));

    return genSection('style', style);
}
1220904
def _update_stylesheet(self, widget):
        """"""
        if is_dark_interface():
            css = qdarkstyle.load_stylesheet_from_environment()
            widget.setStyleSheet(css)
            palette = widget.palette()
            background = palette.color(palette.Window).lighter(150).name()
            border = palette.color(palette.Window).lighter(200).name()
            name = widget.__class__.__name__
            widget.setObjectName(name)
            extra_css = '''
                {0}#{0} {{
                    background-color:{1};
                    border: 1px solid {2};
                }}'''.format(name, background, border)
            widget.setStyleSheet(css + extra_css)
202852
def load_stylesheet(self, id, path):
        
        self.add_child(HeadLink(id=id, link_type="stylesheet", path=path))