itextpdf-master/xmlworker/src/main/java/com/itextpdf/tool/xml/css/CssUtils.java
/*
 *
 * This file is part of the iText (R) project.
    Copyright (c) 1998-2022 iText Group NV
 * Authors: Balder Van Camp, Emiel Ackermann, et al.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License version 3
 * as published by the Free Software Foundation with the addition of the
 * following permission added to Section 15 as permitted in Section 7(a):
 * FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
 * ITEXT GROUP. ITEXT GROUP DISCLAIMS THE WARRANTY OF NON INFRINGEMENT
 * OF THIRD PARTY RIGHTS
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 * You should have received a copy of the GNU Affero General Public License
 * along with this program; if not, see http://www.gnu.org/licenses or write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA, 02110-1301 USA, or download the license from the following URL:
 * http://itextpdf.com/terms-of-use/
 *
 * The interactive user interfaces in modified source and object code versions
 * of this program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU Affero General Public License.
 *
 * In accordance with Section 7(b) of the GNU Affero General Public License,
 * a covered work must retain the producer line in every PDF that is created
 * or manipulated using iText.
 *
 * You can be released from the requirements of the license by purchasing
 * a commercial license. Buying such a license is mandatory as soon as you
 * develop commercial activities involving the iText software without
 * disclosing the source code of your own applications.
 * These activities include: offering paid services to customers as an ASP,
 * serving PDFs on the fly in a web application, shipping iText with a closed
 * source product.
 *
 * For more information, please contact iText Software Corp. at this
 * address: sales@itextpdf.com
 */
package com.itextpdf.tool.xml.css;

import com.itextpdf.text.html.HtmlTags;
import com.itextpdf.text.html.WebColors;
import com.itextpdf.tool.xml.Tag;
import com.itextpdf.tool.xml.css.apply.MarginMemory;
import com.itextpdf.tool.xml.exceptions.NoDataException;

import java.text.MessageFormat;
import java.util.*;

/**
 * @author redlab_b
 *
 */
public class CssUtils {

	private static final String COLOR = "-color";
	private static final String STYLE = "-style";
	private static final String WIDTH = "-width";
	private static final String BORDER2 = "border-";
	private static final String _0_LEFT_1 = "{0}left{1}";
	private static final String _0_RIGHT_1 = "{0}right{1}";
	private static final String _0_BOTTOM_1 = "{0}bottom{1}";
	private static final String _0_TOP_1 = "{0}top{1}";
	private static CssUtils instance = new CssUtils();

	/**
	 * Default font size if none is set.
	 */
	public static final int DEFAULT_FONT_SIZE_PT = 12;


	/**
	 * @return Singleton instance of CssUtils.
	 */
	public static CssUtils getInstance() {
		return instance;
	}

	/**
	 *
	 */
	private CssUtils() {
	}
	/**
	 * Returns the top, bottom, left, right version for the given box. the keys
	 * will be the pre value concatenated with either top, bottom, right or left
	 * and the post value. <strong>Note:</strong> Does not work when double
	 * spaces are in the boxes value. (<strong>Tip:</strong> Use
	 * {@link CssUtils#stripDoubleSpacesAndTrim(String)})
	 *
	 * @param box
	 *            the value to parse
	 * @param pre
	 *            the pre key part
	 * @param post
	 *            the post key part
	 * @return a map with the parsed properties
	 */
    public Map<String, String> parseBoxValues(final java.lang.String box,
                                             final java.lang.String pre, final java.lang.String post) {

        return parseBoxValues(box, pre, post, null);
    }
    public Map<String, String> parseBoxValues(final String box,
                                              final String pre, final String post, String preKey) {
		String[] props = box.split(" ");
		int length = props.length;
		Map<String, String> map = new LinkedHashMap<String, String>(4);
		if (length == 1) {
			String value = props[0];
            if (preKey == null) {
                map.put(MessageFormat.format(_0_TOP_1, pre, post), value);
                map.put(MessageFormat.format(_0_BOTTOM_1, pre, post), value);
                map.put(MessageFormat.format(_0_RIGHT_1, pre, post), value);
                map.put(MessageFormat.format(_0_LEFT_1, pre, post), value);
            } else {
                map.put(MessageFormat.format(preKey + "{0}", post), value);
            }
		} else if (length == 2) {
            if (preKey == null) {
                map.put(MessageFormat.format(_0_TOP_1, pre, post), props[0]);
                map.put(MessageFormat.format(_0_BOTTOM_1, pre, post), props[0]);
                map.put(MessageFormat.format(_0_RIGHT_1, pre, post), props[1]);
                map.put(MessageFormat.format(_0_LEFT_1, pre, post), props[1]);
            } else {
                map.put(MessageFormat.format(preKey + "{0}", post), props[0]);
            }
		} else if (length == 3) {
            if (preKey == null) {
                map.put(MessageFormat.format(_0_TOP_1, pre, post), props[0]);
                map.put(MessageFormat.format(_0_BOTTOM_1, pre, post), props[2]);
                map.put(MessageFormat.format(_0_RIGHT_1, pre, post), props[1]);
                map.put(MessageFormat.format(_0_LEFT_1, pre, post), props[1]);
            } else {
                map.put(MessageFormat.format(preKey + "{0}", post), props[0]);
            }
		} else if (length == 4) {
            if (preKey == null) {
                map.put(MessageFormat.format(_0_TOP_1, pre, post), props[0]);
                map.put(MessageFormat.format(_0_BOTTOM_1, pre, post), props[2]);
                map.put(MessageFormat.format(_0_RIGHT_1, pre, post), props[1]);
                map.put(MessageFormat.format(_0_LEFT_1, pre, post), props[3]);
            } else {
                map.put(MessageFormat.format(preKey + "{0}", post), props[0]);
            }
		}
		return map;
	}

	private static final Set<String> borderwidth = new HashSet<String>(
			Arrays.asList(new String[] { CSS.Value.THIN, CSS.Value.MEDIUM, CSS.Value.THICK })); //  thin = 1px, medium = 3px, thick = 5px
	private static final Set<String> borderstyle = new HashSet<String>(
			Arrays.asList(new String[] { CSS.Value.NONE, CSS.Value.HIDDEN, CSS.Value.DOTTED, CSS.Value.DASHED, CSS.Value.SOLID, CSS.Value.DOUBLE, CSS.Value.GROOVE, CSS.Value.RIDGE, CSS.Value.INSET, CSS.Value.OUTSET}));
	/**
	 * @param border
	 *            the border property
	 * @return a map of the border property parsed to each property (width,
	 *         style, color).
	 */
    public Map<String, String> parseBorder(final String border) {
        return parseBorder(border, null);
    }
	public Map<String, String> parseBorder(final String border, final String borderKey) {
		HashMap<String, String> map = new HashMap<String, String>(0);
		String split[] = splitComplexCssStyle(border);
		int length = split.length;
		if (length == 1) {
			if (borderwidth.contains(split[0]) || isNumericValue(split[0]) || isMetricValue(split[0])) {
				map.putAll(parseBoxValues(split[0], BORDER2, WIDTH, borderKey));
			} else {
				map.putAll(parseBoxValues(split[0], BORDER2, STYLE, borderKey));
			}
		} else {
			for(int i = 0 ; i<length ; i++) {
				String value = split[i];
				if (borderwidth.contains(value) || isNumericValue(value) || isMetricValue(value)) {
					map.putAll(parseBoxValues(value, BORDER2, WIDTH, borderKey));
				} else if(borderstyle.contains(value)){
					map.putAll(parseBoxValues(value, BORDER2, STYLE, borderKey));
				} else if(value.contains("rgb(") || value.contains("#") || WebColors.NAMES.containsKey(value.toLowerCase())){
					map.putAll(parseBoxValues(value, BORDER2, COLOR, borderKey));
				}
			}
		}
		return map;
	}

	/**
	 * Trims and Strips double spaces from the given string.
	 *
	 * @param str
	 *            the string to strip
	 * @return the string without double spaces
	 */
	public String stripDoubleSpacesAndTrim(final String str) {
		char[] charArray = str.toCharArray();
		if (str.contains("  ")) {
			StringBuilder builder = new StringBuilder();
			for (int i = 0; i < charArray.length; i++) {
				char c = charArray[i];
				if (c != ' ') {
					builder.append(c);
				} else {
					if (i + 1 < charArray.length && charArray[i + 1] != ' ') {
						builder.append(' ');
					}
				}
			}
			return builder.toString().trim();
		} else {
			return String.valueOf(charArray).trim();
		}
	}

    public String stripDoubleSpacesTrimAndToLowerCase(final String str) {
        return stripDoubleSpacesAndTrim(str).toLowerCase();
    }

	private static final Set<String> backgroundPositions = new HashSet<String>(
			Arrays.asList(new String[] { CSS.Value.LEFT, CSS.Value.CENTER, CSS.Value.BOTTOM, CSS.Value.TOP, CSS.Value.RIGHT }));

	/**
	 * Preparation before implementing the background style in iText. Splits the
	 * given background style and its attributes into background-color,
	 * background-image, background-repeat, background-attachment,
	 * background-position and css styles.
	 *
	 * @param background
	 *            the string containing the font style value.
	 * @return a map with the values of font parsed into each css property.
	 */
	public Map<String, String> processBackground(final String background) {
		Map<String, String> rules = new HashMap<String, String>();
		String[] styles = splitComplexCssStyle(background);
		for(String style : styles) {
			if (style.contains("url(")) {
				rules.put(CSS.Property.BACKGROUND_IMAGE, style);
			} else if (style.equalsIgnoreCase(CSS.Value.REPEAT)
					|| style.equalsIgnoreCase(CSS.Value.NO_REPEAT)
					|| style.equalsIgnoreCase(CSS.Value.REPEAT_X)
					|| style.equalsIgnoreCase(CSS.Value.REPEAT_Y)) {
				rules.put(CSS.Property.BACKGROUND_REPEAT, style);
			} else if (style.equalsIgnoreCase(CSS.Value.FIXED) || style.equalsIgnoreCase(CSS.Value.SCROLL)) {
				rules.put(CSS.Property.BACKGROUND_ATTACHMENT, style);
			} else if (backgroundPositions.contains(style)) {
				if(rules.get(CSS.Property.BACKGROUND_POSITION) == null) {
					rules.put(CSS.Property.BACKGROUND_POSITION, style);
				} else {
					style = style.concat(" "+rules.get(CSS.Property.BACKGROUND_POSITION));
					rules.put(CSS.Property.BACKGROUND_POSITION, style);
				}
			} else if (isNumericValue(style) || isMetricValue(style) || isRelativeValue(style)) {
				if(rules.get(CSS.Property.BACKGROUND_POSITION) == null) {
					rules.put(CSS.Property.BACKGROUND_POSITION, style);
				} else {
					style = style.concat(" "+rules.get(CSS.Property.BACKGROUND_POSITION));
					rules.put(CSS.Property.BACKGROUND_POSITION, style);
				}
			} else if(style.contains("rgb(") || style.contains("rgba(")  || style.contains("#") || WebColors.NAMES.containsKey(style.toLowerCase())) {
				rules.put(CSS.Property.BACKGROUND_COLOR, style);
			}
		}
		return rules;
	}
	/**
	 * Preparation before implementing the list style in iText. Splits the given
	 * list style and its attributes into list-style-type, list-style-position and list-style-image.
	 *
	 * @param listStyle the string containing the list style value.
	 * @return a map with the values of the parsed list style into each css property.
	 */
	public Map<String, String> processListStyle(final String listStyle) {
		Map<String, String> rules = new HashMap<String, String>();
		String[] styles = splitComplexCssStyle(listStyle);
		for(String style : styles) {
			if (style.equalsIgnoreCase(CSS.Value.DISC)
					|| style.equalsIgnoreCase(CSS.Value.SQUARE)
					|| style.equalsIgnoreCase(CSS.Value.CIRCLE)
					|| style.equalsIgnoreCase(CSS.Value.LOWER_ROMAN)
					|| style.equalsIgnoreCase(CSS.Value.UPPER_ROMAN)
					|| style.equalsIgnoreCase(CSS.Value.LOWER_GREEK)
					|| style.equalsIgnoreCase(CSS.Value.UPPER_GREEK)
					|| style.equalsIgnoreCase(CSS.Value.LOWER_ALPHA)
					|| style.equalsIgnoreCase(CSS.Value.UPPER_ALPHA)
					|| style.equalsIgnoreCase(CSS.Value.LOWER_LATIN)
					|| style.equalsIgnoreCase(CSS.Value.UPPER_LATIN)) {
				rules.put(CSS.Property.LIST_STYLE_TYPE, style);
			} else if (style.equalsIgnoreCase(CSS.Value.INSIDE) || style.equalsIgnoreCase(CSS.Value.OUTSIDE)) {
				rules.put(CSS.Property.LIST_STYLE_POSITION, style);
			} else if (style.contains("url(")) {
				rules.put(CSS.Property.LIST_STYLE_IMAGE, style);
			}
		}
		return rules;
	}
	/**
	 * Preparation before implementing the font style in iText. Splits the given
	 * font style and its attributes into font-size, line-height,
	 * font-weight, font-style, font-variant and font-family css styles.
	 *
	 * @param font the string containing the font style value.
	 * @return a map with the values of the parsed font into each css property.
	 */
	public Map<String, String> processFont(final String font) {
		Map<String, String> rules = new HashMap<String, String>();
		String[] styleAndRest = font.split("\\s");

		for (int i = 0 ; i < styleAndRest.length ; i++){
			String style = styleAndRest[i];
			if (style.equalsIgnoreCase(HtmlTags.ITALIC) || style.equalsIgnoreCase(HtmlTags.OBLIQUE)) {
				rules.put(HtmlTags.FONTSTYLE, style);
			} else if (style.equalsIgnoreCase("small-caps")){
				rules.put("font-variant", style);
			} else if (style.equalsIgnoreCase(HtmlTags.BOLD)){
				rules.put(HtmlTags.FONTWEIGHT, style);
			} else if (isMetricValue(style) || isNumericValue(style)){
				if (style.contains("/")) {
					String[] sizeAndLineHeight = style.split("/");
					style = sizeAndLineHeight[0]; // assuming font-size always is the first parameter
					rules.put(HtmlTags.LINEHEIGHT, sizeAndLineHeight[1]);
				}
				rules.put(HtmlTags.FONTSIZE, style);
				if (i != styleAndRest.length-1){
					String rest = styleAndRest[i+1];
					rest = rest.replaceAll("\"", "");
					rest = rest.replaceAll("'", "");
					rules.put(HtmlTags.FONTFAMILY, rest);
				}
			}
		}

		return rules;
	}

	/**
	 * Use only if value of style is a metric value ({@link CssUtils#isMetricValue(String)}) or a numeric value in pixels ({@link CssUtils#isNumericValue(String)}).<br />
	 * Checks if the style is present in the css of the tag, then parses it to pt. and returns the parsed value.
	 * @param t the tag which needs to be checked.
	 * @param style the style which needs to be checked.
	 * @return float the parsed value of the style or 0f if the value was invalid.
	 */
	public float checkMetricStyle(final Tag t, final String style) {
		Float metricValue = checkMetricStyle(t.getCSS(), style);
        if (metricValue != null) {
            return metricValue;
        }
        return 0f;
	}
	/**
	 * Use only if value of style is a metric value ({@link CssUtils#isMetricValue(String)}) or a numeric value in pixels ({@link CssUtils#isNumericValue(String)}).<br />
	 * Checks if the style is present in the css of the tag, then parses it to pt. and returns the parsed value.
	 * @param css the map of css styles which needs to be checked.
	 * @param style the style which needs to be checked.
	 * @return float the parsed value of the style or 0f if the value was invalid.
	 */
	public Float checkMetricStyle(final Map<String,String> css, final String style) {
		String value = css.get(style);
		if (value != null && (isMetricValue(value) || isNumericValue(value))) {
			return parsePxInCmMmPcToPt(value);
		}
		return null;
	}

	/**
	 * Checks whether a string contains an allowed metric unit in HTML/CSS; px, in, cm, mm, pc or pt.
	 * @param value the string that needs to be checked.
	 * @return boolean true if value contains an allowed metric value.
	 */
	public boolean isMetricValue(final String value) {
		return value.contains(CSS.Value.PX) || value.contains(CSS.Value.IN) || value.contains(CSS.Value.CM)
			|| value.contains(CSS.Value.MM) || value.contains(CSS.Value.PC) || value.contains(CSS.Value.PT);

	}
	/**
	 * Checks whether a string contains an allowed value relative to previously set value.
	 * @param value the string that needs to be checked.
	 * @return boolean true if value contains an allowed metric value.
	 */
	public boolean isRelativeValue(final String value) {
		return value.contains(CSS.Value.PERCENTAGE) || value.contains(CSS.Value.EM) || value.contains(CSS.Value.EX);

	}
	/**
	 * Checks whether a string matches a numeric value (e.g. 123, 1.23, .123). All these metric values are allowed in HTML/CSS.
	 * @param value the string that needs to be checked.
	 * @return boolean true if value contains an allowed metric value.
	 */
	public boolean isNumericValue(final String value) {
		return value.matches("^-?\\d\\d*\\.\\d*$") || value.matches("^-?\\d\\d*$") || value.matches("^-?\\.\\d\\d*$");

	}
	/**
	 * Convenience method for parsing a value to pt if a value can contain: <br />
	 * <ul>
	 * 	<li>a numeric value in pixels (e.g. 123, 1.23, .123),</li>
	 * 	<li>a value with a metric unit (px, in, cm, mm, pc or pt) attached to it,</li>
	 * 	<li>or a value with a relative value (%, em, ex).</li>
	 * </ul>
	 * <b>Note:</b> baseValue must be in pt.<br /><br />
	 * @param value the string containing the value to be parsed.
	 * @param baseValue float needed for the calculation of the relative value.
	 * @return parsedValue float containing the parsed value in pt.
	 */
	public float parseValueToPt(final String value, final float baseValue) {
		float parsedValue = 0;
		if(isMetricValue(value) || isNumericValue(value)) {
			parsedValue = parsePxInCmMmPcToPt(value);
		} else if (isRelativeValue(value)) {
			parsedValue = parseRelativeValue(value, baseValue);
		}
		return parsedValue;
	}
	/**
	 * Parses an relative value based on the base value that was given, in the metric unit of the base value. <br />
	 * (e.g. margin=10% should be based on the page width, so if an A4 is used, the margin = 0.10*595.0 = 59.5f)
	 * @param relativeValue in %, em or ex.
	 * @param baseValue the value the returned float is based on.
	 * @return the parsed float in the metric unit of the base value.
	 */
	public float parseRelativeValue(final String relativeValue, final float baseValue) {
		int pos = determinePositionBetweenValueAndUnit(relativeValue);
		if (pos == 0)
			return 0f;
		float f = Float.parseFloat(relativeValue.substring(0, pos) + "f");
		String unit = relativeValue.substring(pos);
		if (unit.startsWith("%")) {
			f = baseValue * f / 100;
		} else if (unit.startsWith("em")) {
			f = baseValue * f;
		} else if (unit.contains("ex")) {
			f = baseValue * f / 2;
		}
		return f;
	}

	/**
	 * Parses a length with an allowed metric unit (px, pt, in, cm, mm, pc, em or ex) or numeric value (e.g. 123, 1.23,
	 * .123) to pt.<br />
	 * A numeric value (without px, pt, etc in the given length string) is considered to be in the default metric that
	 * was given.
	 *
	 * @param length the string containing the length.
	 * @param defaultMetric the string containing the metric if it is possible that the length string does not contain
	 *            one. If null the length is considered to be in px as is default in HTML/CSS.
	 * @return parsed value
	 */
	public float parsePxInCmMmPcToPt(final String length, final String defaultMetric) {
		int pos = determinePositionBetweenValueAndUnit(length);
		if (pos == 0)
			return 0f;
		float f = Float.parseFloat(length.substring(0, pos) + "f");
		String unit = length.substring(pos);
		// inches
		if (unit.startsWith(CSS.Value.IN) || (unit.equals("") && defaultMetric.equals(CSS.Value.IN))) {
			f *= 72f;
		}
		// centimeters
		else if (unit.startsWith(CSS.Value.CM) || (unit.equals("") && defaultMetric.equals(CSS.Value.CM))) {
			f = (f / 2.54f) * 72f;
		}
		// millimeters
		else if (unit.startsWith(CSS.Value.MM) || (unit.equals("") && defaultMetric.equals(CSS.Value.MM))) {
			f = (f / 25.4f) * 72f;
		}
		// picas
		else if (unit.startsWith(CSS.Value.PC) || (unit.equals("") && defaultMetric.equals(CSS.Value.PC))) {
			f *= 12f;
		}
		// pixels (1px = 0.75pt).
		else if (unit.startsWith(CSS.Value.PX) || (unit.equals("") && defaultMetric.equals(CSS.Value.PX))) {
			f *= 0.75f;
		}
		return f;
	}

	/**
	 * Parses a length with an allowed metric unit (px, pt, in, cm, mm, pc, em or ex) or numeric value (e.g. 123, 1.23, .123) to pt.<br />
	 * A numeric value is considered to be in px as is default in HTML/CSS.
	 * @param length the string containing the length.
	 * @return float the parsed length in pt.
	 */
	public float parsePxInCmMmPcToPt(final String length) {
		return parsePxInCmMmPcToPt(length, CSS.Value.PX);
	}

	/**
	 * Method used in preparation of splitting a string containing a numeric value with a metric unit (e.g. 18px, 9pt, 6cm, etc).<br /><br />
	 * Determines the position between digits and affiliated characters ('+','-','0-9' and '.') and all other characters.<br />
	 * e.g. string "16px" will return 2, string "0.5em" will return 3 and string '-8.5mm' will return 4.
	 *
	 * @param string containing a numeric value with a metric unit
	 * @return int position between the numeric value and unit or 0 if string is null or string started with a non-numeric value.
	 */
	public int determinePositionBetweenValueAndUnit(final String string) {
		if (string == null)
			return 0;
		int pos = 0;
		boolean ok = true;
		while (ok && pos < string.length()) {
			switch (string.charAt(pos)) {
			case '+':
			case '-':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case '.':
				pos++;
				break;
			default:
				ok = false;
			}
		}
		return pos;
	}
	/**
	 * Returns the sum of the left and right margin of a tag.
	 * @param t the tag of which the total horizontal margin is needed.
	 * @param pageWidth the page width
	 * @return float the total horizontal margin.
	 */
	public float getLeftAndRightMargin(final Tag t, final float pageWidth) {
		float horizontalMargin = 0;
		String value = t.getCSS().get(CSS.Property.MARGIN_LEFT);
		if (value != null) {
			horizontalMargin += parseValueToPt(value, pageWidth);
		}
		value = t.getCSS().get(CSS.Property.MARGIN_RIGHT);
		if (value != null) {
			horizontalMargin += parseValueToPt(value, pageWidth);
		}
		return horizontalMargin;
	}

	/**
	 * Parses <code>url("file.jpg")</code> to <code>file.jpg</code>.
	 * @param url the url attribute to parse
	 * @return the parsed url. Or original url if not wrappend in url()
	 */
	public String extractUrl(final String url) {
		String str = null;
		if (url.startsWith("url")) {
			String urlString = url.substring(3).trim().replace("(", "").replace(")", "").trim();
			if (urlString.startsWith("'") && urlString.endsWith("'")) {
				str = urlString.substring(urlString.indexOf("'")+1, urlString.lastIndexOf("'"));
			} else if ( urlString.startsWith("\"") && urlString.endsWith("\"") ) {
				str = urlString.substring(urlString.indexOf('"')+1, urlString.lastIndexOf('"'));
			} else {
			    str = urlString;
			}
		} else {
			// assume it's an url without wrapping in "url()"
			str = url;
		}
		return str;
	}

	/**
	 * Validates a given textHeight based on the content of a tag against the css styles "min-height" and "max-height" of the tag if present.
	 *
	 * @param css the styles of a tag
	 * @param textHeight the current textHeight based on the content of a tag
	 * @return the final text height of an element.
	 */
	public float validateTextHeight(final Map<String, String> css,
			float textHeight) {
		if(null != css.get("min-height") && textHeight < new CssUtils().parsePxInCmMmPcToPt(css.get("min-height"))) {
			textHeight = new CssUtils().parsePxInCmMmPcToPt(css.get("min-height"));
		} else if(null != css.get("max-height") && textHeight > new CssUtils().parsePxInCmMmPcToPt(css.get("max-height"))) {
			textHeight = new CssUtils().parsePxInCmMmPcToPt(css.get("max-height"));
		}
		return textHeight;
	}

	/**
	 * Calculates the margin top or spacingBefore based on the given value and the last margin bottom.
	 * <br /><br />
	 * In HTML the margin-bottom of a tag overlaps with the margin-top of a following tag.
	 * This method simulates this behavior by subtracting the margin-top value of the given tag from the margin-bottom of the previous tag. The remaining value is returned or if the margin-bottom value is the largest, 0 is returned
	 * @param value the margin-top value of the given tag.
	 * @param largestFont used if a relative value was given to calculate margin.
	 * @param configuration XmlWorkerConfig containing the last margin bottom.
	 * @return an offset
	 */
	public float calculateMarginTop(final String value, final float largestFont, final MarginMemory configuration) {
		return calculateMarginTop(parseValueToPt(value, largestFont), configuration);
	}

	/**
	 * Calculates the margin top or spacingBefore based on the given value and the last margin bottom.
	 * <br /><br />
	 * In HTML the margin-bottom of a tag overlaps with the margin-top of a following tag.
	 * This method simulates this behavior by subtracting the margin-top value of the given tag from the margin-bottom of the previous tag. The remaining value is returned or if the margin-bottom value is the largest, 0 is returned
	 * @param value float containing the margin-top value.
	 * @param configuration XmlWorkerConfig containing the last margin bottom.
	 * @return an offset
	 */
	public float calculateMarginTop(final float value, final MarginMemory configuration) {
		float marginTop = value;
		try {
			float marginBottom = configuration.getLastMarginBottom();
			marginTop = (marginTop>marginBottom)?marginTop-marginBottom:0;
		} catch (NoDataException e) {
		}
		return marginTop;
	}

	/**
	 * Trims a string and removes surrounding " or '.
	 *
	 * @param s the string
	 * @return trimmed and unquoted string
	 */
	public String trimAndRemoveQuoutes(String s) {
		s = s.trim();
		if ((s.startsWith("\"") || s.startsWith("'")) && s.endsWith("\"") || s.endsWith("'")) {
			s = s.substring(1, s.length() - 1);
		}
		return s;
	}

    public String[] splitComplexCssStyle(String s) {
        s = s.replaceAll("\\s*,\\s*", ",") ;
        return s.split("\\s");
    }
}
