handle with import procedure,may search involved file in project
@param styles styles css file content
@param initPath project path, used for searching target file
@param mayRM this param avoid loop importing
@returns handled styles content
553402
function handleImportStyle(styles, initPath, mayRM) {
    if (!!mayRM) {
        styles = styles.replace(mayRM, '')
    }
    if (styles.indexOf('@import') < 0) return styles
    const ast = csstree.parse(styles);
    csstree.walk(ast, {
        enter: function (node) {
            if (node.type === 'Atrule') {
                if (node.name === 'import') {
                    const pat = node.prelude.children.head.data.value
                    if (initPath && typeof pat === 'string') {
                        const realP = pat.substring(1, pat.length - 1)
                        const newPath = path.dirname(initPath)
                        const resPath = path.resolve(newPath, realP)
                        const text = fs.readFileSync(resPath).toString()
                        const re = new RegExp("[\\s]*@import[\\s]+\"" + realP + "\";", "g");
                        //handle with loop import
                        styles = styles.replace(re, handleImportStyle(text, resPath, re))
                    }
                }
            }
        }
    })
    return styles
}
1004368
public static String convertToUnixStylePath(String path) {
		String retval = StringSupport.replaceAll(path, "\\", "/");
		retval = StringSupport.replaceAll(retval, new String[]{"///", "//"}, new String[]{"/", "/"});
		return retval;
	}
606969
@Override
	protected String postcss(HttpServletRequest request, String css, IResource resource) throws IOException {
		final String sourceMethod = "postcss"; //$NON-NLS-1$
		final boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(sourceClass, sourceMethod, new Object[]{css, resource});
		}
		if (resource.getPath().toLowerCase().endsWith(LESS_SUFFIX)) {
			css = processLess(resource.getReferenceURI().toString(), css);
			if (inlineImports) {
				css = _inlineImports(request, css, resource, ""); //$NON-NLS-1$
			}
		}
		css = super.postcss(request, css, resource);

		if (isTraceLogging) {
			log.exiting(sourceMethod, sourceMethod, css);
		}
		return css;
	}
372158
public static Image newImage (String path, String... styles)
    {
        return setStyleNames(new Image(path), styles);
    }
1135029
@SuppressWarnings("unchecked")
    public <T extends XPathBuilder> T setStyle(final String style) {
        this.style = style;
        return (T) this;
    }
964516
function createStylefromCode(styles, abspath) {
    //may import other file
    const arr = queryImport(styles)
    const baseRes = handleImportStyle(styles, abspath)
    const obj = {}
    const ast = csstree.parse(baseRes);
    csstree.walk(ast, {
        enter: function (node) {
            if (node.type === 'Rule' && node.prelude && node.prelude.type === 'SelectorList') {
                const clzName = []
                node.prelude.children.forEach(e => {
                    //we may handle each class selector here
                    let ans = selectorBlockHandler(e)
                    if (ans) {
                        //to save before value
                        obj[ans] = obj[ans] || {}
                        //save ans to log which to give value
                        clzName.push(ans)
                    }
                })
                const styleArray = []
                node.block.children.forEach(e => {
                    //handle with unit or function case
                    const styleItem = styleBlockHandler(e)
                    styleItem.length > 0 && styleArray.push(styleItem)
                })
                clzName.forEach(e => {
                    try {
                        const styleObject = transform(styleArray)
                        if (styleObject.fontWeight) {
                            //fontWeight must be string
                            styleObject.fontWeight = styleObject.fontWeight + ""
                        }
                        Object.assign(obj[e], styleObject)
                    } catch (e) {
                        console.error("convert ", abspath, " error:", e.message)
                    }

                })
            }
        },
    })
    return {styles: obj, imports: arr}
}
369118
public final Optional<? extends Style> getStyle(final String styleName) {
        final String styleRef = this.styles.get(styleName);
        if (styleRef != null) {
            return this.styleParser.loadStyle(this, this.clientHttpRequestFactory, styleRef);
        } else {
            return Optional.empty();
        }


    }
359121
public DynamicReportBuilder addStyle(Style style) throws DJBuilderException {
        if (style.getName() == null) {
            throw new DJBuilderException("Invalid style. The style must have a name");
        }

        report.addStyle(style);

        return this;
    }
864815
private void init(Context context, AttributeSet attrs, int defStyle) {
		// Initialize paint objects
		paint = new Paint();
		paint.setAntiAlias(true);
		paintBorder = new Paint();
		paintBorder.setAntiAlias(true);
		paintBorder.setStyle(Paint.Style.STROKE);
		paintSelectorBorder = new Paint();
		paintSelectorBorder.setAntiAlias(true);

		// Enable software rendering on HoneyComb and up. (needed for shadow)
		if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
			setLayerType(LAYER_TYPE_SOFTWARE, null);

		// Load the styled attributes and set their properties
		TypedArray attributes = context.obtainStyledAttributes(attrs, R.styleable.CircularImageView, defStyle, 0);

		// Check for extra features being enabled
		hasBorder = attributes.getBoolean(R.styleable.CircularImageView_civ_border, false);
		hasSelector = attributes.getBoolean(R.styleable.CircularImageView_civ_selector, false);
		shadowEnabled = attributes.getBoolean(R.styleable.CircularImageView_civ_shadow, SHADOW_ENABLED);

		// Set border properties, if enabled
		if(hasBorder) {
			int defaultBorderSize = (int) (2 * context.getResources().getDisplayMetrics().density + 0.5f);
			setBorderWidth(attributes.getDimensionPixelOffset(R.styleable.CircularImageView_civ_borderWidth, defaultBorderSize));
			setBorderColor(attributes.getColor(R.styleable.CircularImageView_civ_borderColor, Color.WHITE));
		}

		// Set selector properties, if enabled
		if(hasSelector) {
			int defaultSelectorSize = (int) (2 * context.getResources().getDisplayMetrics().density + 0.5f);
			setSelectorColor(attributes.getColor(R.styleable.CircularImageView_civ_selectorColor, Color.TRANSPARENT));
			setSelectorStrokeWidth(attributes.getDimensionPixelOffset(R.styleable.CircularImageView_civ_selectorStrokeWidth, defaultSelectorSize));
			setSelectorStrokeColor(attributes.getColor(R.styleable.CircularImageView_civ_selectorStrokeColor, Color.BLUE));
		}

		// Set shadow properties, if enabled
		if(shadowEnabled) {
			shadowRadius = attributes.getFloat(R.styleable.CircularImageView_civ_shadowRadius, SHADOW_RADIUS);
			shadowDx = attributes.getFloat(R.styleable.CircularImageView_civ_shadowDx, SHADOW_DX);
			shadowDy = attributes.getFloat(R.styleable.CircularImageView_civ_shadowDy, SHADOW_DY);
			shadowColor = attributes.getColor(R.styleable.CircularImageView_civ_shadowColor, SHADOW_COLOR);
			setShadowEnabled(true);
		}

		// We no longer need our attributes TypedArray, give it back to cache
		attributes.recycle();
	}
1073159
protected void handleImportStyle(final String uri, final MediaQueryList media,
            final String defaultNamespaceURI, final Locator locator) {
        getDocumentHandler().importStyle(uri, media, defaultNamespaceURI, locator);
    }
754117
static String pullFontPathFromTheme(Context context, int styleAttrId, int[] attributeId) {
        if (styleAttrId == -1 || attributeId == null)
            return null;

        final Resources.Theme theme = context.getTheme();
        final TypedValue value = new TypedValue();

        theme.resolveAttribute(styleAttrId, value, true);
        final TypedArray typedArray = theme.obtainStyledAttributes(value.resourceId, attributeId);
        try {
            String font = typedArray.getString(0);
            return font;
        } catch (Exception ignore) {
            // Failed for some reason.
            return null;
        } finally {
            typedArray.recycle();
        }
    }
625875
public void setParamTabExWorkplaceSearchResult(String style) {

        if (style == null) {
            style = OpenCms.getWorkplaceManager().getDefaultUserSettings().getWorkplaceSearchViewStyle().getMode();
        }
        m_userSettings.setWorkplaceSearchViewStyle(CmsSearchResultStyle.valueOf(style));
    }
975790
private void checkResourcePath(String path, String fullPath) {

		if (!pathsChecked.contains(path)) {

			pathsChecked.add(path);

			if (checkResourcePathForInfo) {

				String pathToCheck = fullPath.substring(WEBJARS_RESOURCE_PREFIX.length());
				if (path.equals(pathToCheck) || (URL_SEPARATOR + path).equals(pathToCheck)) {
					if (LOGGER.isInfoEnabled()) {

						Matcher matcher = WEBJARS_PREFIX_PATTERN.matcher(fullPath);
						String useCorrectPathMsg = "";
						if (matcher.find()) {
							String shortPath = fullPath.substring(matcher.group().length());
							useCorrectPathMsg = "In your case, you should reference the resource '"
									+ GeneratorRegistry.WEBJARS_GENERATOR_PREFIX + GeneratorRegistry.PREFIX_SEPARATOR
									+ path + "' by '" + GeneratorRegistry.WEBJARS_GENERATOR_PREFIX
									+ GeneratorRegistry.PREFIX_SEPARATOR + shortPath + "'";
						}

						LOGGER.info("\nThe resource '" + GeneratorRegistry.WEBJARS_GENERATOR_PREFIX
								+ GeneratorRegistry.PREFIX_SEPARATOR + path
								+ "' is referenced with it's version number. If you change the version of your webjars package, you'll need to update your mapping.\n"
								+ "A better way to reference your resource is to avoid using the version number reference.\n"
								+ useCorrectPathMsg);

					}
				}

			}

			if (checkResourcePathForWarning) {

				Matcher matcher = WEBJARS_PREFIX_PATTERN.matcher(fullPath);
				if (matcher.find()) {
					String shortPath = fullPath.substring(matcher.group().length());
					if (!path.equals(shortPath)) {
						if (LOGGER.isWarnEnabled()) {
							LOGGER.warn("\nThe reference to the CSS resource '" + path + "' could lead to issues "
									+ "in binary resources (image, fonts, ...) mappings for the generated CSS resource.\n"
									+ "Please update your bundle mapping to use webjars reference path which start after the version number.\n"
									+ "In your case, you should reference the resource '"
									+ GeneratorRegistry.WEBJARS_GENERATOR_PREFIX + GeneratorRegistry.PREFIX_SEPARATOR
									+ path + "' by '" + GeneratorRegistry.WEBJARS_GENERATOR_PREFIX
									+ GeneratorRegistry.PREFIX_SEPARATOR + shortPath + "'");

						}
					}
				}
			}
		}

	}
219847
public static boolean containsStyle(final String styleNames,
                                        final String style) {
        if (styleNames == null || style == null) {
            return false;
        }

        final String[] styles = styleNames.split("\\s");

        for (final String s : styles) {
            if (style.equals(s)) {
                return true;
            }
        }

        return false;
    }
950540
function devHandler(curPath, importPath, jsFilename) {
    var absPath = resolve(importPath, jsFilename)

    var projectDir = path.resolve(require.resolve('./index.js'), '..', '..', '..', '..', '..')

    absPath = absPath.replace(projectDir, '@areslabs/babel-plugin-import-css/rncsscache')
    curPath.node.source.value = (absPath + '.js')
}
803620
@Override
	public InputSource resolveStylesheet(String identifier, ScssStylesheet parentStylesheet) {

		return resolver.resolve(parentStylesheet, identifier);
	}
1052646
@Override
	protected String inlineImports(HttpServletRequest req, String css, IResource res, String path)
			throws IOException {
		/*
		 * For the LESS builder, we want the LESS compiler to process &#64imports so that variable
		 * substitution in import names can take place.  We override this method and do nothing because
		 * the CSS module builder calls it before the LESS compiler runs.  Instead, we inline imports
		 * that weren't processed by the LESS compiler (i.e. CSS imports) after compiling by calling
		 * _inlineImports().
		 */
		if (!res.getPath().toLowerCase().endsWith(LESS_SUFFIX)) {
			css = super.inlineImports(req, css, res, path);
		}
		return css;
	}