Merge branch 'html'

Conflicts:
	Makefile

7 files changed, 3308 insertions, 0 deletions

diff --git a/source/fitz/document-all.c b/source/fitz/document-all.c
index e1eb4a58..bfe57592 100644
--- a/source/fitz/document-all.c
+++ b/source/fitz/document-all.c
@@ -7,4 +7,6 @@ void fz_register_document_handlers(fz_context *ctx)
 	fz_register_document_handler(ctx, &cbz_document_handler);
 	fz_register_document_handler(ctx, &img_document_handler);
 	fz_register_document_handler(ctx, &tiff_document_handler);
+	fz_register_document_handler(ctx, &html_document_handler);
+	fz_register_document_handler(ctx, &epub_document_handler);
 }
diff --git a/source/html/css-apply.c b/source/html/css-apply.c
new file mode 100644
index 00000000..9a6d7a89
--- /dev/null
+++ b/source/html/css-apply.c
@@ -0,0 +1,993 @@
+#include "mupdf/html.h"
+
+static const char *inherit_list[] = {
+	"color",
+	"direction",
+	"font-family",
+	"font-size",
+	"font-style",
+	"font-variant",
+	"font-weight",
+	"letter-spacing",
+	"line-height",
+	"list-style-image",
+	"list-style-position",
+	"list-style-type",
+	"orphans",
+	"quotes",
+	"text-align",
+	"text-indent",
+	"text-transform",
+	"visibility",
+	"white-space",
+	"widows",
+	"word-spacing",
+};
+
+static const char *border_width_kw[] = {
+	"medium",
+	"thick",
+	"thin",
+};
+
+static const char *border_style_kw[] = {
+	"dashed",
+	"dotted",
+	"double",
+	"groove",
+	"hidden",
+	"inset",
+	"none",
+	"outset",
+	"ridge",
+	"solid",
+};
+
+static const char *color_kw[] = {
+	"aqua",
+	"black",
+	"blue",
+	"fuchsia",
+	"gray",
+	"green",
+	"lime",
+	"maroon",
+	"navy",
+	"olive",
+	"orange",
+	"purple",
+	"red",
+	"silver",
+	"teal",
+	"transparent",
+	"white",
+	"yellow",
+};
+
+static int
+keyword_in_list(const char *name, const char **list, int n)
+{
+	int l = 0;
+	int r = n - 1;
+	while (l <= r)
+	{
+		int m = (l + r) >> 1;
+		int c = strcmp(name, list[m]);
+		if (c < 0)
+			r = m - 1;
+		else if (c > 0)
+			l = m + 1;
+		else
+			return 1;
+	}
+	return 0;
+}
+
+/*
+ * Compute specificity
+ */
+
+static int
+count_condition_ids(fz_css_condition *cond)
+{
+	int n = 0;
+	while (cond)
+	{
+		if (cond->type == '#')
+			n ++;
+		cond = cond->next;
+	}
+	return n;
+}
+
+static int
+count_selector_ids(fz_css_selector *sel)
+{
+	int n = count_condition_ids(sel->cond);
+	if (sel->left && sel->right)
+	{
+		n += count_selector_ids(sel->left);
+		n += count_selector_ids(sel->right);
+	}
+	return n;
+}
+
+static int
+count_condition_atts(fz_css_condition *cond)
+{
+	int n = 0;
+	while (cond)
+	{
+		if (cond->type != '#' && cond->type != ':')
+			n ++;
+		cond = cond->next;
+	}
+	return n;
+}
+
+static int
+count_selector_atts(fz_css_selector *sel)
+{
+	int n = count_condition_atts(sel->cond);
+	if (sel->left && sel->right)
+	{
+		n += count_selector_atts(sel->left);
+		n += count_selector_atts(sel->right);
+	}
+	return n;
+}
+
+static int
+count_condition_names(fz_css_condition *cond)
+{
+	int n = 0;
+	while (cond)
+	{
+		if (cond->type == ':')
+			n ++;
+		cond = cond->next;
+	}
+	return n;
+}
+
+static int
+count_selector_names(fz_css_selector *sel)
+{
+	int n = count_condition_names(sel->cond);
+	if (sel->left && sel->right)
+	{
+		n += count_selector_names(sel->left);
+		n += count_selector_names(sel->right);
+	}
+	else if (sel->name)
+	{
+		n ++;
+	}
+	return n;
+}
+
+#define INLINE_SPECIFICITY 1000
+
+static int
+selector_specificity(fz_css_selector *sel)
+{
+	int b = count_selector_ids(sel);
+	int c = count_selector_atts(sel);
+	int d = count_selector_names(sel);
+	return b * 100 + c * 10 + d;
+}
+
+/*
+ * Selector matching
+ */
+
+static int
+match_id_condition(fz_xml *node, const char *p)
+{
+	const char *s = fz_xml_att(node, "id");
+	if (s && !strcmp(s, p))
+		return 1;
+	return 0;
+}
+
+static int
+match_class_condition(fz_xml *node, const char *p)
+{
+	const char *s = fz_xml_att(node, "class");
+	char buf[1024];
+	if (s) {
+		strcpy(buf, s);
+		s = strtok(buf, " ");
+		while (s) {
+			if (!strcmp(s, p))
+				return 1;
+			s = strtok(NULL, " ");
+		}
+	}
+	return 0;
+}
+
+static int
+match_condition(fz_css_condition *cond, fz_xml *node)
+{
+	if (!cond)
+		return 1;
+
+	switch (cond->type) {
+	default: return 0;
+	case ':': return 0; /* don't support pseudo-classes */
+	case '#': if (!match_id_condition(node, cond->val)) return 0; break;
+	case '.': if (!match_class_condition(node, cond->val)) return 0; break;
+	}
+
+	return match_condition(cond->next, node);
+}
+
+static int
+match_selector(fz_css_selector *sel, fz_xml *node)
+{
+	if (!node)
+		return 0;
+
+	if (sel->combine)
+	{
+		/* descendant */
+		if (sel->combine == ' ')
+		{
+			fz_xml *parent = fz_xml_up(node);
+			while (parent)
+			{
+				if (match_selector(sel->left, parent))
+					if (match_selector(sel->right, node))
+						return 1;
+				parent = fz_xml_up(parent);
+			}
+			return 0;
+		}
+
+		/* child */
+		if (sel->combine == '>')
+		{
+			fz_xml *parent = fz_xml_up(node);
+			if (!parent)
+				return 0;
+			if (!match_selector(sel->left, parent))
+				return 0;
+			if (!match_selector(sel->right, node))
+				return 0;
+		}
+
+		/* adjacent */
+		if (sel->combine == '+')
+		{
+			fz_xml *prev = fz_xml_prev(node);
+			while (prev && !fz_xml_tag(prev))
+				prev = fz_xml_prev(prev);
+			if (!prev)
+				return 0;
+			if (!fz_xml_tag(prev))
+				return 0;
+			if (!match_selector(sel->left, prev))
+				return 0;
+			if (!match_selector(sel->right, node))
+				return 0;
+		}
+	}
+
+	if (sel->name)
+	{
+		if (strcmp(sel->name, fz_xml_tag(node)))
+			return 0;
+	}
+
+	if (sel->cond)
+	{
+		if (!match_condition(sel->cond, node))
+			return 0;
+	}
+
+	return 1;
+}
+
+/*
+ * Annotating nodes with properties and expanding shorthand forms.
+ */
+
+static int
+count_values(fz_css_value *value)
+{
+	int n = 0;
+	while (value)
+	{
+		n++;
+		value = value->next;
+	}
+	return n;
+}
+
+static void add_property(fz_css_match *match, const char *name, fz_css_value *value, int spec);
+
+static void
+add_shorthand_trbl(fz_css_match *match, fz_css_value *value, int spec,
+	const char *name_t, const char *name_r, const char *name_b, const char *name_l)
+{
+	int n = count_values(value);
+
+	if (n == 1)
+	{
+		add_property(match, name_t, value, spec);
+		add_property(match, name_r, value, spec);
+		add_property(match, name_b, value, spec);
+		add_property(match, name_l, value, spec);
+	}
+
+	if (n == 2)
+	{
+		fz_css_value *a = value;
+		fz_css_value *b = value->next;
+
+		add_property(match, name_t, a, spec);
+		add_property(match, name_r, b, spec);
+		add_property(match, name_b, a, spec);
+		add_property(match, name_l, b, spec);
+	}
+
+	if (n == 3)
+	{
+		fz_css_value *a = value;
+		fz_css_value *b = value->next;
+		fz_css_value *c = value->next->next;
+
+		add_property(match, name_t, a, spec);
+		add_property(match, name_r, b, spec);
+		add_property(match, name_b, c, spec);
+		add_property(match, name_l, b, spec);
+	}
+
+	if (n == 4)
+	{
+		fz_css_value *a = value;
+		fz_css_value *b = value->next;
+		fz_css_value *c = value->next->next;
+		fz_css_value *d = value->next->next->next;
+
+		add_property(match, name_t, a, spec);
+		add_property(match, name_r, b, spec);
+		add_property(match, name_b, c, spec);
+		add_property(match, name_l, d, spec);
+	}
+}
+
+static void
+add_shorthand_margin(fz_css_match *match, fz_css_value *value, int spec)
+{
+	add_shorthand_trbl(match, value, spec,
+		"margin-top", "margin-right", "margin-bottom", "margin-left");
+}
+
+static void
+add_shorthand_padding(fz_css_match *match, fz_css_value *value, int spec)
+{
+	add_shorthand_trbl(match, value, spec,
+		"padding-top", "padding-right", "padding-bottom", "padding-left");
+}
+
+static void
+add_shorthand_border_width(fz_css_match *match, fz_css_value *value, int spec)
+{
+	add_shorthand_trbl(match, value, spec,
+		"border-width-top", "border-width-right", "border-width-bottom", "border-width-left");
+}
+
+static void
+add_shorthand_border(fz_css_match *match, fz_css_value *value, int spec)
+{
+	while (value)
+	{
+		if (value->type == CSS_COLOR)
+		{
+			add_property(match, "border-color", value, spec);
+		}
+		else if (value->type == CSS_KEYWORD)
+		{
+			if (keyword_in_list(value->data, border_width_kw, nelem(border_width_kw)))
+			{
+				add_property(match, "border-width-top", value, spec);
+				add_property(match, "border-width-right", value, spec);
+				add_property(match, "border-width-bottom", value, spec);
+				add_property(match, "border-width-left", value, spec);
+			}
+			else if (keyword_in_list(value->data, border_style_kw, nelem(border_style_kw)))
+			{
+				add_property(match, "border-style", value, spec);
+			}
+			else if (keyword_in_list(value->data, color_kw, nelem(color_kw)))
+			{
+				add_property(match, "border-color", value, spec);
+			}
+		}
+		else
+		{
+			add_property(match, "border-width-top", value, spec);
+			add_property(match, "border-width-right", value, spec);
+			add_property(match, "border-width-bottom", value, spec);
+			add_property(match, "border-width-left", value, spec);
+		}
+		value = value->next;
+	}
+}
+
+static void
+add_property(fz_css_match *match, const char *name, fz_css_value *value, int spec)
+{
+	int i;
+
+	if (!strcmp(name, "margin"))
+	{
+		add_shorthand_margin(match, value, spec);
+		return;
+	}
+	if (!strcmp(name, "padding"))
+	{
+		add_shorthand_padding(match, value, spec);
+		return;
+	}
+	if (!strcmp(name, "border-width"))
+	{
+		add_shorthand_border_width(match, value, spec);
+		return;
+	}
+	if (!strcmp(name, "border"))
+	{
+		add_shorthand_border(match, value, spec);
+		return;
+	}
+
+	/* shorthand expansions: */
+	/* TODO: border-color */
+	/* TODO: border-style */
+	/* TODO: font */
+	/* TODO: list-style */
+	/* TODO: background */
+
+	for (i = 0; i < match->count; ++i)
+	{
+		if (!strcmp(match->prop[i].name, name))
+		{
+			if (match->prop[i].spec <= spec)
+			{
+				match->prop[i].value = value;
+				match->prop[i].spec = spec;
+			}
+			return;
+		}
+	}
+
+	if (match->count + 1 >= nelem(match->prop))
+	{
+		// fz_warn(ctx, "too many css properties");
+		return;
+	}
+
+	match->prop[match->count].name = name;
+	match->prop[match->count].value = value;
+	match->prop[match->count].spec = spec;
+	++match->count;
+}
+
+void
+fz_match_css(fz_context *ctx, fz_css_match *match, fz_css_rule *css, fz_xml *node)
+{
+	fz_css_rule *rule;
+	fz_css_selector *sel;
+	fz_css_property *prop, *head, *tail;
+	const char *s;
+
+	for (rule = css; rule; rule = rule->next)
+	{
+		sel = rule->selector;
+		while (sel)
+		{
+			if (match_selector(sel, node))
+			{
+				for (prop = rule->declaration; prop; prop = prop->next)
+					add_property(match, prop->name, prop->value, selector_specificity(sel));
+				break;
+			}
+			sel = sel->next;
+		}
+	}
+
+	s = fz_xml_att(node, "style");
+	if (s)
+	{
+		head = tail = prop = fz_parse_css_properties(ctx, s);
+		while (prop)
+		{
+			add_property(match, prop->name, prop->value, INLINE_SPECIFICITY);
+			tail = prop;
+			prop = prop->next;
+		}
+		if (tail)
+			tail->next = css->garbage;
+		css->garbage = head;
+	}
+}
+
+static fz_css_value *
+value_from_raw_property(fz_css_match *match, const char *name)
+{
+	int i;
+	for (i = 0; i < match->count; ++i)
+		if (!strcmp(match->prop[i].name, name))
+			return match->prop[i].value;
+	return NULL;
+}
+
+static fz_css_value *
+value_from_property(fz_css_match *match, const char *name)
+{
+	fz_css_value *value;
+
+	value = value_from_raw_property(match, name);
+	if (match->up)
+	{
+		if (value && !strcmp(value->data, "inherit"))
+			return value_from_property(match->up, name);
+		if (!value && keyword_in_list(name, inherit_list, nelem(inherit_list)))
+			return value_from_property(match->up, name);
+	}
+	return value;
+}
+
+static const char *
+string_from_property(fz_css_match *match, const char *name, const char *initial)
+{
+	fz_css_value *value;
+	value = value_from_property(match, name);
+	if (!value)
+		return initial;
+	return value->data;
+}
+
+static fz_css_number
+make_number(float v, int u)
+{
+	fz_css_number n;
+	n.value = v;
+	n.unit = u;
+	return n;
+}
+
+static fz_css_number
+number_from_value(fz_css_value *value, float initial, int initial_unit)
+{
+	char *p;
+
+	if (!value)
+		return make_number(initial, initial_unit);
+
+	if (value->type == CSS_PERCENT)
+		return make_number(strtof(value->data, NULL), N_PERCENT);
+
+	if (value->type == CSS_NUMBER)
+		return make_number(strtof(value->data, NULL), N_NUMBER);
+
+	if (value->type == CSS_LENGTH)
+	{
+		float x = strtof(value->data, &p);
+
+		if (p[0] == 'e' && p[1] == 'm')
+			return make_number(x, N_SCALE);
+		if (p[0] == 'e' && p[1] == 'x')
+			return make_number(x / 2, N_SCALE);
+
+		if (p[0] == 'i' && p[1] == 'n')
+			return make_number(x * 72, N_NUMBER);
+		if (p[0] == 'c' && p[1] == 'm')
+			return make_number(x * 7200 / 254, N_NUMBER);
+		if (p[0] == 'm' && p[1] == 'm')
+			return make_number(x * 720 / 254, N_NUMBER);
+		if (p[0] == 'p' && p[1] == 'c')
+			return make_number(x * 12, N_NUMBER);
+
+		if (p[0] == 'p' && p[1] == 't')
+			return make_number(x, N_NUMBER);
+		if (p[0] == 'p' && p[1] == 'x')
+			return make_number(x, N_NUMBER);
+
+		return make_number(x, N_NUMBER);
+	}
+
+	return make_number(initial, initial_unit);
+}
+
+static fz_css_number
+number_from_property(fz_css_match *match, const char *property, float initial, int initial_unit)
+{
+	return number_from_value(value_from_property(match, property), initial, initial_unit);
+}
+
+static fz_css_number
+border_width_from_property(fz_css_match *match, const char *property)
+{
+	fz_css_value *value = value_from_property(match, property);
+	if (value)
+	{
+		if (!strcmp(value->data, "thin"))
+			return make_number(1, N_NUMBER);
+		if (!strcmp(value->data, "medium"))
+			return make_number(2, N_NUMBER);
+		if (!strcmp(value->data, "thick"))
+			return make_number(4, N_NUMBER);
+		return number_from_value(value, 0, N_NUMBER);
+	}
+	return make_number(2, N_NUMBER); /* initial: 'medium' */
+}
+
+float
+fz_from_css_number(fz_css_number number, float em, float width)
+{
+	switch (number.unit) {
+	default:
+	case N_NUMBER: return number.value;
+	case N_SCALE: return number.value * em;
+	case N_PERCENT: return number.value * 0.01 * width;
+	}
+}
+
+float
+fz_from_css_number_scale(fz_css_number number, float scale, float em, float width)
+{
+	switch (number.unit) {
+	default:
+	case N_NUMBER: return number.value * scale;
+	case N_SCALE: return number.value * em;
+	case N_PERCENT: return number.value * 0.01 * width;
+	}
+}
+
+static fz_css_color
+make_color(int r, int g, int b, int a)
+{
+	fz_css_color c;
+	c.r = r;
+	c.g = g;
+	c.b = b;
+	c.a = a;
+	return c;
+}
+
+static int tohex(int c)
+{
+	if (c - '0' < 10)
+		return c - '0';
+	return (c | 32) - 'a' + 10;
+}
+
+static fz_css_color
+color_from_value(fz_css_value *value, fz_css_color initial)
+{
+	if (!value)
+		return initial;
+	if (value->type == CSS_COLOR)
+	{
+		int r = tohex(value->data[0]) * 16 + tohex(value->data[1]);
+		int g = tohex(value->data[2]) * 16 + tohex(value->data[3]);
+		int b = tohex(value->data[4]) * 16 + tohex(value->data[5]);
+		return make_color(r, g, b, 255);
+	}
+	if (value->type == CSS_KEYWORD)
+	{
+		if (!strcmp(value->data, "transparent"))
+			return make_color(0, 0, 0, 0);
+		if (!strcmp(value->data, "maroon"))
+			return make_color(0x80, 0x00, 0x00, 255);
+		if (!strcmp(value->data, "red"))
+			return make_color(0xFF, 0x00, 0x00, 255);
+		if (!strcmp(value->data, "orange"))
+			return make_color(0xFF, 0xA5, 0x00, 255);
+		if (!strcmp(value->data, "yellow"))
+			return make_color(0xFF, 0xFF, 0x00, 255);
+		if (!strcmp(value->data, "olive"))
+			return make_color(0x80, 0x80, 0x00, 255);
+		if (!strcmp(value->data, "purple"))
+			return make_color(0x80, 0x00, 0x80, 255);
+		if (!strcmp(value->data, "fuchsia"))
+			return make_color(0xFF, 0x00, 0xFF, 255);
+		if (!strcmp(value->data, "white"))
+			return make_color(0xFF, 0xFF, 0xFF, 255);
+		if (!strcmp(value->data, "lime"))
+			return make_color(0x00, 0xFF, 0x00, 255);
+		if (!strcmp(value->data, "green"))
+			return make_color(0x00, 0x80, 0x00, 255);
+		if (!strcmp(value->data, "navy"))
+			return make_color(0x00, 0x00, 0x80, 255);
+		if (!strcmp(value->data, "blue"))
+			return make_color(0x00, 0x00, 0xFF, 255);
+		if (!strcmp(value->data, "aqua"))
+			return make_color(0x00, 0xFF, 0xFF, 255);
+		if (!strcmp(value->data, "teal"))
+			return make_color(0x00, 0x80, 0x80, 255);
+		if (!strcmp(value->data, "black"))
+			return make_color(0x00, 0x00, 0x00, 255);
+		if (!strcmp(value->data, "silver"))
+			return make_color(0xC0, 0xC0, 0xC0, 255);
+		if (!strcmp(value->data, "gray"))
+			return make_color(0x80, 0x80, 0x80, 255);
+		return make_color(0, 0, 0, 255);
+	}
+	return initial;
+}
+
+static fz_css_color
+color_from_property(fz_css_match *match, const char *property, fz_css_color initial)
+{
+	return color_from_value(value_from_property(match, property), initial);
+}
+
+int
+fz_get_css_match_display(fz_css_match *match)
+{
+	fz_css_value *value = value_from_property(match, "display");
+	if (value)
+	{
+		if (!strcmp(value->data, "none"))
+			return DIS_NONE;
+		if (!strcmp(value->data, "inline"))
+			return DIS_INLINE;
+		if (!strcmp(value->data, "block"))
+			return DIS_BLOCK;
+		if (!strcmp(value->data, "list-item"))
+			return DIS_LIST_ITEM;
+	}
+	return DIS_INLINE;
+}
+
+static int
+white_space_from_property(fz_css_match *match)
+{
+	fz_css_value *value = value_from_property(match, "white-space");
+	if (value)
+	{
+		if (!strcmp(value->data, "normal")) return WS_NORMAL;
+		if (!strcmp(value->data, "pre")) return WS_PRE;
+		if (!strcmp(value->data, "nowrap")) return WS_NOWRAP;
+		if (!strcmp(value->data, "pre-wrap")) return WS_PRE_WRAP;
+		if (!strcmp(value->data, "pre-line")) return WS_PRE_LINE;
+	}
+	return WS_NORMAL;
+}
+
+void
+fz_default_css_style(fz_context *ctx, fz_css_style *style)
+{
+	memset(style, 0, sizeof *style);
+	style->text_align = TA_LEFT;
+	style->vertical_align = VA_BASELINE;
+	style->white_space = WS_NORMAL;
+	style->font_size = make_number(1, N_SCALE);
+}
+
+void
+fz_apply_css_style(fz_context *ctx, fz_html_font_set *set, fz_css_style *style, fz_css_match *match)
+{
+	fz_css_value *value;
+
+	fz_css_color black = { 0, 0, 0, 255 };
+	fz_css_color transparent = { 0, 0, 0, 0 };
+
+	fz_default_css_style(ctx, style);
+
+	style->white_space = white_space_from_property(match);
+
+	value = value_from_property(match, "text-align");
+	if (value)
+	{
+		if (!strcmp(value->data, "left"))
+			style->text_align = TA_LEFT;
+		if (!strcmp(value->data, "right"))
+			style->text_align = TA_RIGHT;
+		if (!strcmp(value->data, "center"))
+			style->text_align = TA_CENTER;
+		if (!strcmp(value->data, "justify"))
+			style->text_align = TA_JUSTIFY;
+	}
+
+	value = value_from_property(match, "vertical-align");
+	if (value)
+	{
+		if (!strcmp(value->data, "baseline"))
+			style->vertical_align = VA_BASELINE;
+		if (!strcmp(value->data, "sub"))
+			style->vertical_align = VA_SUB;
+		if (!strcmp(value->data, "super"))
+			style->vertical_align = VA_SUPER;
+		if (!strcmp(value->data, "top"))
+			style->vertical_align = VA_TOP;
+		if (!strcmp(value->data, "bottom"))
+			style->vertical_align = VA_BOTTOM;
+	}
+
+	value = value_from_property(match, "font-size");
+	if (value)
+	{
+		if (!strcmp(value->data, "xx-large")) style->font_size = make_number(1.73, N_SCALE);
+		else if (!strcmp(value->data, "x-large")) style->font_size = make_number(1.44, N_SCALE);
+		else if (!strcmp(value->data, "large")) style->font_size = make_number(1.2, N_SCALE);
+		else if (!strcmp(value->data, "medium")) style->font_size = make_number(1, N_SCALE);
+		else if (!strcmp(value->data, "small")) style->font_size = make_number(0.83, N_SCALE);
+		else if (!strcmp(value->data, "x-small")) style->font_size = make_number(0.69, N_SCALE);
+		else if (!strcmp(value->data, "xx-small")) style->font_size = make_number(0.69, N_SCALE);
+		else if (!strcmp(value->data, "larger")) style->font_size = make_number(1.2f, N_SCALE);
+		else if (!strcmp(value->data, "smaller")) style->font_size = make_number(1/1.2f, N_SCALE);
+		else style->font_size = number_from_value(value, 12, N_NUMBER);
+	}
+	else
+	{
+		style->font_size = make_number(1, N_SCALE);
+	}
+
+	value = value_from_property(match, "border-style");
+	if (value)
+	{
+		if (!strcmp(value->data, "none"))
+			style->border_style = BS_NONE;
+		if (!strcmp(value->data, "hidden"))
+			style->border_style = BS_NONE;
+		if (!strcmp(value->data, "solid"))
+			style->border_style = BS_SOLID;
+	}
+
+	style->line_height = number_from_property(match, "line-height", 1.2, N_SCALE);
+
+	style->text_indent = number_from_property(match, "text-indent", 0, N_NUMBER);
+
+	style->margin[0] = number_from_property(match, "margin-top", 0, N_NUMBER);
+	style->margin[1] = number_from_property(match, "margin-right", 0, N_NUMBER);
+	style->margin[2] = number_from_property(match, "margin-bottom", 0, N_NUMBER);
+	style->margin[3] = number_from_property(match, "margin-left", 0, N_NUMBER);
+
+	style->padding[0] = number_from_property(match, "padding-top", 0, N_NUMBER);
+	style->padding[1] = number_from_property(match, "padding-right", 0, N_NUMBER);
+	style->padding[2] = number_from_property(match, "padding-bottom", 0, N_NUMBER);
+	style->padding[3] = number_from_property(match, "padding-left", 0, N_NUMBER);
+
+	style->border_width[0] = border_width_from_property(match, "border-width-top");
+	style->border_width[1] = border_width_from_property(match, "border-width-right");
+	style->border_width[2] = border_width_from_property(match, "border-width-bottom");
+	style->border_width[3] = border_width_from_property(match, "border-width-left");
+
+	style->color = color_from_property(match, "color", black);
+	style->background_color = color_from_property(match, "background-color", transparent);
+	style->border_color = color_from_property(match, "border-color", style->color);
+
+	{
+		const char *font_family = string_from_property(match, "font-family", "serif");
+		const char *font_variant = string_from_property(match, "font-variant", "normal");
+		const char *font_style = string_from_property(match, "font-style", "normal");
+		const char *font_weight = string_from_property(match, "font-weight", "normal");
+		style->font = fz_load_html_font(ctx, set, font_family, font_variant, font_style, font_weight);
+	}
+}
+
+/*
+ * Pretty printing
+ */
+
+void
+print_value(fz_css_value *val)
+{
+	printf("%s", val->data);
+	if (val->args)
+	{
+		printf("(");
+		print_value(val->args);
+		printf(")");
+	}
+	if (val->next)
+	{
+		printf(" ");
+		print_value(val->next);
+	}
+}
+
+void
+print_property(fz_css_property *prop)
+{
+	printf("\t%s: ", prop->name);
+	print_value(prop->value);
+	printf(" !%d;\n", prop->spec);
+}
+
+void
+print_condition(fz_css_condition *cond)
+{
+	if (cond->type == '=')
+		printf("[%s=%s]", cond->key, cond->val);
+	else if (cond->type == '[')
+		printf("[%s]", cond->key);
+	else
+		printf("%c%s", cond->type, cond->val);
+	if (cond->next)
+		print_condition(cond->next);
+}
+
+void
+print_selector(fz_css_selector *sel)
+{
+	if (sel->combine)
+	{
+putchar('(');
+		print_selector(sel->left);
+		if (sel->combine == ' ')
+			printf(" ");
+		else
+			printf(" %c ", sel->combine);
+		print_selector(sel->right);
+putchar(')');
+	}
+	else if (sel->name)
+		printf("%s", sel->name);
+	else
+		printf("*");
+	if (sel->cond)
+	{
+		print_condition(sel->cond);
+	}
+}
+
+void
+print_rule(fz_css_rule *rule)
+{
+	fz_css_selector *sel;
+	fz_css_property *prop;
+
+	for (sel = rule->selector; sel; sel = sel->next)
+	{
+		print_selector(sel);
+		printf(" !%d", selector_specificity(sel));
+		if (sel->next)
+			printf(", ");
+	}
+
+	printf("\n{\n");
+	for (prop = rule->declaration; prop; prop = prop->next)
+	{
+		print_property(prop);
+	}
+	printf("}\n");
+}
+
+void
+print_rules(fz_css_rule *rule)
+{
+	while (rule)
+	{
+		print_rule(rule);
+		rule = rule->next;
+	}
+}
+
+void
+print_style(fz_css_style *style)
+{
+	printf("style {\n");
+	printf("\tfont-size = %g%c;\n", style->font_size.value, style->font_size.unit);
+	printf("\tfont = %s;\n", style->font->name);
+	printf("\tline-height = %g%c;\n", style->line_height.value, style->line_height.unit);
+	printf("\ttext-indent = %g%c;\n", style->text_indent.value, style->text_indent.unit);
+	printf("\ttext-align = %d;\n", style->text_align);
+	printf("\tvertical-align = %d;\n", style->vertical_align);
+	printf("\tmargin = %g%c %g%c %g%c %g%c;\n",
+		style->margin[0].value, style->margin[0].unit,
+		style->margin[1].value, style->margin[1].unit,
+		style->margin[2].value, style->margin[2].unit,
+		style->margin[3].value, style->margin[3].unit);
+	printf("\tpadding = %g%c %g%c %g%c %g%c;\n",
+		style->padding[0].value, style->padding[0].unit,
+		style->padding[1].value, style->padding[1].unit,
+		style->padding[2].value, style->padding[2].unit,
+		style->padding[3].value, style->padding[3].unit);
+	printf("}\n");
+}
diff --git a/source/html/css-parse.c b/source/html/css-parse.c
new file mode 100644
index 00000000..e3ddd48f
--- /dev/null
+++ b/source/html/css-parse.c
@@ -0,0 +1,865 @@
+#include "mupdf/html.h"
+
+struct lexbuf
+{
+	fz_context *ctx;
+	const char *s;
+	const char *file;
+	int line;
+	int lookahead;
+	int c;
+	int color;
+	int string_len;
+	char string[1024];
+};
+
+FZ_NORETURN static void fz_css_error(struct lexbuf *buf, const char *msg)
+{
+	fz_throw(buf->ctx, FZ_ERROR_GENERIC, "css syntax error: %s (%s:%d)", msg, buf->file, buf->line);
+}
+
+static fz_css_rule *fz_new_css_rule(fz_context *ctx, fz_css_selector *selector, fz_css_property *declaration)
+{
+	fz_css_rule *rule = fz_malloc_struct(ctx, fz_css_rule);
+	rule->selector = selector;
+	rule->declaration = declaration;
+	rule->garbage = NULL;
+	rule->next = NULL;
+	return rule;
+}
+
+static fz_css_selector *fz_new_css_selector(fz_context *ctx, const char *name)
+{
+	fz_css_selector *sel = fz_malloc_struct(ctx, fz_css_selector);
+	sel->name = name ? fz_strdup(ctx, name) : NULL;
+	sel->combine = 0;
+	sel->cond = NULL;
+	sel->left = NULL;
+	sel->right = NULL;
+	sel->next = NULL;
+	return sel;
+}
+
+static fz_css_condition *fz_new_css_condition(fz_context *ctx, int type, const char *key, const char *val)
+{
+	fz_css_condition *cond = fz_malloc_struct(ctx, fz_css_condition);
+	cond->type = type;
+	cond->key = key ? fz_strdup(ctx, key) : NULL;
+	cond->val = val ? fz_strdup(ctx, val) : NULL;
+	cond->next = NULL;
+	return cond;
+}
+
+static fz_css_property *fz_new_css_property(fz_context *ctx, const char *name, fz_css_value *value, int spec)
+{
+	fz_css_property *prop = fz_malloc_struct(ctx, fz_css_property);
+	prop->name = fz_strdup(ctx, name);
+	prop->value = value;
+	prop->spec = spec;
+	prop->next = NULL;
+	return prop;
+}
+
+static fz_css_value *fz_new_css_value(fz_context *ctx, int type, const char *data)
+{
+	fz_css_value *val = fz_malloc_struct(ctx, fz_css_value);
+	val->type = type;
+	val->data = fz_strdup(ctx, data);
+	val->args = NULL;
+	val->next = NULL;
+	return val;
+}
+
+static void fz_drop_css_value(fz_context *ctx, fz_css_value *val)
+{
+	while (val)
+	{
+		fz_css_value *next = val->next;
+		fz_drop_css_value(ctx, val->args);
+		fz_free(ctx, val->data);
+		fz_free(ctx, val);
+		val = next;
+	}
+}
+
+static void fz_drop_css_condition(fz_context *ctx, fz_css_condition *cond)
+{
+	while (cond)
+	{
+		fz_css_condition *next = cond->next;
+		fz_free(ctx, cond->key);
+		fz_free(ctx, cond->val);
+		fz_free(ctx, cond);
+		cond = next;
+	}
+}
+
+static void fz_drop_css_selector(fz_context *ctx, fz_css_selector *sel)
+{
+	while (sel)
+	{
+		fz_css_selector *next = sel->next;
+		fz_free(ctx, sel->name);
+		fz_drop_css_condition(ctx, sel->cond);
+		fz_drop_css_selector(ctx, sel->left);
+		fz_drop_css_selector(ctx, sel->right);
+		fz_free(ctx, sel);
+		sel = next;
+	}
+}
+
+static void fz_drop_css_property(fz_context *ctx, fz_css_property *prop)
+{
+	while (prop)
+	{
+		fz_css_property *next = prop->next;
+		fz_free(ctx, prop->name);
+		fz_drop_css_value(ctx, prop->value);
+		fz_free(ctx, prop);
+		prop = next;
+	}
+}
+
+void fz_drop_css(fz_context *ctx, fz_css_rule *rule)
+{
+	while (rule)
+	{
+		fz_css_rule *next = rule->next;
+		fz_drop_css_selector(ctx, rule->selector);
+		fz_drop_css_property(ctx, rule->declaration);
+		fz_drop_css_property(ctx, rule->garbage);
+		fz_free(ctx, rule);
+		rule = next;
+	}
+}
+
+static void css_lex_next(struct lexbuf *buf)
+{
+	buf->c = *(buf->s++);
+	if (buf->c == '\n')
+		++buf->line;
+}
+
+static void css_lex_init(fz_context *ctx, struct lexbuf *buf, const char *s, const char *file)
+{
+	buf->ctx = ctx;
+	buf->s = s;
+	buf->c = 0;
+	buf->file = file;
+	buf->line = 1;
+	css_lex_next(buf);
+
+	buf->color = 0;
+	buf->string_len = 0;
+}
+
+static int iswhite(int c)
+{
+	return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\f';
+}
+
+static int isnmstart(int c)
+{
+	return c == '\\' || c == '_' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+		(c >= 128 && c <= 255);
+}
+
+static int isnmchar(int c)
+{
+	return c == '\\' || c == '_' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+		(c >= '0' && c <= '9') || c == '-' || (c >= 128 && c <= 255);
+}
+
+static void css_push_char(struct lexbuf *buf, int c)
+{
+	if (buf->string_len + 1 >= nelem(buf->string))
+		fz_css_error(buf, "token too long");
+	buf->string[buf->string_len++] = c;
+}
+
+static int css_lex_accept(struct lexbuf *buf, int t)
+{
+	if (buf->c == t)
+	{
+		css_lex_next(buf);
+		return 1;
+	}
+	return 0;
+}
+
+static void css_lex_expect(struct lexbuf *buf, int t)
+{
+	if (!css_lex_accept(buf, t))
+		fz_css_error(buf, "unexpected character");
+}
+
+static int ishex(int c, int *v)
+{
+	if (c >= '0' && c <= '9')
+	{
+		*v = c - '0';
+		return 1;
+	}
+	if (c >= 'A' && c <= 'F')
+	{
+		*v = c - 'A' + 0xA;
+		return 1;
+	}
+	if (c >= 'a' && c <= 'f')
+	{
+		*v = c - 'a' + 0xA;
+		return 1;
+	}
+	return 0;
+}
+
+static int css_lex_accept_hex(struct lexbuf *buf, int *v)
+{
+	if (ishex(buf->c, v))
+	{
+		css_lex_next(buf);
+		return 1;
+	}
+	return 0;
+}
+
+static int css_lex_number(struct lexbuf *buf)
+{
+	while (buf->c >= '0' && buf->c <= '9')
+	{
+		css_push_char(buf, buf->c);
+		css_lex_next(buf);
+	}
+
+	if (css_lex_accept(buf, '.'))
+	{
+		css_push_char(buf, '.');
+		while (buf->c >= '0' && buf->c <= '9')
+		{
+			css_push_char(buf, buf->c);
+			css_lex_next(buf);
+		}
+	}
+
+	if (css_lex_accept(buf, '%'))
+	{
+		css_push_char(buf, '%');
+		css_push_char(buf, 0);
+		return CSS_PERCENT;
+	}
+
+	if (isnmstart(buf->c))
+	{
+		css_push_char(buf, buf->c);
+		css_lex_next(buf);
+		while (isnmchar(buf->c))
+		{
+			css_push_char(buf, buf->c);
+			css_lex_next(buf);
+		}
+		css_push_char(buf, 0);
+		return CSS_LENGTH;
+	}
+
+	css_push_char(buf, 0);
+	return CSS_NUMBER;
+}
+
+static int css_lex_keyword(struct lexbuf *buf)
+{
+	while (isnmchar(buf->c))
+	{
+		css_push_char(buf, buf->c);
+		css_lex_next(buf);
+	}
+	css_push_char(buf, 0);
+	return CSS_KEYWORD;
+}
+
+static int css_lex_string(struct lexbuf *buf, int q)
+{
+	while (buf->c && buf->c != q)
+	{
+		if (css_lex_accept(buf, '\\'))
+		{
+			if (css_lex_accept(buf, 'n'))
+				css_push_char(buf, '\n');
+			else if (css_lex_accept(buf, 'r'))
+				css_push_char(buf, '\r');
+			else if (css_lex_accept(buf, 'f'))
+				css_push_char(buf, '\f');
+			else if (css_lex_accept(buf, '\f'))
+				/* line continuation */ ;
+			else if (css_lex_accept(buf, '\n'))
+				/* line continuation */ ;
+			else if (css_lex_accept(buf, '\r'))
+				css_lex_accept(buf, '\n');
+			else
+			{
+				css_push_char(buf, buf->c);
+				css_lex_next(buf);
+			}
+		}
+		else
+		{
+			css_push_char(buf, buf->c);
+			css_lex_next(buf);
+		}
+	}
+	css_lex_expect(buf, q);
+	css_push_char(buf, 0);
+	return CSS_STRING;
+}
+
+static int css_lex(struct lexbuf *buf)
+{
+	int t;
+
+	// TODO: keyword escape sequences
+
+	buf->string_len = 0;
+
+	while (buf->c)
+	{
+restart:
+		while (iswhite(buf->c))
+			css_lex_next(buf);
+
+		if (buf->c == 0)
+			break;
+
+		if (css_lex_accept(buf, '/'))
+		{
+			if (css_lex_accept(buf, '*'))
+			{
+				while (buf->c)
+				{
+					if (css_lex_accept(buf, '*'))
+					{
+						while (buf->c == '*')
+							css_lex_next(buf);
+						if (css_lex_accept(buf, '/'))
+							goto restart;
+					}
+					css_lex_next(buf);
+				}
+				fz_css_error(buf, "unterminated comment");
+			}
+			return '/';
+		}
+
+		if (css_lex_accept(buf, '<'))
+		{
+			if (css_lex_accept(buf, '!'))
+			{
+				css_lex_expect(buf, '-');
+				css_lex_expect(buf, '-');
+				continue; /* ignore CDO */
+			}
+			return '<';
+		}
+
+		if (css_lex_accept(buf, '-'))
+		{
+			if (css_lex_accept(buf, '-'))
+			{
+				css_lex_expect(buf, '>');
+				continue; /* ignore CDC */
+			}
+			if (buf->c >= '0' && buf->c <= '9')
+			{
+				css_push_char(buf, '-');
+				return css_lex_number(buf);
+			}
+			if (isnmstart(buf->c))
+			{
+				css_push_char(buf, '-');
+				css_push_char(buf, buf->c);
+				css_lex_next(buf);
+				return css_lex_keyword(buf);
+			}
+			return '-';
+		}
+
+		if (css_lex_accept(buf, '+'))
+		{
+			if (buf->c >= '0' && buf->c <= '9')
+				return css_lex_number(buf);
+			return '+';
+		}
+
+		if (css_lex_accept(buf, '.'))
+		{
+			if (buf->c >= '0' && buf->c <= '9')
+			{
+				css_push_char(buf, '.');
+				return css_lex_number(buf);
+			}
+			return '.';
+		}
+
+		if (css_lex_accept(buf, '#'))
+		{
+			int a, b, c, d, e, f;
+			if (!css_lex_accept_hex(buf, &a)) goto colorerror;
+			if (!css_lex_accept_hex(buf, &b)) goto colorerror;
+			if (!css_lex_accept_hex(buf, &c)) goto colorerror;
+			if (css_lex_accept_hex(buf, &d))
+			{
+				if (!css_lex_accept_hex(buf, &e)) goto colorerror;
+				if (!css_lex_accept_hex(buf, &f)) goto colorerror;
+				buf->color = (a << 20) | (b << 16) | (c << 12) | (d << 8) | (e << 4) | f;
+			}
+			else
+			{
+				buf->color = (a << 20) | (b << 12) | (c << 4);
+			}
+			sprintf(buf->string, "%06x", buf->color); // XXX
+			return CSS_COLOR;
+colorerror:
+			fz_css_error(buf, "invalid color");
+		}
+
+		if (css_lex_accept(buf, '"'))
+			return css_lex_string(buf, '"');
+		if (css_lex_accept(buf, '\''))
+			return css_lex_string(buf, '\'');
+
+		if (buf->c >= '0' && buf->c <= '9')
+			return css_lex_number(buf);
+
+		if (css_lex_accept(buf, 'u'))
+		{
+			if (css_lex_accept(buf, 'r'))
+			{
+				if (css_lex_accept(buf, 'l'))
+				{
+					if (css_lex_accept(buf, '('))
+					{
+						// string or url
+						css_lex_expect(buf, ')');
+						return CSS_URI;
+					}
+					css_push_char(buf, 'u');
+					css_push_char(buf, 'r');
+					css_push_char(buf, 'l');
+					return css_lex_keyword(buf);
+				}
+				css_push_char(buf, 'u');
+				css_push_char(buf, 'r');
+				return css_lex_keyword(buf);
+			}
+			css_push_char(buf, 'u');
+			return css_lex_keyword(buf);
+		}
+
+		if (isnmstart(buf->c))
+		{
+			css_push_char(buf, buf->c);
+			css_lex_next(buf);
+			return css_lex_keyword(buf);
+		}
+
+		t = buf->c;
+		css_lex_next(buf);
+		return t;
+	}
+	return EOF;
+}
+
+static void next(struct lexbuf *buf)
+{
+	buf->lookahead = css_lex(buf);
+}
+
+static int accept(struct lexbuf *buf, int t)
+{
+	if (buf->lookahead == t)
+	{
+		next(buf);
+		return 1;
+	}
+	return 0;
+}
+
+static void expect(struct lexbuf *buf, int t)
+{
+	if (accept(buf, t))
+		return;
+	fz_css_error(buf, "unexpected token");
+}
+
+static int iscond(int t)
+{
+	return t == ':' || t == '.' || t == '#' || t == '[';
+}
+
+static fz_css_value *parse_value_list(struct lexbuf *buf);
+
+static fz_css_value *parse_value(struct lexbuf *buf)
+{
+	fz_css_value *v;
+
+	if (buf->lookahead == CSS_KEYWORD)
+	{
+		v = fz_new_css_value(buf->ctx, CSS_KEYWORD, buf->string);
+		next(buf);
+
+		if (accept(buf, '('))
+		{
+			v->type = '(';
+			v->args = parse_value_list(buf);
+			expect(buf, ')');
+		}
+
+		return v;
+	}
+
+	switch (buf->lookahead)
+	{
+	case CSS_NUMBER:
+	case CSS_LENGTH:
+	case CSS_PERCENT:
+	case CSS_STRING:
+	case CSS_COLOR:
+	case CSS_URI:
+		v = fz_new_css_value(buf->ctx, buf->lookahead, buf->string);
+		next(buf);
+		return v;
+	}
+
+	if (accept(buf, ','))
+		return fz_new_css_value(buf->ctx, ',', ",");
+	if (accept(buf, '/'))
+		return fz_new_css_value(buf->ctx, '/', "/");
+
+	fz_css_error(buf, "expected value");
+}
+
+static fz_css_value *parse_value_list(struct lexbuf *buf)
+{
+	fz_css_value *head, *tail;
+
+	head = tail = NULL;
+
+	while (buf->lookahead != '}' && buf->lookahead != ';' && buf->lookahead != '!' &&
+			buf->lookahead != ')' && buf->lookahead != EOF)
+	{
+		if (!head)
+			head = tail = parse_value(buf);
+		else
+			tail = tail->next = parse_value(buf);
+	}
+
+	return head;
+}
+
+static fz_css_property *parse_declaration(struct lexbuf *buf)
+{
+	fz_css_property *p;
+
+	if (buf->lookahead != CSS_KEYWORD)
+		fz_css_error(buf, "expected keyword in property");
+	p = fz_new_css_property(buf->ctx, buf->string, NULL, 0);
+	next(buf);
+
+	expect(buf, ':');
+
+	p->value = parse_value_list(buf);
+
+	/* !important */
+	if (accept(buf, '!'))
+		expect(buf, CSS_KEYWORD);
+
+	return p;
+}
+
+static fz_css_property *parse_declaration_list(struct lexbuf *buf)
+{
+	fz_css_property *head, *tail;
+
+	if (buf->lookahead == '}' || buf->lookahead == EOF)
+		return NULL;
+
+	head = tail = parse_declaration(buf);
+
+	while (accept(buf, ';'))
+	{
+		if (buf->lookahead != '}' && buf->lookahead != ';' && buf->lookahead != EOF)
+		{
+			tail = tail->next = parse_declaration(buf);
+		}
+	}
+
+	return head;
+}
+
+static char *parse_attrib_value(struct lexbuf *buf)
+{
+	char *s;
+
+	if (buf->lookahead == CSS_KEYWORD || buf->lookahead == CSS_STRING)
+	{
+		s = fz_strdup(buf->ctx, buf->string);
+		next(buf);
+		return s;
+	}
+
+	fz_css_error(buf, "expected attribute value");
+}
+
+static fz_css_condition *parse_condition(struct lexbuf *buf)
+{
+	fz_css_condition *c;
+
+	if (accept(buf, ':'))
+	{
+		if (buf->lookahead != CSS_KEYWORD)
+			fz_css_error(buf, "expected keyword after ':'");
+		c = fz_new_css_condition(buf->ctx, ':', "pseudo", buf->string);
+		next(buf);
+		return c;
+	}
+
+	if (accept(buf, '.'))
+	{
+		if (buf->lookahead != CSS_KEYWORD)
+			fz_css_error(buf, "expected keyword after '.'");
+		c = fz_new_css_condition(buf->ctx, '.', "class", buf->string);
+		next(buf);
+		return c;
+	}
+
+	if (accept(buf, '#'))
+	{
+		if (buf->lookahead != CSS_KEYWORD)
+			fz_css_error(buf, "expected keyword after '#'");
+		c = fz_new_css_condition(buf->ctx, '#', "id", buf->string);
+		next(buf);
+		return c;
+	}
+
+	if (accept(buf, '['))
+	{
+		if (buf->lookahead != CSS_KEYWORD)
+			fz_css_error(buf, "expected keyword after '['");
+
+		c = fz_new_css_condition(buf->ctx, '[', buf->string, NULL);
+		next(buf);
+
+		if (accept(buf, '='))
+		{
+			c->type = '=';
+			c->val = parse_attrib_value(buf);
+		}
+		else if (accept(buf, '|'))
+		{
+			expect(buf, '=');
+			c->type = '|';
+			c->val = parse_attrib_value(buf);
+		}
+		else if (accept(buf, '~'))
+		{
+			expect(buf, '=');
+			c->type = '~';
+			c->val = parse_attrib_value(buf);
+		}
+
+		expect(buf, ']');
+
+		return c;
+	}
+
+	fz_css_error(buf, "expected condition");
+}
+
+static fz_css_condition *parse_condition_list(struct lexbuf *buf)
+{
+	fz_css_condition *head, *tail;
+
+	head = tail = parse_condition(buf);
+	while (iscond(buf->lookahead))
+	{
+		tail = tail->next = parse_condition(buf);
+	}
+	return head;
+}
+
+static fz_css_selector *parse_simple_selector(struct lexbuf *buf)
+{
+	fz_css_selector *s;
+
+	if (accept(buf, '*'))
+	{
+		s = fz_new_css_selector(buf->ctx, NULL);
+		if (iscond(buf->lookahead))
+			s->cond = parse_condition_list(buf);
+		return s;
+	}
+	else if (buf->lookahead == CSS_KEYWORD)
+	{
+		s = fz_new_css_selector(buf->ctx, buf->string);
+		next(buf);
+		if (iscond(buf->lookahead))
+			s->cond = parse_condition_list(buf);
+		return s;
+	}
+	else if (iscond(buf->lookahead))
+	{
+		s = fz_new_css_selector(buf->ctx, NULL);
+		s->cond = parse_condition_list(buf);
+		return s;
+	}
+
+	fz_css_error(buf, "expected selector");
+}
+
+static fz_css_selector *parse_adjacent_selector(struct lexbuf *buf)
+{
+	fz_css_selector *s, *a, *b;
+
+	a = parse_simple_selector(buf);
+	if (accept(buf, '+'))
+	{
+		b = parse_adjacent_selector(buf);
+		s = fz_new_css_selector(buf->ctx, NULL);
+		s->combine = '+';
+		s->left = a;
+		s->right = b;
+		return s;
+	}
+	return a;
+}
+
+static fz_css_selector *parse_child_selector(struct lexbuf *buf)
+{
+	fz_css_selector *s, *a, *b;
+
+	a = parse_adjacent_selector(buf);
+	if (accept(buf, '>'))
+	{
+		b = parse_child_selector(buf);
+		s = fz_new_css_selector(buf->ctx, NULL);
+		s->combine = '>';
+		s->left = a;
+		s->right = b;
+		return s;
+	}
+	return a;
+}
+
+static fz_css_selector *parse_descendant_selector(struct lexbuf *buf)
+{
+	fz_css_selector *s, *a, *b;
+
+	a = parse_child_selector(buf);
+	if (buf->lookahead != ',' && buf->lookahead != '{' && buf->lookahead != EOF)
+	{
+		b = parse_descendant_selector(buf);
+		s = fz_new_css_selector(buf->ctx, NULL);
+		s->combine = ' ';
+		s->left = a;
+		s->right = b;
+		return s;
+	}
+	return a;
+}
+
+static fz_css_selector *parse_selector_list(struct lexbuf *buf)
+{
+	fz_css_selector *head, *tail;
+
+	head = tail = parse_descendant_selector(buf);
+	while (accept(buf, ','))
+	{
+		tail = tail->next = parse_descendant_selector(buf);
+	}
+	return head;
+}
+
+static fz_css_rule *parse_rule(struct lexbuf *buf)
+{
+	fz_css_selector *s;
+	fz_css_property *p;
+
+	s = parse_selector_list(buf);
+	expect(buf, '{');
+	p = parse_declaration_list(buf);
+	expect(buf, '}');
+	return fz_new_css_rule(buf->ctx, s, p);
+}
+
+static void parse_at_rule(struct lexbuf *buf)
+{
+	expect(buf, CSS_KEYWORD);
+
+	/* skip until '{' or ';' */
+	while (buf->lookahead != EOF)
+	{
+		if (accept(buf, ';'))
+			return;
+		if (accept(buf, '{'))
+		{
+			int depth = 1;
+			while (buf->lookahead != EOF && depth > 0)
+			{
+				if (accept(buf, '{'))
+					++depth;
+				else if (accept(buf, '}'))
+					--depth;
+				else
+					next(buf);
+			}
+			return;
+		}
+		next(buf);
+	}
+}
+
+static fz_css_rule *parse_stylesheet(struct lexbuf *buf, fz_css_rule *chain)
+{
+	fz_css_rule *rule, **nextp, *tail;
+
+	tail = chain;
+	if (tail)
+	{
+		while (tail->next)
+			tail = tail->next;
+		nextp = &tail->next;
+	}
+	else
+	{
+		nextp = &tail;
+	}
+
+	while (buf->lookahead != EOF)
+	{
+		if (accept(buf, '@'))
+		{
+			parse_at_rule(buf);
+		}
+		else
+		{
+			rule = *nextp = parse_rule(buf);
+			nextp = &rule->next;
+		}
+	}
+
+	return chain ? chain : tail;
+}
+
+fz_css_property *fz_parse_css_properties(fz_context *ctx, const char *source)
+{
+	struct lexbuf buf;
+	css_lex_init(ctx, &buf, source, "<inline>");
+	next(&buf);
+	return parse_declaration_list(&buf);
+}
+
+fz_css_rule *fz_parse_css(fz_context *ctx, fz_css_rule *chain, const char *source, const char *file)
+{
+	struct lexbuf buf;
+	css_lex_init(ctx, &buf, source, file);
+	next(&buf);
+	return parse_stylesheet(&buf, chain);
+}
diff --git a/source/html/epub-doc.c b/source/html/epub-doc.c
new file mode 100644
index 00000000..69963ff0
--- /dev/null
+++ b/source/html/epub-doc.c
@@ -0,0 +1,326 @@
+#include "mupdf/html.h"
+
+#define DEFW (450)
+#define DEFH (600)
+#define DEFEM (12)
+
+typedef struct epub_document_s epub_document;
+typedef struct epub_chapter_s epub_chapter;
+typedef struct epub_page_s epub_page;
+
+struct epub_document_s
+{
+	fz_document super;
+	fz_archive *zip;
+	fz_html_font_set *set;
+	float page_w, page_h, em;
+	int count;
+	epub_chapter *spine;
+};
+
+struct epub_chapter_s
+{
+	int start;
+	fz_html *box;
+	epub_chapter *next;
+};
+
+struct epub_page_s
+{
+	fz_page super;
+	epub_document *doc;
+	int number;
+};
+
+static void
+epub_layout(fz_context *ctx, fz_document *doc_, float w, float h, float em)
+{
+	epub_document *doc = (epub_document*)doc_;
+	epub_chapter *ch;
+
+	doc->page_w = w;
+	doc->page_h = h;
+	doc->em = em;
+
+	printf("epub: laying out chapters.\n");
+	for (ch = doc->spine; ch; ch = ch->next)
+		fz_layout_html(ctx, ch->box, w, h, em);
+	printf("epub: done.\n");
+}
+
+static int
+epub_count_pages(fz_context *ctx, fz_document *doc_)
+{
+	epub_document *doc = (epub_document*)doc_;
+	epub_chapter *ch;
+	int count = 0;
+	for (ch = doc->spine; ch; ch = ch->next)
+		count += ceilf(ch->box->h / doc->page_h);
+	return count;
+}
+
+static void
+epub_drop_page_imp(fz_context *ctx, fz_page *page_)
+{
+}
+
+static fz_rect *
+epub_bound_page(fz_context *ctx, fz_page *page_, fz_rect *bbox)
+{
+	epub_page *page = (epub_page*)page_;
+	epub_document *doc = page->doc;
+	bbox->x0 = 0;
+	bbox->y0 = 0;
+	bbox->x1 = doc->page_w;
+	bbox->y1 = doc->page_h;
+	return bbox;
+}
+
+static void
+epub_run_page(fz_context *ctx, fz_page *page_, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
+{
+	epub_page *page = (epub_page*)page_;
+	epub_document *doc = page->doc;
+	epub_chapter *ch;
+	int n = page->number;
+
+	int count = 0;
+	for (ch = doc->spine; ch; ch = ch->next)
+	{
+		int cn = ceilf(ch->box->h / doc->page_h);
+		if (n < count + cn)
+		{
+			fz_draw_html(ctx, ch->box, (n-count) * doc->page_h, (n-count+1) * doc->page_h, dev, ctm);
+			break;
+		}
+		count += cn;
+	}
+}
+
+static fz_page *
+epub_load_page(fz_context *ctx, fz_document *doc_, int number)
+{
+	epub_document *doc = (epub_document*)doc_;
+	epub_page *page = fz_new_page(ctx, sizeof *page);
+	page->super.bound_page = epub_bound_page;
+	page->super.run_page_contents = epub_run_page;
+	page->super.drop_page_imp = epub_drop_page_imp;
+	page->doc = doc;
+	page->number = number;
+	return (fz_page*)page;
+}
+
+static void
+epub_close_document(fz_context *ctx, fz_document *doc_)
+{
+	epub_document *doc = (epub_document*)doc_;
+	epub_chapter *ch, *next;
+	ch = doc->spine;
+	while (ch)
+	{
+		next = ch->next;
+		fz_drop_html(ctx, ch->box);
+		fz_free(ctx, ch);
+		ch = next;
+	}
+	fz_drop_archive(ctx, doc->zip);
+	fz_drop_html_font_set(ctx, doc->set);
+	fz_free(ctx, doc);
+}
+
+static const char *
+rel_path_from_idref(fz_xml *manifest, const char *idref)
+{
+	fz_xml *item;
+	if (!idref)
+		return NULL;
+	item = fz_xml_find_down(manifest, "item");
+	while (item)
+	{
+		const char *id = fz_xml_att(item, "id");
+		if (id && !strcmp(id, idref))
+			return fz_xml_att(item, "href");
+		item = fz_xml_find_next(item, "item");
+	}
+	return NULL;
+}
+
+static const char *
+path_from_idref(char *path, fz_xml *manifest, const char *base_uri, const char *idref, int n)
+{
+	const char *rel_path = rel_path_from_idref(manifest, idref);
+	if (!rel_path)
+	{
+		path[0] = 0;
+		return NULL;
+	}
+	fz_strlcpy(path, base_uri, n);
+	fz_strlcat(path, "/", n);
+	fz_strlcat(path, rel_path, n);
+	return fz_cleanname(path);
+}
+
+static epub_chapter *
+epub_parse_chapter(fz_context *ctx, epub_document *doc, const char *path)
+{
+	fz_archive *zip = doc->zip;
+	fz_buffer *buf;
+	epub_chapter *ch;
+	char base_uri[2048];
+
+	fz_dirname(base_uri, path, sizeof base_uri);
+
+	buf = fz_read_archive_entry(ctx, zip, path);
+	fz_write_buffer_byte(ctx, buf, 0);
+
+	ch = fz_malloc_struct(ctx, epub_chapter);
+	ch->box = fz_parse_html(ctx, doc->set, zip, base_uri, buf, NULL);
+	ch->next = NULL;
+
+	fz_drop_buffer(ctx, buf);
+
+	return ch;
+}
+
+static void
+epub_parse_header(fz_context *ctx, epub_document *doc)
+{
+	fz_archive *zip = doc->zip;
+	fz_buffer *buf;
+	fz_xml *container_xml, *content_opf;
+	fz_xml *container, *rootfiles, *rootfile;
+	fz_xml *package, *manifest, *spine, *itemref;
+	char base_uri[2048];
+	const char *full_path;
+	char ncx[2048], s[2048];
+	epub_chapter *head, *tail;
+
+	/* parse META-INF/container.xml to find OPF */
+
+	buf = fz_read_archive_entry(ctx, zip, "META-INF/container.xml");
+	fz_write_buffer_byte(ctx, buf, 0);
+	container_xml = fz_parse_xml(ctx, buf->data, buf->len, 0);
+	fz_drop_buffer(ctx, buf);
+
+	container = fz_xml_find(container_xml, "container");
+	rootfiles = fz_xml_find_down(container, "rootfiles");
+	rootfile = fz_xml_find_down(rootfiles, "rootfile");
+	full_path = fz_xml_att(rootfile, "full-path");
+	if (!full_path)
+		fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find root file in EPUB");
+
+	printf("epub: found root: %s\n", full_path);
+
+	fz_dirname(base_uri, full_path, sizeof base_uri);
+
+	/* parse OPF to find NCX and spine */
+
+	buf = fz_read_archive_entry(ctx, zip, full_path);
+	fz_write_buffer_byte(ctx, buf, 0);
+	content_opf = fz_parse_xml(ctx, buf->data, buf->len, 0);
+	fz_drop_buffer(ctx, buf);
+
+	package = fz_xml_find(content_opf, "package");
+	manifest = fz_xml_find_down(package, "manifest");
+	spine = fz_xml_find_down(package, "spine");
+
+	if (path_from_idref(ncx, manifest, base_uri, fz_xml_att(spine, "toc"), sizeof ncx))
+	{
+		/* TODO: parse NCX to create fz_outline */
+		printf("epub: found outline: %s\n", ncx);
+	}
+
+	head = tail = NULL;
+	itemref = fz_xml_find_down(spine, "itemref");
+	while (itemref)
+	{
+		if (path_from_idref(s, manifest, base_uri, fz_xml_att(itemref, "idref"), sizeof s))
+		{
+			printf("epub: found spine %s\n", s);
+			if (!head)
+				head = tail = epub_parse_chapter(ctx, doc, s);
+			else
+				tail = tail->next = epub_parse_chapter(ctx, doc, s);
+		}
+		itemref = fz_xml_find_next(itemref, "itemref");
+	}
+
+	doc->spine = head;
+
+	printf("epub: done.\n");
+
+	fz_drop_xml(ctx, container_xml);
+	fz_drop_xml(ctx, content_opf);
+}
+
+static epub_document *
+epub_init(fz_context *ctx, fz_archive *zip)
+{
+	epub_document *doc;
+
+	doc = fz_malloc_struct(ctx, epub_document);
+	doc->zip = zip;
+	doc->set = fz_new_html_font_set(ctx);
+
+	doc->super.close = epub_close_document;
+	doc->super.layout = epub_layout;
+	doc->super.count_pages = epub_count_pages;
+	doc->super.load_page = epub_load_page;
+
+	fz_try(ctx)
+	{
+		epub_parse_header(ctx, doc);
+		epub_layout(ctx, (fz_document*)doc, DEFW, DEFH, DEFEM);
+	}
+	fz_catch(ctx)
+	{
+		epub_close_document(ctx, (fz_document*)doc);
+		fz_rethrow(ctx);
+	}
+
+	return doc;
+}
+
+static epub_document *
+epub_open_document_with_stream(fz_context *ctx, fz_stream *file)
+{
+	return epub_init(ctx, fz_open_archive_with_stream(ctx, file));
+}
+
+static epub_document *
+epub_open_document(fz_context *ctx, const char *filename)
+{
+	if (strstr(filename, "META-INF/container.xml") || strstr(filename, "META-INF\\container.xml"))
+	{
+		char dirname[2048], *p;
+		fz_strlcpy(dirname, filename, sizeof dirname);
+		p = strstr(dirname, "META-INF");
+		*p = 0;
+		if (!dirname[0])
+			fz_strlcpy(dirname, ".", sizeof dirname);
+		return epub_init(ctx, fz_open_directory(ctx, dirname));
+	}
+
+	return epub_init(ctx, fz_open_archive(ctx, filename));
+}
+
+static int
+epub_recognize(fz_context *doc, const char *magic)
+{
+	char *ext = strrchr(magic, '.');
+	if (ext)
+		if (!fz_strcasecmp(ext, ".epub"))
+			return 100;
+	if (strstr(magic, "META-INF/container.xml") || strstr(magic, "META-INF\\container.xml"))
+		return 200;
+	if (!strcmp(magic, "application/epub+zip"))
+		return 100;
+	return 0;
+}
+
+fz_document_handler epub_document_handler =
+{
+	(fz_document_recognize_fn *)&epub_recognize,
+	(fz_document_open_fn *)&epub_open_document,
+	(fz_document_open_with_stream_fn *)&epub_open_document_with_stream
+};
diff --git a/source/html/html-doc.c b/source/html/html-doc.c
new file mode 100644
index 00000000..7217f74c
--- /dev/null
+++ b/source/html/html-doc.c
@@ -0,0 +1,166 @@
+#include "mupdf/html.h"
+
+#define DEFW (450)
+#define DEFH (600)
+#define DEFEM (12)
+
+typedef struct html_document_s html_document;
+typedef struct html_page_s html_page;
+
+struct html_document_s
+{
+	fz_document super;
+	fz_archive *zip;
+	fz_html_font_set *set;
+	float page_w, page_h, em;
+	fz_html *box;
+};
+
+struct html_page_s
+{
+	fz_page super;
+	html_document *doc;
+	int number;
+};
+
+static void
+htdoc_close_document(fz_context *ctx, fz_document *doc_)
+{
+	html_document *doc = (html_document*)doc_;
+	fz_drop_archive(ctx, doc->zip);
+	fz_drop_html(ctx, doc->box);
+	fz_drop_html_font_set(ctx, doc->set);
+	fz_free(ctx, doc);
+}
+
+static int
+htdoc_count_pages(fz_context *ctx, fz_document *doc_)
+{
+	html_document *doc = (html_document*)doc_;
+	int count = ceilf(doc->box->h / doc->page_h);
+	return count;
+}
+
+static void
+htdoc_layout(fz_context *ctx, fz_document *doc_, float w, float h, float em)
+{
+	html_document *doc = (html_document*)doc_;
+	doc->page_w = w;
+	doc->page_h = h;
+	doc->em = em;
+	fz_layout_html(ctx, doc->box, w, h, em);
+}
+
+static void
+htdoc_drop_page_imp(fz_context *ctx, fz_page *page_)
+{
+}
+
+static fz_rect *
+htdoc_bound_page(fz_context *ctx, fz_page *page_, fz_rect *bbox)
+{
+	html_page *page = (html_page*)page_;
+	html_document *doc = page->doc;
+	bbox->x0 = bbox->y0 = 0;
+	bbox->x1 = doc->page_w;
+	bbox->y1 = doc->page_h;
+	return bbox;
+}
+
+static void
+htdoc_run_page(fz_context *ctx, fz_page *page_, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
+{
+	html_page *page = (html_page*)page_;
+	html_document *doc = page->doc;
+	int n = page->number;
+	fz_draw_html(ctx, doc->box, n * doc->page_h, (n+1) * doc->page_h, dev, ctm);
+}
+
+static fz_page *
+htdoc_load_page(fz_context *ctx, fz_document *doc_, int number)
+{
+	html_document *doc = (html_document*)doc_;
+	html_page *page = fz_new_page(ctx, sizeof *page);
+	page->super.bound_page = htdoc_bound_page;
+	page->super.run_page_contents = htdoc_run_page;
+	page->super.drop_page_imp = htdoc_drop_page_imp;
+	page->doc = doc;
+	page->number = number;
+	return (fz_page*)page;
+}
+
+static html_document *
+htdoc_open_document_with_stream(fz_context *ctx, fz_stream *file)
+{
+	html_document *doc;
+	fz_buffer *buf;
+
+	doc = fz_malloc_struct(ctx, html_document);
+	doc->zip = fz_open_directory(ctx, ".");
+	doc->set = fz_new_html_font_set(ctx);
+
+	doc->super.close = htdoc_close_document;
+	doc->super.layout = htdoc_layout;
+	doc->super.count_pages = htdoc_count_pages;
+	doc->super.load_page = htdoc_load_page;
+
+	buf = fz_read_all(ctx, file, 0);
+	fz_write_buffer_byte(ctx, buf, 0);
+	doc->box = fz_parse_html(ctx, doc->set, doc->zip, ".", buf, NULL);
+	fz_drop_buffer(ctx, buf);
+
+	htdoc_layout(ctx, (fz_document*)doc, DEFW, DEFH, DEFEM);
+
+	return doc;
+}
+
+static html_document *
+htdoc_open_document(fz_context *ctx, const char *filename)
+{
+	char dirname[2048];
+	fz_buffer *buf;
+	html_document *doc;
+
+	fz_dirname(dirname, filename, sizeof dirname);
+
+	doc = fz_malloc_struct(ctx, html_document);
+	doc->zip = fz_open_directory(ctx, dirname);
+	doc->set = fz_new_html_font_set(ctx);
+
+	doc->super.close = htdoc_close_document;
+	doc->super.layout = htdoc_layout;
+	doc->super.count_pages = htdoc_count_pages;
+	doc->super.load_page = htdoc_load_page;
+
+	buf = fz_read_file(ctx, filename);
+	fz_write_buffer_byte(ctx, buf, 0);
+	doc->box = fz_parse_html(ctx, doc->set, doc->zip, ".", buf, NULL);
+	fz_drop_buffer(ctx, buf);
+
+	htdoc_layout(ctx, (fz_document*)doc, DEFW, DEFH, DEFEM);
+
+	return doc;
+}
+
+static int
+htdoc_recognize(fz_context *doc, const char *magic)
+{
+	char *ext = strrchr(magic, '.');
+
+	if (ext)
+	{
+		if (!fz_strcasecmp(ext, ".xml") || !fz_strcasecmp(ext, ".xhtml") || !fz_strcasecmp(ext, ".html"))
+			return 100;
+	}
+	if (!strcmp(magic, "application/html+xml") || !strcmp(magic, "application/xml") || !strcmp(magic, "text/xml"))
+		return 100;
+
+	return 0;
+}
+
+fz_document_handler html_document_handler =
+{
+	(fz_document_recognize_fn *)&htdoc_recognize,
+	(fz_document_open_fn *)&htdoc_open_document,
+	(fz_document_open_with_stream_fn *)&htdoc_open_document_with_stream
+};
diff --git a/source/html/html-font.c b/source/html/html-font.c
new file mode 100644
index 00000000..ae6568c9
--- /dev/null
+++ b/source/html/html-font.c
@@ -0,0 +1,47 @@
+#include "mupdf/html.h"
+#include "mupdf/pdf.h" /* for pdf_lookup_builtin_font */
+
+static const char *font_names[16] =
+{
+	"Times-Roman", "Times-Italic", "Times-Bold", "Times-BoldItalic",
+	"Helvetica", "Helvetica-Oblique", "Helvetica-Bold", "Helvetica-BoldOblique",
+	"Courier", "Courier-Oblique", "Courier-Bold", "Courier-BoldOblique",
+	"Courier", "Courier-Oblique", "Courier-Bold", "Courier-BoldOblique",
+};
+
+fz_font *
+fz_load_html_font(fz_context *ctx, fz_html_font_set *set,
+	const char *family, const char *variant, const char *style, const char *weight)
+{
+	unsigned char *data;
+	unsigned int size;
+
+	int is_mono = !strcmp(family, "monospace");
+	int is_sans = !strcmp(family, "sans-serif");
+	int is_bold = !strcmp(weight, "bold") || !strcmp(weight, "bolder") || atoi(weight) > 400;
+	int is_italic = !strcmp(style, "italic") || !strcmp(style, "oblique");
+
+	int idx = is_mono * 8 + is_sans * 4 + is_bold * 2 + is_italic;
+	if (!set->fonts[idx])
+	{
+		data = pdf_lookup_builtin_font(ctx, font_names[idx], &size);
+		if (!data)
+			fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load html font: %s", font_names[idx]);
+		set->fonts[idx] = fz_new_font_from_memory(ctx, font_names[idx], data, size, 0, 1);
+	}
+
+	return set->fonts[idx];
+}
+
+fz_html_font_set *fz_new_html_font_set(fz_context *ctx)
+{
+	return fz_malloc_struct(ctx, fz_html_font_set);
+}
+
+void fz_drop_html_font_set(fz_context *ctx, fz_html_font_set *set)
+{
+	int i;
+	for (i = 0; i < nelem(set->fonts); ++i)
+		fz_drop_font(ctx, set->fonts[i]);
+	fz_free(ctx, set);
+}
diff --git a/source/html/html-layout.c b/source/html/html-layout.c
new file mode 100644
index 00000000..5a1a3157
--- /dev/null
+++ b/source/html/html-layout.c
@@ -0,0 +1,909 @@
+#include "mupdf/html.h"
+
+enum { T, R, B, L };
+
+static const char *default_css =
+"html,address,blockquote,body,dd,div,dl,dt,h1,h2,h3,h4,h5,h6,ol,p,ul,center,hr,pre{display:block}"
+"span{display:inline}"
+"li{display:list-item}"
+"head{display:none}"
+"body{margin:1em}"
+"h1{font-size:2em;margin:.67em 0}"
+"h2{font-size:1.5em;margin:.75em 0}"
+"h3{font-size:1.17em;margin:.83em 0}"
+"h4,p,blockquote,ul,ol,dl,dir,menu{margin:1.12em 0}"
+"h5{font-size:.83em;margin:1.5em 0}"
+"h6{font-size:.67em;margin:1.67em 0}"
+"h1,h2,h3,h4,h5,h6,b,strong{font-weight:bold}"
+"blockquote{margin-left:40px;margin-right:40px}"
+"i,cite,em,var,address{font-style:italic}"
+"pre,tt,code,kbd,samp{font-family:monospace}"
+"pre{white-space:pre}"
+"big{font-size:1.17em}"
+"small,sub,sup{font-size:.83em}"
+"sub{vertical-align:sub}"
+"sup{vertical-align:super}"
+"s,strike,del{text-decoration:line-through}"
+"hr{border-width:thin;border-color:black;border-style:solid;margin:.5em 0}"
+"ol,ul,dir,menu,dd{margin-left:40px}"
+"ol{list-style-type:decimal}"
+"ol ul,ul ol,ul ul,ol ol{margin-top:0;margin-bottom:0}"
+"u,ins{text-decoration:underline}"
+"center{text-align:center}"
+"svg{display:none}"
+"a{color:blue}"
+;
+
+static int iswhite(int c)
+{
+	return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+}
+
+static void fz_drop_html_flow(fz_context *ctx, fz_html_flow *flow)
+{
+	while (flow)
+	{
+		fz_html_flow *next = flow->next;
+		if (flow->type == FLOW_WORD)
+			fz_free(ctx, flow->text);
+		if (flow->type == FLOW_IMAGE)
+			fz_drop_image(ctx, flow->image);
+		fz_free(ctx, flow);
+		flow = next;
+	}
+}
+
+static fz_html_flow *add_flow(fz_context *ctx, fz_html *top, fz_css_style *style, int type)
+{
+	fz_html_flow *flow = fz_malloc_struct(ctx, fz_html_flow);
+	flow->type = type;
+	flow->style = style;
+	*top->flow_tail = flow;
+	top->flow_tail = &flow->next;
+	return flow;
+}
+
+static void add_flow_space(fz_context *ctx, fz_html *top, fz_css_style *style)
+{
+	fz_html_flow *flow;
+
+	/* delete space at the beginning of the line */
+	if (!top->flow_head)
+		return;
+
+	flow = add_flow(ctx, top, style, FLOW_GLUE);
+	flow->text = " ";
+	flow->broken_text = "";
+}
+
+static void add_flow_word(fz_context *ctx, fz_html *top, fz_css_style *style, const char *a, const char *b)
+{
+	fz_html_flow *flow = add_flow(ctx, top, style, FLOW_WORD);
+	flow->text = fz_malloc(ctx, b - a + 1);
+	memcpy(flow->text, a, b - a);
+	flow->text[b - a] = 0;
+}
+
+static void add_flow_image(fz_context *ctx, fz_html *top, fz_css_style *style, fz_image *img)
+{
+	fz_html_flow *flow = add_flow(ctx, top, style, FLOW_IMAGE);
+	flow->image = fz_keep_image(ctx, img);
+}
+
+static void generate_text(fz_context *ctx, fz_html *box, const char *text)
+{
+	fz_html *flow = box;
+	while (flow->type != BOX_FLOW)
+		flow = flow->up;
+
+	while (*text)
+	{
+		if (iswhite(*text))
+		{
+			++text;
+			while (iswhite(*text))
+				++text;
+			add_flow_space(ctx, flow, &box->style);
+		}
+		if (*text)
+		{
+			const char *mark = text++;
+			while (*text && !iswhite(*text))
+				++text;
+			add_flow_word(ctx, flow, &box->style, mark, text);
+		}
+	}
+}
+
+static void generate_image(fz_context *ctx, fz_archive *zip, const char *base_uri, fz_html *box, const char *src)
+{
+	fz_image *img;
+	fz_buffer *buf;
+	char path[2048];
+
+	fz_html *flow = box;
+	while (flow->type != BOX_FLOW)
+		flow = flow->up;
+
+	fz_strlcpy(path, base_uri, sizeof path);
+	fz_strlcat(path, "/", sizeof path);
+	fz_strlcat(path, src, sizeof path);
+	fz_cleanname(path);
+
+	fz_try(ctx)
+	{
+		buf = fz_read_archive_entry(ctx, zip, path);
+		img = fz_new_image_from_buffer(ctx, buf);
+		fz_drop_buffer(ctx, buf);
+
+		add_flow_image(ctx, flow, &box->style, img);
+	}
+	fz_catch(ctx)
+	{
+		const char *alt = "[image]";
+		fz_warn(ctx, "html: cannot add image src='%s'", src);
+		add_flow_word(ctx, flow, &box->style, alt, alt + 7);
+	}
+}
+
+static void init_box(fz_context *ctx, fz_html *box)
+{
+	box->type = BOX_BLOCK;
+	box->x = box->y = 0;
+	box->w = box->h = 0;
+
+	box->up = NULL;
+	box->last = NULL;
+	box->down = NULL;
+	box->next = NULL;
+
+	box->flow_head = NULL;
+	box->flow_tail = &box->flow_head;
+
+	fz_default_css_style(ctx, &box->style);
+}
+
+void fz_drop_html(fz_context *ctx, fz_html *box)
+{
+	while (box)
+	{
+		fz_html *next = box->next;
+		fz_drop_html_flow(ctx, box->flow_head);
+		fz_drop_html(ctx, box->down);
+		fz_free(ctx, box);
+		box = next;
+	}
+}
+
+static fz_html *new_box(fz_context *ctx)
+{
+	fz_html *box = fz_malloc_struct(ctx, fz_html);
+	init_box(ctx, box);
+	return box;
+}
+
+static void insert_box(fz_context *ctx, fz_html *box, int type, fz_html *top)
+{
+	box->type = type;
+
+	box->up = top;
+
+	if (top)
+	{
+		if (!top->last)
+		{
+			top->down = top->last = box;
+		}
+		else
+		{
+			top->last->next = box;
+			top->last = box;
+		}
+	}
+}
+
+static fz_html *insert_block_box(fz_context *ctx, fz_html *box, fz_html *top)
+{
+	if (top->type == BOX_BLOCK)
+	{
+		insert_box(ctx, box, BOX_BLOCK, top);
+	}
+	else if (top->type == BOX_FLOW)
+	{
+		while (top->type != BOX_BLOCK)
+			top = top->up;
+		insert_box(ctx, box, BOX_BLOCK, top);
+	}
+	else if (top->type == BOX_INLINE)
+	{
+		while (top->type != BOX_BLOCK)
+			top = top->up;
+		insert_box(ctx, box, BOX_BLOCK, top);
+	}
+	return top;
+}
+
+static fz_html *insert_break_box(fz_context *ctx, fz_html *box, fz_html *top)
+{
+	if (top->type == BOX_BLOCK)
+	{
+		insert_box(ctx, box, BOX_BREAK, top);
+	}
+	else if (top->type == BOX_FLOW)
+	{
+		while (top->type != BOX_BLOCK)
+			top = top->up;
+		insert_box(ctx, box, BOX_BREAK, top);
+	}
+	else if (top->type == BOX_INLINE)
+	{
+		while (top->type != BOX_BLOCK)
+			top = top->up;
+		insert_box(ctx, box, BOX_BREAK, top);
+	}
+	return top;
+}
+
+static void insert_inline_box(fz_context *ctx, fz_html *box, fz_html *top)
+{
+	if (top->type == BOX_BLOCK)
+	{
+		if (top->last && top->last->type == BOX_FLOW)
+		{
+			insert_box(ctx, box, BOX_INLINE, top->last);
+		}
+		else
+		{
+			fz_html *flow = new_box(ctx);
+			flow->is_first_flow = !top->last;
+			insert_box(ctx, flow, BOX_FLOW, top);
+			insert_box(ctx, box, BOX_INLINE, flow);
+		}
+	}
+	else if (top->type == BOX_FLOW)
+	{
+		insert_box(ctx, box, BOX_INLINE, top);
+	}
+	else if (top->type == BOX_INLINE)
+	{
+		insert_box(ctx, box, BOX_INLINE, top);
+	}
+}
+
+static void generate_boxes(fz_context *ctx, fz_html_font_set *set, fz_archive *zip, const char *base_uri,
+	fz_xml *node, fz_html *top, fz_css_rule *rule, fz_css_match *up_match)
+{
+	fz_css_match match;
+	fz_html *box;
+	const char *tag;
+	int display;
+
+	while (node)
+	{
+		match.up = up_match;
+		match.count = 0;
+
+		tag = fz_xml_tag(node);
+		if (tag)
+		{
+			fz_match_css(ctx, &match, rule, node);
+
+			display = fz_get_css_match_display(&match);
+
+			if (!strcmp(tag, "br"))
+			{
+				box = new_box(ctx);
+				fz_apply_css_style(ctx, set, &box->style, &match);
+				top = insert_break_box(ctx, box, top);
+			}
+
+			else if (!strcmp(tag, "img"))
+			{
+				const char *src = fz_xml_att(node, "src");
+				if (src)
+				{
+					box = new_box(ctx);
+					fz_apply_css_style(ctx, set, &box->style, &match);
+					insert_inline_box(ctx, box, top);
+					generate_image(ctx, zip, base_uri, box, src);
+				}
+			}
+
+			else if (display != DIS_NONE)
+			{
+				box = new_box(ctx);
+				fz_apply_css_style(ctx, set, &box->style, &match);
+
+				if (display == DIS_BLOCK)
+				{
+					top = insert_block_box(ctx, box, top);
+				}
+				else if (display == DIS_LIST_ITEM)
+				{
+					top = insert_block_box(ctx, box, top);
+				}
+				else if (display == DIS_INLINE)
+				{
+					insert_inline_box(ctx, box, top);
+				}
+				else
+				{
+					fz_warn(ctx, "unknown box display type");
+					insert_box(ctx, box, BOX_BLOCK, top);
+				}
+
+				if (fz_xml_down(node))
+					generate_boxes(ctx, set, zip, base_uri, fz_xml_down(node), box, rule, &match);
+
+				// TODO: remove empty flow boxes
+			}
+		}
+		else
+		{
+			if (top->type != BOX_INLINE)
+			{
+				box = new_box(ctx);
+				insert_inline_box(ctx, box, top);
+				box->style = top->style;
+				generate_text(ctx, box, fz_xml_text(node));
+			}
+			else
+			{
+				generate_text(ctx, top, fz_xml_text(node));
+			}
+		}
+
+		node = fz_xml_next(node);
+	}
+}
+
+static void measure_image(fz_context *ctx, fz_html_flow *node, float w, float h)
+{
+	float xs = 1, ys = 1, s = 1;
+	node->x = 0;
+	node->y = 0;
+	if (node->image->w > w)
+		xs = w / node->image->w;
+	if (node->image->h > h)
+		ys = h / node->image->h;
+	s = fz_min(xs, ys);
+	node->w = node->image->w * s;
+	node->h = node->image->h * s;
+}
+
+static void measure_word(fz_context *ctx, fz_html_flow *node, float em)
+{
+	const char *s;
+	int c, g;
+	float w;
+
+	em = fz_from_css_number(node->style->font_size, em, em);
+	node->x = 0;
+	node->y = 0;
+	node->h = fz_from_css_number_scale(node->style->line_height, em, em, em);
+
+	w = 0;
+	s = node->text;
+	while (*s)
+	{
+		s += fz_chartorune(&c, s);
+		g = fz_encode_character(ctx, node->style->font, c);
+		w += fz_advance_glyph(ctx, node->style->font, g) * em;
+	}
+	node->w = w;
+	node->em = em;
+}
+
+static float measure_line(fz_html_flow *node, fz_html_flow *end, float *baseline)
+{
+	float max_a = 0, max_d = 0, h = 0;
+	while (node != end)
+	{
+		if (node->type == FLOW_IMAGE)
+		{
+			if (node->h > max_a)
+				max_a = node->h;
+		}
+		else
+		{
+			float a = node->em * 0.8;
+			float d = node->em * 0.2;
+			if (a > max_a) max_a = a;
+			if (d > max_d) max_d = d;
+		}
+		if (node->h > h) h = node->h;
+		if (max_a + max_d > h) h = max_a + max_d;
+		node = node->next;
+	}
+	*baseline = max_a + (h - max_a - max_d) / 2;
+	return h;
+}
+
+static void layout_line(fz_context *ctx, float indent, float page_w, float line_w, int align, fz_html_flow *node, fz_html_flow *end, fz_html *box, float baseline)
+{
+	float x = box->x + indent;
+	float y = box->y + box->h;
+	float slop = page_w - line_w;
+	float justify = 0;
+	float va;
+	int n = 0;
+
+	if (align == TA_JUSTIFY)
+	{
+		fz_html_flow *it;
+		for (it = node; it != end; it = it->next)
+			if (it->type == FLOW_GLUE)
+				++n;
+		justify = slop / n;
+	}
+	else if (align == TA_RIGHT)
+		x += slop;
+	else if (align == TA_CENTER)
+		x += slop / 2;
+
+	while (node != end)
+	{
+		switch (node->style->vertical_align)
+		{
+		default:
+		case VA_BASELINE:
+			va = 0;
+			break;
+		case VA_SUB:
+			va = node->em * 0.2f;
+			break;
+		case VA_SUPER:
+			va = node->em * -0.3f;
+			break;
+		}
+		node->x = x;
+		if (node->type == FLOW_IMAGE)
+			node->y = y + baseline - node->h;
+		else
+			node->y = y + baseline + va;
+		x += node->w;
+		if (node->type == FLOW_GLUE)
+			x += justify;
+		node = node->next;
+	}
+}
+
+static fz_html_flow *find_next_glue(fz_html_flow *node, float *w)
+{
+	while (node && node->type == FLOW_GLUE)
+	{
+		*w += node->w;
+		node = node->next;
+	}
+	while (node && node->type != FLOW_GLUE)
+	{
+		*w += node->w;
+		node = node->next;
+	}
+	return node;
+}
+
+static fz_html_flow *find_next_word(fz_html_flow *node, float *w)
+{
+	while (node && node->type == FLOW_GLUE)
+	{
+		*w += node->w;
+		node = node->next;
+	}
+	return node;
+}
+
+static void layout_flow(fz_context *ctx, fz_html *box, fz_html *top, float em, float page_h)
+{
+	fz_html_flow *node, *line_start, *word_start, *word_end, *line_end;
+	float glue_w;
+	float word_w;
+	float line_w;
+	float indent;
+	float avail, line_h;
+	float baseline;
+	int align;
+
+	em = fz_from_css_number(box->style.font_size, em, em);
+	indent = box->is_first_flow ? fz_from_css_number(top->style.text_indent, em, top->w) : 0;
+	align = top->style.text_align;
+
+	box->x = top->x;
+	box->y = top->y + top->h;
+	box->w = top->w;
+	box->h = 0;
+
+	if (!box->flow_head)
+		return;
+
+	for (node = box->flow_head; node; node = node->next)
+		if (node->type == FLOW_IMAGE)
+			measure_image(ctx, node, top->w, page_h);
+		else
+			measure_word(ctx, node, em);
+
+	line_start = find_next_word(box->flow_head, &glue_w);
+	line_end = NULL;
+
+	line_w = indent;
+	word_w = 0;
+	word_start = line_start;
+	while (word_start)
+	{
+		word_end = find_next_glue(word_start, &word_w);
+		if (line_w + word_w <= top->w)
+		{
+			line_w += word_w;
+			glue_w = 0;
+			line_end = word_end;
+			word_start = find_next_word(word_end, &glue_w);
+			word_w = glue_w;
+		}
+		else
+		{
+			avail = page_h - fmodf(box->y + box->h, page_h);
+			line_h = measure_line(line_start, line_end, &baseline);
+			if (line_h > avail)
+				box->h += avail;
+			layout_line(ctx, indent, top->w, line_w, align, line_start, line_end, box, baseline);
+			box->h += line_h;
+			word_start = find_next_word(line_end, &glue_w);
+			line_start = word_start;
+			line_end = NULL;
+			indent = 0;
+			line_w = 0;
+			word_w = 0;
+		}
+	}
+
+	/* don't justify the last line of a paragraph */
+	if (align == TA_JUSTIFY)
+		align = TA_LEFT;
+
+	if (line_start)
+	{
+		avail = page_h - fmodf(box->y + box->h, page_h);
+		line_h = measure_line(line_start, line_end, &baseline);
+		if (line_h > avail)
+			box->h += avail;
+		layout_line(ctx, indent, top->w, line_w, align, line_start, line_end, box, baseline);
+		box->h += line_h;
+	}
+}
+
+static void layout_block(fz_context *ctx, fz_html *box, fz_html *top, float em, float top_collapse_margin, float page_h)
+{
+	fz_html *child;
+	float box_collapse_margin;
+	int prev_br;
+
+	float *margin = box->margin;
+	float *border = box->border;
+	float *padding = box->padding;
+
+	em = fz_from_css_number(box->style.font_size, em, em);
+
+	margin[0] = fz_from_css_number(box->style.margin[0], em, top->w);
+	margin[1] = fz_from_css_number(box->style.margin[1], em, top->w);
+	margin[2] = fz_from_css_number(box->style.margin[2], em, top->w);
+	margin[3] = fz_from_css_number(box->style.margin[3], em, top->w);
+
+	padding[0] = fz_from_css_number(box->style.padding[0], em, top->w);
+	padding[1] = fz_from_css_number(box->style.padding[1], em, top->w);
+	padding[2] = fz_from_css_number(box->style.padding[2], em, top->w);
+	padding[3] = fz_from_css_number(box->style.padding[3], em, top->w);
+
+	if (box->style.border_style)
+	{
+		border[0] = fz_from_css_number(box->style.border_width[0], em, top->w);
+		border[1] = fz_from_css_number(box->style.border_width[1], em, top->w);
+		border[2] = fz_from_css_number(box->style.border_width[2], em, top->w);
+		border[3] = fz_from_css_number(box->style.border_width[3], em, top->w);
+	}
+	else
+		border[0] = border[1] = border[2] = border[3] = 0;
+
+	if (padding[T] == 0 && border[T] == 0)
+		box_collapse_margin = margin[T];
+	else
+		box_collapse_margin = 0;
+
+	if (margin[T] > top_collapse_margin)
+		margin[T] -= top_collapse_margin;
+	else
+		margin[T] = 0;
+
+	box->x = top->x + margin[L] + border[L] + padding[L];
+	box->y = top->y + top->h + margin[T] + border[T] + padding[T];
+	box->w = top->w - (margin[L] + margin[R] + border[L] + border[R] + padding[L] + padding[R]);
+	box->h = 0;
+
+	prev_br = 0;
+	for (child = box->down; child; child = child->next)
+	{
+		if (child->type == BOX_BLOCK)
+		{
+			layout_block(ctx, child, box, em, box_collapse_margin, page_h);
+			box->h += child->h +
+				child->padding[T] + child->padding[B] +
+				child->border[T] + child->border[B] +
+				child->margin[T] + child->margin[B];
+			box_collapse_margin = child->margin[B];
+			prev_br = 0;
+		}
+		else if (child->type == BOX_BREAK)
+		{
+			/* TODO: interaction with page breaks */
+			if (prev_br)
+				box->h += fz_from_css_number_scale(box->style.line_height, em, em, em);
+			prev_br = 1;
+		}
+		else if (child->type == BOX_FLOW)
+		{
+			layout_flow(ctx, child, box, em, page_h);
+			if (child->h > 0)
+			{
+				box->h += child->h;
+				box_collapse_margin = 0;
+				prev_br = 0;
+			}
+		}
+	}
+
+	if (padding[B] == 0 && border[B] == 0)
+	{
+		if (margin[B] > 0)
+		{
+			box->h -= box_collapse_margin;
+			if (margin[B] < box_collapse_margin)
+				margin[B] = box_collapse_margin;
+		}
+	}
+}
+
+static void draw_flow_box(fz_context *ctx, fz_html *box, float page_top, float page_bot, fz_device *dev, const fz_matrix *ctm)
+{
+	fz_html_flow *node;
+	fz_text *text;
+	fz_matrix trm;
+	const char *s;
+	float color[3];
+	float x, y;
+	int c, g;
+
+	for (node = box->flow_head; node; node = node->next)
+	{
+		if (node->type == FLOW_IMAGE)
+		{
+			if (node->y > page_bot || node->y + node->h < page_top)
+				continue;
+		}
+		else
+		{
+			if (node->y > page_bot || node->y < page_top)
+				continue;
+		}
+
+		if (node->type == FLOW_WORD)
+		{
+			fz_scale(&trm, node->em, -node->em);
+			text = fz_new_text(ctx, node->style->font, &trm, 0);
+
+			x = node->x;
+			y = node->y;
+			s = node->text;
+			while (*s)
+			{
+				s += fz_chartorune(&c, s);
+				g = fz_encode_character(ctx, node->style->font, c);
+				fz_add_text(ctx, text, g, c, x, y);
+				x += fz_advance_glyph(ctx, node->style->font, g) * node->em;
+			}
+
+			color[0] = node->style->color.r / 255.0f;
+			color[1] = node->style->color.g / 255.0f;
+			color[2] = node->style->color.b / 255.0f;
+
+			fz_fill_text(ctx, dev, text, ctm, fz_device_rgb(ctx), color, 1);
+
+			fz_drop_text(ctx, text);
+		}
+		else if (node->type == FLOW_IMAGE)
+		{
+			fz_matrix local_ctm = *ctm;
+			fz_pre_translate(&local_ctm, node->x, node->y);
+			fz_pre_scale(&local_ctm, node->w, node->h);
+			fz_fill_image(ctx, dev, node->image, &local_ctm, 1);
+		}
+	}
+}
+
+static void draw_rect(fz_context *ctx, fz_device *dev, const fz_matrix *ctm, float *rgba, float x0, float y0, float x1, float y1)
+{
+	fz_path *path = fz_new_path(ctx);
+
+	fz_moveto(ctx, path, x0, y0);
+	fz_lineto(ctx, path, x1, y0);
+	fz_lineto(ctx, path, x1, y1);
+	fz_lineto(ctx, path, x0, y1);
+	fz_closepath(ctx, path);
+
+	fz_fill_path(ctx, dev, path, 0, ctm, fz_device_rgb(ctx), rgba, rgba[3]);
+
+	fz_drop_path(ctx, path);
+}
+
+static void draw_block_box(fz_context *ctx, fz_html *box, float page_top, float page_bot, fz_device *dev, const fz_matrix *ctm)
+{
+	float x0, y0, x1, y1;
+	float color[4];
+
+	// TODO: background fill
+	// TODO: border stroke
+
+	float *border = box->border;
+	float *padding = box->padding;
+
+	x0 = box->x - padding[L];
+	y0 = box->y - padding[T];
+	x1 = box->x + box->w + padding[R];
+	y1 = box->y + box->h + padding[B];
+
+	if (y0 > page_bot || y1 < page_top)
+		return;
+
+	if (box->style.background_color.a > 0)
+	{
+		color[0] = box->style.background_color.r / 255.0f;
+		color[1] = box->style.background_color.g / 255.0f;
+		color[2] = box->style.background_color.b / 255.0f;
+		color[3] = box->style.background_color.a / 255.0f;
+		draw_rect(ctx, dev, ctm, color, x0, y0, x1, y1);
+	}
+
+	if (box->style.border_color.a > 0)
+	{
+		color[0] = box->style.border_color.r / 255.0f;
+		color[1] = box->style.border_color.g / 255.0f;
+		color[2] = box->style.border_color.b / 255.0f;
+		color[3] = box->style.border_color.a / 255.0f;
+		if (border[T] > 0)
+			draw_rect(ctx, dev, ctm, color, x0 - border[L], y0 - border[T], x1 + border[R], y0);
+		if (border[B] > 0)
+			draw_rect(ctx, dev, ctm, color, x0 - border[L], y1, x1 + border[R], y1 + border[B]);
+		if (border[L] > 0)
+			draw_rect(ctx, dev, ctm, color, x0 - border[L], y0 - border[T], x0, y1 + border[B]);
+		if (border[R] > 0)
+			draw_rect(ctx, dev, ctm, color, x1, y0 - border[T], x1 + border[R], y1 + border[B]);
+	}
+
+	for (box = box->down; box; box = box->next)
+	{
+		switch (box->type)
+		{
+		case BOX_BLOCK: draw_block_box(ctx, box, page_top, page_bot, dev, ctm); break;
+		case BOX_FLOW: draw_flow_box(ctx, box, page_top, page_bot, dev, ctm); break;
+		}
+	}
+}
+
+void
+fz_draw_html(fz_context *ctx, fz_html *box, float page_top, float page_bot, fz_device *dev, const fz_matrix *inctm)
+{
+	fz_matrix ctm = *inctm;
+	fz_pre_translate(&ctm, 0, -page_top);
+	draw_block_box(ctx, box, page_top, page_bot, dev, &ctm);
+}
+
+static char *concat_text(fz_context *ctx, fz_xml *root)
+{
+	fz_xml  *node;
+	int i = 0, n = 1;
+	char *s;
+	for (node = fz_xml_down(root); node; node = fz_xml_next(node))
+	{
+		const char *text = fz_xml_text(node);
+		n += text ? strlen(text) : 0;
+	}
+	s = fz_malloc(ctx, n);
+	for (node = fz_xml_down(root); node; node = fz_xml_next(node))
+	{
+		const char *text = fz_xml_text(node);
+		if (text)
+		{
+			n = strlen(text);
+			memcpy(s+i, text, n);
+			i += n;
+		}
+	}
+	s[i] = 0;
+	return s;
+}
+
+static fz_css_rule *
+html_load_css(fz_context *ctx, fz_archive *zip, const char *base_uri, fz_css_rule *css, fz_xml *root)
+{
+	fz_xml *node;
+	fz_buffer *buf;
+	char path[2048];
+
+	for (node = root; node; node = fz_xml_next(node))
+	{
+		const char *tag = fz_xml_tag(node);
+		if (tag && !strcmp(tag, "link"))
+		{
+			char *rel = fz_xml_att(node, "rel");
+			if (rel && !strcasecmp(rel, "stylesheet"))
+			{
+				char *type = fz_xml_att(node, "type");
+				if ((type && !strcmp(type, "text/css")) || !type)
+				{
+					char *href = fz_xml_att(node, "href");
+					if (href)
+					{
+						fz_strlcpy(path, base_uri, sizeof path);
+						fz_strlcat(path, "/", sizeof path);
+						fz_strlcat(path, href, sizeof path);
+						fz_cleanname(path);
+
+						buf = fz_read_archive_entry(ctx, zip, path);
+						fz_write_buffer_byte(ctx, buf, 0);
+						css = fz_parse_css(ctx, css, (char*)buf->data, path);
+						fz_drop_buffer(ctx, buf);
+					}
+				}
+			}
+		}
+		if (tag && !strcmp(tag, "style"))
+		{
+			char *s = concat_text(ctx, node);
+			css = fz_parse_css(ctx, css, s, "<style>");
+			fz_free(ctx, s);
+		}
+		if (fz_xml_down(node))
+			css = html_load_css(ctx, zip, base_uri, css, fz_xml_down(node));
+	}
+	return css;
+}
+
+void
+fz_layout_html(fz_context *ctx, fz_html *box, float w, float h, float em)
+{
+	fz_html page_box;
+
+	init_box(ctx, &page_box);
+	page_box.w = w;
+	page_box.h = 0;
+
+	layout_block(ctx, box, &page_box, em, 0, h);
+}
+
+fz_html *
+fz_parse_html(fz_context *ctx, fz_html_font_set *set, fz_archive *zip, const char *base_uri, fz_buffer *buf, const char *user_css)
+{
+	fz_xml *xml;
+	fz_css_rule *css;
+	fz_css_match match;
+	fz_html *box;
+
+	xml = fz_parse_xml(ctx, buf->data, buf->len, 1);
+
+	css = fz_parse_css(ctx, NULL, default_css, "<default>");
+	if (user_css)
+		css = fz_parse_css(ctx, NULL, user_css, "<user>");
+	css = html_load_css(ctx, zip, base_uri, css, xml);
+
+	// print_rules(css);
+
+	box = new_box(ctx);
+
+	match.up = NULL;
+	match.count = 0;
+
+	generate_boxes(ctx, set, zip, base_uri, xml, box, css, &match);
+
+	fz_drop_css(ctx, css);
+	fz_drop_xml(ctx, xml);
+
+	return box;
+}