WIP: Add a Lua PDF generatorlpg-libqr

Because Lua compiled for C++ might be hard to find,
provide a wrap.  Only GitHub releases seem to contain onelua.c,
which is a very handy file.

WIP: Add documentation, actually get rid of the libqr copy.

13 files changed, 1433 insertions, 5 deletions

diff --git a/LICENSE b/LICENSE
index 7511f3e..689d036 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2017 - 2024, Přemysl Eric Janouch <p@janouch.name>
+Copyright (c) 2017 - 2025, Přemysl Eric Janouch <p@janouch.name>
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted.
diff --git a/README.adoc b/README.adoc
index 10e581f..4d738ba 100644
--- a/README.adoc
+++ b/README.adoc
@@ -33,6 +33,8 @@ Runtime dependencies: libcrypto (OpenSSL 1.1 API)
  $ cd builddir
  $ ninja
 
+Go
+~~
 In addition to the C++ version, also included is a native Go port,
 which has enhanced PDF 1.5 support:
 
@@ -56,6 +58,15 @@ Type=^PDF
 Open=%cd %p/extfs-pdf://
 ----
 
+Lua PDF generator
+~~~~~~~~~~~~~~~~~
+Build dependencies:
+ Meson, a C++17 compiler, pkg-config +
+Runtime dependencies:
+ C++ Lua >= 5.2 (custom Meson wrap fallback), cairo, pangocairo
+
+This is a parasitic subproject located in the _lpg_ subdirectory.
+
 Contributing and Support
 ------------------------
 Use https://git.janouch.name/p/pdf-simple-sign to report bugs, request features,
diff --git a/lpg/.clang-format b/lpg/.clang-format
new file mode 100644
index 0000000..339b7e1
--- /dev/null
+++ b/lpg/.clang-format
@@ -0,0 +1,9 @@
+BasedOnStyle: LLVM
+ColumnLimit: 80
+IndentWidth: 4
+TabWidth: 4
+UseTab: ForContinuationAndIndentation
+SpaceAfterCStyleCast: true
+AlignAfterOpenBracket: DontAlign
+AlignOperands: DontAlign
+SpacesBeforeTrailingComments: 2
diff --git a/lpg/libqr.c b/lpg/libqr.c
new file mode 100644
index 0000000..19f9788
--- /dev/null
+++ b/lpg/libqr.c
@@ -0,0 +1,14 @@
+// Easier to build this way
+#include "libqr/bitmap.c"
+#include "libqr/bitstream.c"
+#undef MIN
+#include "libqr/constants.c"
+#include "libqr/code-common.c"
+#include "libqr/code-create.c"
+#include "libqr/code-layout.c"
+#define get_px get_px_
+#include "libqr/code-parse.c"
+#include "libqr/data-common.c"
+#include "libqr/data-create.c"
+#include "libqr/data-parse.c"
+#include "libqr/galois.c"
diff --git a/lpg/lpg.cpp b/lpg/lpg.cpp
new file mode 100644
index 0000000..4bebd42
--- /dev/null
+++ b/lpg/lpg.cpp
@@ -0,0 +1,1129 @@
+//
+// lpg: Lua PDF generator
+//
+// Copyright (c) 2017 - 2025, Přemysl Eric Janouch <p@janouch.name>
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+// SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+// OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+// CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+//
+
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
+
+#include <cairo.h>
+#include <cairo-pdf.h>
+#include <pango/pangocairo.h>
+
+#include <qr/bitmap.h>
+#include <qr/bitstream.h>
+#include <qr/code.h>
+#include <qr/data.h>
+#include <qr/version.h>
+
+#include <algorithm>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+#include <arpa/inet.h>
+
+using namespace std;
+using attribute = variant<string, double>;
+
+#define DefWidget(name) struct name : public Widget
+struct Widget {
+	virtual ~Widget() {}
+
+	unordered_map<string, attribute> attributes;
+	using attribute_map = decltype(attributes);
+	Widget *setattr(string key, attribute_map::mapped_type value) {
+		attributes.insert({key, value});
+		return this;
+	}
+
+	optional<attribute> getattr(const string &name) {
+		if (auto it = attributes.find("_" + name); it != attributes.end())
+			return {it->second};
+		if (auto it = attributes.find(name); it != attributes.end())
+			return {it->second};
+		return {};
+	}
+
+	/// Top-down attribute propagation.
+	virtual void apply_attributes(const attribute_map &attrs = {}) {
+		for (const auto &kv : attrs)
+			if (*kv.first.c_str() != '_')
+				attributes.insert(kv);
+	}
+
+	// We need CAIRO_ROUND_GLYPH_POS_OFF to be set in font options,
+	// which can only be done internally, se we have to pass a context that
+	// is based on an actual PDF surface.
+	//
+	// Font maps also need some kind of a backend, like Cairo.
+
+	/// Compute and return space required for the widget's contents.
+	virtual tuple<double, double> prepare([[maybe_unused]] PangoContext *pc) {
+		return {0, 0};
+	}
+
+	/// Compute and return space required for the widget's contents,
+	/// given a fixed size (favouring any dimension).
+	virtual tuple<double, double> prepare_for_size(PangoContext *pc,
+		[[maybe_unused]] double width, [[maybe_unused]] double height) {
+		return prepare(pc);
+	}
+
+	/// Render to the context within the designated space, no clipping.
+	virtual void render([[maybe_unused]] cairo_t *cr, [[maybe_unused]] double w,
+		[[maybe_unused]] double h) {}
+};
+
+/// Special container that basically just fucks with the system right now.
+DefWidget(Frame) {
+	unique_ptr<Widget> child;
+	Frame(Widget *w) : child(w) {}
+
+	virtual void apply_attributes(const attribute_map &attrs) override {
+		Widget::apply_attributes(attrs);
+		child->apply_attributes(attributes);
+	}
+
+	virtual tuple<double, double> prepare(PangoContext *pc) override {
+		auto d = child->prepare(pc);
+		if (auto v = getattr("w_override"))
+			get<0>(d) = get<double>(*v);
+		if (auto v = getattr("h_override"))
+			get<1>(d) = get<double>(*v);
+		return d;
+	}
+
+	virtual void render(cairo_t *cr, double w, double h) override {
+		cairo_save(cr);
+
+		if (auto v = getattr("color")) {
+			int rgb = get<double>(*v);
+			cairo_set_source_rgb(cr, ((rgb >> 16) & 0xFF) / 255.,
+				((rgb >> 8) & 0xFF) / 255., (rgb & 0xFF) / 255.);
+		}
+
+		child->render(cr, w, h);
+		cairo_restore(cr);
+	}
+};
+
+#define DefContainer(name) struct name : public Container
+DefWidget(Container) {
+	vector<unique_ptr<Widget>> children;
+
+	inline void add() {}
+	template <typename... Args> void add(Widget *w, Args && ...args) {
+		children.push_back(unique_ptr<Widget>(w));
+		add(args...);
+	}
+
+	Container(vector<unique_ptr<Widget>> &&children)
+		: children(std::move(children)) {}
+
+	virtual void apply_attributes(const attribute_map &attrs) override {
+		Widget::apply_attributes(attrs);
+		for (auto &i : children)
+			i->apply_attributes(attributes);
+	}
+};
+
+static void finalize_box(vector<double> &sizes, double available) {
+	double fixed = 0, stretched = 0;
+	for (auto s : sizes) {
+		if (s >= 0)
+			fixed += s;
+		else
+			stretched += s;
+	}
+	if (stretched) {
+		auto factor = max(0., available - fixed) / stretched;
+		for (auto &s : sizes)
+			if (s < 0)
+				s *= factor;
+	} else {
+		// TODO(p): One should be able to *opt in* for this.
+		auto redistribute = max(0., available - fixed) / sizes.size();
+		for (auto &s : sizes)
+			s += redistribute;
+	}
+}
+
+DefContainer(HBox) {
+	HBox(vector<unique_ptr<Widget>> children = {})
+		: Container(std::move(children)) {}
+
+	vector<double> widths;
+	virtual tuple<double, double> prepare(PangoContext *pc) override {
+		double w = 0, h = 0;
+		widths.resize(children.size());
+		for (size_t i = 0; i < children.size(); i++) {
+			auto d = children[i]->prepare(pc);
+			if ((widths[i] = get<0>(d)) > 0)
+				w += widths[i];
+			h = max(h, get<1>(d));
+		}
+		return {w, h};
+	}
+
+	virtual tuple<double, double> prepare_for_size(
+		PangoContext *pc, double width, double height) override {
+		double w = 0, h = 0;
+		widths.resize(children.size());
+		for (size_t i = 0; i < children.size(); i++) {
+			auto d = children[i]->prepare_for_size(pc, width, height);
+			if ((widths[i] = get<0>(d)) > 0)
+				w += widths[i];
+			h = max(h, get<1>(d));
+		}
+		return {w, h};
+	}
+
+	virtual void render(cairo_t *cr, double w, double h) override {
+		finalize_box(widths, w);
+		for (size_t i = 0; i < children.size(); i++) {
+			cairo_save(cr);
+			children[i]->render(cr, widths[i], h);
+			cairo_restore(cr);
+			cairo_translate(cr, widths[i], 0.);
+		}
+	}
+};
+
+DefContainer(VBox) {
+	VBox(vector<unique_ptr<Widget>> children = {})
+		: Container(std::move(children)) {}
+
+	vector<double> heights;
+	virtual tuple<double, double> prepare(PangoContext *pc) override {
+		double w = 0, h = 0;
+		heights.resize(children.size());
+		for (size_t i = 0; i < children.size(); i++) {
+			auto d = children[i]->prepare(pc);
+			if ((heights[i] = get<1>(d)) > 0)
+				h += heights[i];
+			w = max(w, get<0>(d));
+		}
+		return {w, h};
+	}
+
+	virtual tuple<double, double> prepare_for_size(
+		PangoContext *pc, double width, double height) override {
+		double w = 0, h = 0;
+		heights.resize(children.size());
+		for (size_t i = 0; i < children.size(); i++) {
+			auto d = children[i]->prepare_for_size(pc, width, height);
+			if ((heights[i] = get<1>(d)) > 0)
+				h += heights[i];
+			w = max(w, get<0>(d));
+		}
+		return {w, h};
+	}
+
+	virtual void render(cairo_t *cr, double w, double h) override {
+		finalize_box(heights, h);
+		for (size_t i = 0; i < children.size(); i++) {
+			cairo_save(cr);
+			children[i]->render(cr, w, heights[i]);
+			cairo_restore(cr);
+			cairo_translate(cr, 0., heights[i]);
+		}
+	}
+};
+
+/// Fillers just take up space and don't render anything.
+DefWidget(Filler) {
+	double w, h;
+	Filler(double w = -1, double h = -1) : w(w), h(h) {}
+	virtual tuple<double, double> prepare(
+		[[maybe_unused]] PangoContext *pc) override {
+		return {w, h};
+	}
+};
+
+DefWidget(HLine) {
+	double thickness;
+	HLine(double thickness = 1) : thickness(thickness) {}
+	virtual tuple<double, double> prepare(
+		[[maybe_unused]] PangoContext *pc) override {
+		return {-1, thickness};
+	}
+	virtual void render(cairo_t *cr, double w, double h) override {
+		cairo_move_to(cr, 0, h / 2);
+		cairo_line_to(cr, w, h / 2);
+		cairo_set_line_width(cr, thickness);
+		cairo_stroke(cr);
+	}
+};
+
+DefWidget(VLine) {
+	double thickness;
+	VLine(double thickness = 1) : thickness(thickness) {}
+	virtual tuple<double, double> prepare(
+		[[maybe_unused]] PangoContext *pc) override {
+		return {thickness, -1};
+	}
+	virtual void render(cairo_t *cr, double w, double h) override {
+		cairo_move_to(cr, w / 2, 0);
+		cairo_line_to(cr, w / 2, h);
+		cairo_set_line_width(cr, thickness);
+		cairo_stroke(cr);
+	}
+};
+
+DefWidget(Text) {
+	string text;
+	PangoLayout *layout = nullptr;
+	double y_offset = 0.;
+
+	Text(string text = "") : text(text) {}
+	virtual ~Text() override { g_clear_object(&layout); }
+
+	void prepare_layout(PangoContext *pc) {
+		g_clear_object(&layout);
+		layout = pango_layout_new(pc);
+		pango_layout_set_markup(layout, text.c_str(), -1);
+		pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
+
+		auto fd = pango_font_description_new();
+		if (auto v = getattr("fontfamily"))
+			pango_font_description_set_family(fd, get<string>(*v).c_str());
+		if (auto v = getattr("fontsize"))
+			pango_font_description_set_size(fd, get<double>(*v) * PANGO_SCALE);
+		if (auto v = getattr("fontweight"))
+			pango_font_description_set_weight(fd, PangoWeight(get<double>(*v)));
+
+		// We need this for the line-height calculation.
+		auto font_size =
+			double(pango_font_description_get_size(fd)) / PANGO_SCALE;
+		if (!font_size)
+			pango_font_description_set_size(fd, (font_size = 10));
+
+		// Supposedly this is how this shit works.
+		// XXX: This will never work if the markup changes the font size.
+		if (auto v = getattr("lineheight")) {
+			auto increment = get<double>(*v) - 1;
+			y_offset = increment * font_size / 2;
+			pango_layout_set_spacing(
+				layout, increment * font_size * PANGO_SCALE);
+		}
+
+		// FIXME: We don't want to override what's in the markup.
+		pango_layout_set_font_description(layout, fd);
+		pango_font_description_free(fd);
+	}
+
+	virtual tuple<double, double> prepare(PangoContext *pc) override {
+		prepare_layout(pc);
+
+		int w, h;
+		pango_layout_get_size(layout, &w, &h);
+		return {
+			double(w) / PANGO_SCALE, double(h) / PANGO_SCALE + 2 * y_offset};
+	}
+
+	virtual tuple<double, double> prepare_for_size(PangoContext *pc,
+		double width, [[maybe_unused]] double height) override {
+		prepare_layout(pc);
+
+		// It's difficult to get vertical text, so wrap horizontally.
+		pango_layout_set_width(layout, PANGO_SCALE * width);
+
+		int w, h;
+		pango_layout_get_size(layout, &w, &h);
+		return {
+			double(w) / PANGO_SCALE, double(h) / PANGO_SCALE + 2 * y_offset};
+	}
+
+	virtual void render(cairo_t *cr, double w, [[maybe_unused]] double h)
+		override {
+		g_return_if_fail(layout);
+		// Assuming horizontal text, make it span the whole allocation.
+		pango_layout_set_width(layout, PANGO_SCALE * w);
+		pango_cairo_update_layout(cr, layout);
+		cairo_translate(cr, 0, y_offset);
+		pango_cairo_show_layout(cr, layout);
+	}
+};
+
+DefWidget(Link) {
+	string target_uri;
+	unique_ptr<Widget> child;
+
+	Link(const string &target_uri, Widget *w)
+		: target_uri(target_uri), child(w) {}
+
+	virtual void apply_attributes(const attribute_map &attrs) override {
+		Widget::apply_attributes(attrs);
+		child->apply_attributes(attributes);
+	}
+
+	virtual tuple<double, double> prepare(PangoContext *pc) override {
+		return child->prepare(pc);
+	}
+
+	virtual void render(cairo_t *cr, double w, double h) override {
+		cairo_save(cr);
+		cairo_tag_begin(
+			cr, CAIRO_TAG_LINK, ("uri='" + target_uri + "'").c_str());
+		child->render(cr, w, h);
+		cairo_tag_end(cr, CAIRO_TAG_LINK);
+		cairo_restore(cr);
+	}
+};
+
+// --- Pictures ----------------------------------------------------------------
+
+struct image_info {
+	double width = 0., height = 0., dpi_x = 72., dpi_y = 72.;
+};
+
+/// http://libpng.org/pub/png/spec/1.2/PNG-Contents.html
+static bool read_png_info(image_info &info, const char *data, size_t length) {
+	return length >= 24 && !memcmp(data, "\211PNG\r\n\032\n", 8) &&
+		!memcmp(data + 12, "IHDR", 4) &&
+		(info.width = ntohl(*(uint32_t *) (data + 16))) &&
+		(info.height = ntohl(*(uint32_t *) (data + 20)));
+}
+
+DefWidget(Picture) {
+	double w = 0, h = 0;
+	double scale_x = 1., scale_y = 1.;
+	cairo_surface_t *surface = nullptr;
+
+	virtual tuple<double, double> prepare(PangoContext *) override {
+		return {w * scale_x, h * scale_y};
+	}
+
+	virtual void render(cairo_t *cr, double width, double height) override {
+		if (!surface || width <= 0 || height <= 0)
+			return;
+
+		// Stretch to fill horizontal space.
+		auto stretch_x = width / (w * scale_x);
+		double scale_x = this->scale_x * stretch_x;
+		double scale_y = this->scale_y * stretch_x;
+
+		// But scale down so that the picture fits vertically.
+		auto stretch_y = height / (h * scale_y);
+		if (stretch_y < 1.) {
+			scale_x *= stretch_y;
+			scale_y *= stretch_y;
+		}
+
+		// For PDF-A, ISO 19005-3:2012 6.2.8: interpolation is not allowed
+		// (Cairo sets it on by default).
+		bool interpolate = true;
+
+		auto pattern = cairo_pattern_create_for_surface(surface);
+		cairo_pattern_set_filter(
+			pattern, interpolate ? CAIRO_FILTER_GOOD : CAIRO_FILTER_NEAREST);
+
+		// Maybe we should also center the picture or something...
+		cairo_scale(cr, scale_x, scale_y);
+		cairo_set_source(cr, pattern);
+		cairo_paint(cr);
+
+		cairo_pattern_destroy(pattern);
+	}
+
+	static cairo_surface_t *make_surface_png(const string &data) {
+		using CharRange = pair<const char *, const char *>;
+		CharRange iterator{&*data.begin(), &*data.end()};
+		return cairo_image_surface_create_from_png_stream(
+			[](void *closure, unsigned char *data, uint len) {
+				auto i = (CharRange *) closure;
+				if (i->second - i->first < len)
+					return CAIRO_STATUS_READ_ERROR;
+
+				memcpy(data, i->first, len);
+				i->first += len;
+				return CAIRO_STATUS_SUCCESS;
+			},
+			&iterator);
+	}
+
+	// Cairo doesn't support PNGs in PDFs by MIME type,
+	// until then we'll have to parametrize.
+	static function<cairo_surface_t *()> identify(
+		const string &picture, image_info &info) {
+		if (read_png_info(info, picture.data(), picture.length()))
+			return bind(make_surface_png, picture);
+		return nullptr;
+	}
+
+	Picture(const string &filename) {
+		ifstream t{filename};
+		stringstream buffer;
+		buffer << t.rdbuf();
+		string picture = buffer.str();
+
+		image_info info;
+		if (auto make_surface = identify(picture, info)) {
+			surface = make_surface();
+			w = info.width;
+			h = info.height;
+			scale_x = info.dpi_x / 72.;
+			scale_y = info.dpi_y / 72.;
+		}
+	}
+};
+
+// --- QR ----------------------------------------------------------------------
+
+DefWidget(QR) {
+	struct qr_code *code = nullptr;
+	double T = 1.;
+
+	QR(string text, double T) : T(T) {
+		struct qr_data *data = qr_data_create(10 /* version, i.e. size */,
+			QR_EC_LEVEL_M /* 15% correction, 311 chars */,
+			QR_DATA_ALPHA /* alphanumeric and some special characters */,
+			text.c_str(), text.length());
+		if (!data)
+			return;
+
+		code = qr_code_create(data);
+		qr_data_destroy(data);
+	}
+
+	virtual ~QR() override {
+		if (code)
+			qr_code_destroy(code);
+	}
+
+	virtual tuple<double, double> prepare([[maybe_unused]] PangoContext *pc)
+		override {
+		if (!code)
+			return {0, 0};
+
+		return {
+			T * code->modules->width,
+			T * code->modules->height,
+		};
+	}
+
+	virtual void render(cairo_t *cr,
+		[[maybe_unused]] double w, [[maybe_unused]] double h) override {
+		if (!code)
+			return;
+
+		auto line = code->modules->bits;
+		for (size_t y = 0; y < code->modules->height; y++) {
+			for (size_t x = 0; x < code->modules->width; x++) {
+				int mask = 1 << (x % CHAR_BIT);
+				int byte = line[x / CHAR_BIT];
+				if (byte & mask)
+					cairo_rectangle(cr, T * x, T * y, T, T);
+			}
+			line += code->modules->stride;
+		}
+		cairo_fill(cr);
+	}
+};
+
+// --- Lua Widget --------------------------------------------------------------
+
+#define XLUA_WIDGET_METATABLE "widget"
+
+struct LuaWidget {
+	// We might not technically need the unique_ptr.
+	unique_ptr<Widget> widget;
+};
+
+static void xlua_widget_check(lua_State *L, LuaWidget *self) {
+	if (!self->widget)
+		luaL_error(L, "trying to use a consumed widget reference");
+}
+
+static attribute xlua_widget_tovalue(lua_State *L, LuaWidget *self, int idx) {
+	xlua_widget_check(L, self);
+	if (lua_isnumber(L, idx))
+		return lua_tonumber(L, idx);
+	if (lua_isstring(L, idx)) {
+		size_t len = 0;
+		const char *s = lua_tolstring(L, idx, &len);
+		return string(s, len);
+	}
+	luaL_error(L, "expected string or numeric attributes");
+	return {};
+}
+
+static void xlua_widget_set(
+	lua_State *L, LuaWidget *self, Widget *widget, int idx_attrs) {
+	self->widget.reset(widget);
+	if (!idx_attrs)
+		return;
+
+	lua_pushvalue(L, idx_attrs);
+	lua_pushnil(L);
+	while (lua_next(L, -2)) {
+		if (lua_type(L, -2) == LUA_TSTRING) {
+			size_t key_len = 0;
+			const char *key = lua_tolstring(L, -2, &key_len);
+			widget->setattr(
+				string(key, key_len), xlua_widget_tovalue(L, self, -1));
+		}
+		lua_pop(L, 1);
+	}
+	lua_pop(L, 1);
+}
+
+static int xlua_widget_gc(lua_State *L) {
+	auto self = (LuaWidget *) luaL_checkudata(L, 1, XLUA_WIDGET_METATABLE);
+	self->widget.reset(nullptr);
+	return 0;
+}
+
+static int xlua_widget_index(lua_State *L) {
+	auto self = (LuaWidget *) luaL_checkudata(L, 1, XLUA_WIDGET_METATABLE);
+	// In theory, this could also index container children,
+	// but it does not seem practically useful.
+	auto key = luaL_checkstring(L, 2);
+	xlua_widget_check(L, self);
+
+	if (auto it = self->widget->attributes.find(key);
+		it == self->widget->attributes.end())
+		lua_pushnil(L);
+	else if (auto s = get_if<string>(&it->second))
+		lua_pushlstring(L, s->c_str(), s->length());
+	else if (auto n = get_if<double>(&it->second))
+		lua_pushnumber(L, *n);
+	return 1;
+}
+
+static int xlua_widget_newindex(lua_State *L) {
+	auto self = (LuaWidget *) luaL_checkudata(L, 1, XLUA_WIDGET_METATABLE);
+	auto key = luaL_checkstring(L, 2);
+	xlua_widget_check(L, self);
+
+	self->widget->attributes[key] = xlua_widget_tovalue(L, self, 3);
+	return 0;
+}
+
+static luaL_Reg xlua_widget_table[] = {
+	{"__gc",       xlua_widget_gc},
+	{"__index",    xlua_widget_index},
+	{"__newindex", xlua_widget_newindex},
+	{}
+};
+
+// --- Lua Document ------------------------------------------------------------
+
+#define XLUA_DOCUMENT_METATABLE "document"
+
+struct LuaDocument {
+	cairo_t *cr = nullptr;              ///< Cairo
+	cairo_surface_t *pdf = nullptr;     ///< PDF surface
+	PangoContext *pc = nullptr;         ///< Pango context
+
+	double page_width = 0.;             ///< Page width in 72 DPI points
+	double page_height = 0.;            ///< Page height in 72 DPI points
+	double page_margin = 0.;            ///< Page margins in 72 DPI points
+};
+
+static int xlua_document_gc(lua_State *L) {
+	auto self = (LuaDocument *) luaL_checkudata(L, 1, XLUA_DOCUMENT_METATABLE);
+	cairo_destroy(self->cr);
+	g_object_unref(self->pc);
+	return 0;
+}
+
+static int xlua_document_index(lua_State *L) {
+	if (auto key = luaL_checkstring(L, 2); *key == '_')
+		lua_pushnil(L);
+	else
+		luaL_getmetafield(L, 1, key);
+	return 1;
+}
+
+// And probably for links as well.
+#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 15, 4)
+#error "At least Cairo 1.15.4 is required for setting PDF metadata."
+#endif
+
+static optional<cairo_pdf_metadata_t> metadata_by_name(const char *name) {
+	if (!strcmp(name, "title"))
+		return CAIRO_PDF_METADATA_TITLE;
+	if (!strcmp(name, "author"))
+		return CAIRO_PDF_METADATA_AUTHOR;
+	if (!strcmp(name, "subject"))
+		return CAIRO_PDF_METADATA_SUBJECT;
+	if (!strcmp(name, "keywords"))
+		return CAIRO_PDF_METADATA_KEYWORDS;
+	if (!strcmp(name, "creator"))
+		return CAIRO_PDF_METADATA_CREATOR;
+	if (!strcmp(name, "create_date"))
+		return CAIRO_PDF_METADATA_CREATE_DATE;
+	if (!strcmp(name, "mod_date"))
+		return CAIRO_PDF_METADATA_MOD_DATE;
+	return {};
+}
+
+static int xlua_document_newindex(lua_State *L) {
+	auto self = (LuaDocument *) luaL_checkudata(L, 1, XLUA_DOCUMENT_METATABLE);
+	auto name = luaL_checkstring(L, 2);
+	auto value = luaL_checkstring(L, 3);
+
+	// These are all read-only in Cairo.
+	if (auto id = metadata_by_name(name))
+		cairo_pdf_surface_set_metadata(self->pdf, id.value(), value);
+	else
+		return luaL_error(L, "%s: unknown property");
+	return 0;
+}
+
+static int xlua_document_show(lua_State *L) {
+	auto self = (LuaDocument *) luaL_checkudata(L, 1, XLUA_DOCUMENT_METATABLE);
+	for (int i = 2; i <= lua_gettop(L); i++) {
+		auto w = (LuaWidget *) luaL_checkudata(L, i, XLUA_WIDGET_METATABLE);
+		xlua_widget_check(L, w);
+		auto widget = w->widget.get();
+		widget->apply_attributes();
+
+		auto inner_width = self->page_width - 2 * self->page_margin;
+		auto inner_height = self->page_height - 2 * self->page_margin;
+		widget->prepare_for_size(self->pc, inner_width, inner_height);
+
+		cairo_save(self->cr);
+		cairo_translate(self->cr, self->page_margin, self->page_margin);
+		widget->render(self->cr, inner_width, inner_height);
+		cairo_restore(self->cr);
+	}
+	cairo_show_page(self->cr);
+	return 0;
+}
+
+static luaL_Reg xlua_document_table[] = {
+	{"__gc",       xlua_document_gc},
+	{"__index",    xlua_document_index},
+	{"__newindex", xlua_document_newindex},
+	{"show",       xlua_document_show},
+	{}
+};
+
+// --- Library -----------------------------------------------------------------
+
+// 1 point is 1/72 inch, also applies to PDF surfaces.
+static int xlua_cm(lua_State *L) {
+	lua_pushnumber(L, luaL_checknumber(L, 1) / 2.54 * 72);
+	return 1;
+}
+
+struct xlua_numpunct : public numpunct<char> {
+	optional<char> thousands_sep_override;
+	optional<char> decimal_point_override;
+	optional<string_type> grouping_override;
+
+	using super = std::numpunct<char>;
+
+	virtual char do_thousands_sep() const override {
+		return thousands_sep_override.value_or(super::do_thousands_sep());
+	}
+
+	virtual char do_decimal_point() const override {
+		return decimal_point_override.value_or(super::do_decimal_point());
+	}
+
+	virtual string_type do_grouping() const override {
+		return grouping_override.value_or(super::do_grouping());
+	}
+};
+
+static int xlua_ntoa(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+
+	auto np = new xlua_numpunct();
+	const char *field = nullptr;
+	if (lua_getfield(L, 1, (field = "thousands_sep")) != LUA_TNIL) {
+		size_t len = 0;
+		auto str = lua_tolstring(L, -1, &len);
+		if (!str || len != 1)
+			return luaL_error(L, "invalid %s", field);
+		np->thousands_sep_override.emplace(str[0]);
+	}
+	if (lua_getfield(L, 1, (field = "decimal_point")) != LUA_TNIL) {
+		size_t len = 0;
+		auto str = lua_tolstring(L, -1, &len);
+		if (!str || len != 1)
+			return luaL_error(L, "invalid %s", field);
+		np->decimal_point_override.emplace(str[0]);
+	}
+	if (lua_getfield(L, 1, (field = "grouping")) != LUA_TNIL) {
+		size_t len = 0;
+		auto str = lua_tolstring(L, -1, &len);
+		if (!str)
+			return luaL_error(L, "invalid %s", field);
+		np->grouping_override.emplace(string(str, len));
+	}
+
+	ostringstream formatted;
+	formatted.imbue(locale(locale(), np));
+	if (lua_getfield(L, 1, "precision") != LUA_TNIL) {
+		formatted.setf(formatted.fixed, formatted.floatfield);
+		formatted.precision(lua_tointeger(L, -1));
+	}
+
+	lua_geti(L, 1, 1);
+	if (lua_isinteger(L, -1))
+		formatted << lua_tointeger(L, -1);
+	else if (lua_isnumber(L, -1))
+		formatted << lua_tonumber(L, -1);
+	else
+		return luaL_error(L, "number expected as the first field");
+
+	lua_pushstring(L, formatted.str().c_str());
+	return 1;
+}
+
+static int xlua_escape(lua_State *L) {
+	string escaped;
+	for (int i = 1; i <= lua_gettop(L); i++) {
+		size_t len = 0;
+		const char *s = luaL_checklstring(L, i, &len);
+		for (size_t i = 0; i < len; i++)
+			switch (auto c = s[i]) {
+			break; case '<': escaped += "&lt;";
+			break; case '>': escaped += "&gt;";
+			break; case '&': escaped += "&amp;";
+			break; default:  escaped += c;
+			}
+	}
+	lua_pushlstring(L, escaped.data(), escaped.length());
+	return 1;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static int xlua_document(lua_State *L) {
+	const char *filename = luaL_checkstring(L, 1);
+	lua_Number width = luaL_checknumber(L, 2);
+	lua_Number height = luaL_checknumber(L, 3);
+
+	LuaDocument *self =
+		static_cast<LuaDocument *>(lua_newuserdata(L, sizeof *self));
+	luaL_setmetatable(L, XLUA_DOCUMENT_METATABLE);
+	new(self) LuaDocument;
+
+	self->pdf = cairo_pdf_surface_create(filename,
+		(self->page_width = width), (self->page_height = height));
+	self->cr = cairo_create(self->pdf);
+	cairo_surface_destroy(self->pdf);
+
+	self->page_margin = luaL_optnumber(L, 4, self->page_margin);
+
+	auto pc = self->pc = pango_cairo_create_context(self->cr);
+	// By default the resolution is set to 96 DPI but the PDF surface uses 72.
+	pango_cairo_context_set_resolution(pc, 72.);
+
+#if PANGO_VERSION_CHECK(1, 44, 0)
+	// Otherwise kerning was broken in Pango before 1.48.6.
+	// Seems like this issue: https://gitlab.gnome.org/GNOME/pango/-/issues/562
+	// and might be related to: https://blogs.gnome.org/mclasen/2019/08/
+	pango_context_set_round_glyph_positions(pc, FALSE);
+#endif
+	return 1;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+static LuaWidget *xlua_newwidget(lua_State *L) {
+	LuaWidget *self =
+		static_cast<LuaWidget *>(lua_newuserdata(L, sizeof *self));
+	luaL_setmetatable(L, XLUA_WIDGET_METATABLE);
+	new(self) LuaWidget;
+	return self;
+}
+
+static int xlua_filler(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+
+	double width = -1, height = -1;
+	if (lua_geti(L, 1, 1); !lua_isnoneornil(L, -1))
+		width = lua_tonumber(L, -1);
+	if (lua_geti(L, 1, 2); !lua_isnoneornil(L, -1))
+		height = lua_tonumber(L, -1);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new Filler{width, height}, 1);
+	return 1;
+}
+
+static int xlua_hline(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+
+	double thickness = 1;
+	if (lua_geti(L, 1, 1); !lua_isnoneornil(L, -1))
+		thickness = lua_tonumber(L, -1);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new HLine{thickness}, 1);
+	return 1;
+}
+
+static int xlua_vline(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+
+	double thickness = 1;
+	if (lua_geti(L, 1, 1); !lua_isnoneornil(L, -1))
+		thickness = lua_tonumber(L, -1);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new VLine{thickness}, 1);
+	return 1;
+}
+
+static int xlua_text(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+
+	string text;
+	for (lua_Integer i = 1, len = luaL_len(L, 1); i <= len; i++) {
+		lua_geti(L, 1, i);
+
+		// TODO(p): If it wasn't a string originally, escape the value.
+		size_t length = 0;
+		const char *s = luaL_tolstring(L, -1, &length);
+		text.append(s, length);
+		lua_pop(L, 1);
+	}
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new Text{text}, 1);
+	return 1;
+}
+
+static LuaWidget *xlua_towidget(lua_State *L) {
+	if (luaL_testudata(L, -1, XLUA_WIDGET_METATABLE))
+		return (LuaWidget *) luaL_checkudata(L, -1, XLUA_WIDGET_METATABLE);
+
+	// TODO(p): If it wasn't a string originally, escape the value.
+	size_t length = 0;
+	const char *s = luaL_tolstring(L, -1, &length);
+	string text(s, length);
+	lua_pop(L, 1);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new Text{text}, 0);
+	return self;
+}
+
+static int xlua_frame(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+	if (luaL_len(L, 1) != 1)
+		return luaL_error(L, "expected one child widget");
+
+	lua_geti(L, 1, 1);
+	auto child = xlua_towidget(L);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new Frame{child->widget.release()}, 1);
+	return 1;
+}
+
+static int xlua_link(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+	if (luaL_len(L, 1) != 2)
+		return luaL_error(L, "expected link target and one child widget");
+
+	lua_geti(L, 1, 1);
+	size_t length = 0;
+	const char *s = luaL_tolstring(L, -1, &length);
+	string target(s, length);
+	lua_pop(L, 1);
+
+	lua_geti(L, 1, 2);
+	auto child = xlua_towidget(L);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new Link{target, child->widget.release()}, 1);
+	return 1;
+}
+
+static int xlua_hbox(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+
+	vector<unique_ptr<Widget>> children;
+	for (lua_Integer i = 1, len = luaL_len(L, 1); i <= len; i++) {
+		lua_geti(L, 1, i);
+		children.emplace_back(xlua_towidget(L)->widget.release());
+		lua_pop(L, 1);
+	}
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new HBox{std::move(children)}, 1);
+	return 1;
+}
+
+static int xlua_vbox(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+
+	vector<unique_ptr<Widget>> children;
+	for (lua_Integer i = 1, len = luaL_len(L, 1); i <= len; i++) {
+		lua_geti(L, 1, i);
+		children.emplace_back(xlua_towidget(L)->widget.release());
+		lua_pop(L, 1);
+	}
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new VBox{std::move(children)}, 1);
+	return 1;
+}
+
+static int xlua_picture(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+	if (luaL_len(L, 1) != 1)
+		return luaL_error(L, "expected picture path");
+
+	lua_geti(L, 1, 1);
+	size_t length = 0;
+	const char *s = luaL_tolstring(L, -1, &length);
+	string filename(s, length);
+	lua_pop(L, 1);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new Picture{filename}, 1);
+	return 1;
+}
+
+static int xlua_qr(lua_State *L) {
+	luaL_checktype(L, 1, LUA_TTABLE);
+	if (luaL_len(L, 1) != 2)
+		return luaL_error(L, "expected contents and module size");
+
+	lua_geti(L, 1, 1);
+	size_t length = 0;
+	const char *s = luaL_tolstring(L, -1, &length);
+	string target(s, length);
+	lua_pop(L, 1);
+
+	lua_geti(L, 1, 2);
+	auto T = lua_tonumber(L, -1);
+	lua_pop(L, 1);
+
+	auto self = xlua_newwidget(L);
+	xlua_widget_set(L, self, new QR{target, T}, 1);
+	return 1;
+}
+
+static luaL_Reg xlua_library[] = {
+	{"cm",       xlua_cm},
+	{"ntoa",     xlua_ntoa},
+	{"escape",   xlua_escape},
+
+	{"Document", xlua_document},
+
+	{"Filler",   xlua_filler},
+	{"HLine",    xlua_hline},
+	{"VLine",    xlua_vline},
+	{"Text",     xlua_text},
+	{"Frame",    xlua_frame},
+	{"Link",     xlua_link},
+	{"HBox",     xlua_hbox},
+	{"VBox",     xlua_vbox},
+	{"Picture",  xlua_picture},
+	{"QR",       xlua_qr},
+	{}
+};
+
+// --- Initialisation, event handling ------------------------------------------
+
+static int xlua_error_handler(lua_State *L) {
+	// Don't add tracebacks when there's already one, and pass nil through.
+	const char *string = luaL_optstring(L, 1, NULL);
+	if (string && !strchr(string, '\n')) {
+		luaL_traceback(L, L, string, 1);
+		lua_remove(L, 1);
+	}
+	return 1;
+}
+
+static void *xlua_alloc([[maybe_unused]] void *ud, void *ptr,
+	[[maybe_unused]] size_t o_size, size_t n_size) {
+	if (n_size)
+		return realloc(ptr, n_size);
+
+	free(ptr);
+	return NULL;
+}
+
+static int xlua_panic(lua_State *L) {
+	cerr << "fatal: Lua panicked: " << lua_tostring(L, -1) << endl;
+	lua_close(L);
+	exit(EXIT_FAILURE);
+	return 0;
+}
+
+int main(int argc, char *argv[]) {
+	if (argc < 2) {
+		cerr << "Usage: " << argv[0] << " program.lua [args...]" << endl;
+		return 1;
+	}
+
+	lua_State *L = lua_newstate(xlua_alloc, NULL);
+	if (!L) {
+		cerr << "fatal: Lua initialization failed" << endl;
+		return 1;
+	}
+	lua_atpanic(L, xlua_panic);
+	luaL_openlibs(L);
+	luaL_checkversion(L);
+
+	luaL_newlib(L, xlua_library);
+	lua_setglobal(L, "lpg");
+
+	luaL_newmetatable(L, XLUA_DOCUMENT_METATABLE);
+	luaL_setfuncs(L, xlua_document_table, 0);
+	lua_pop(L, 1);
+
+	luaL_newmetatable(L, XLUA_WIDGET_METATABLE);
+	luaL_setfuncs(L, xlua_widget_table, 0);
+	lua_pop(L, 1);
+
+	luaL_checkstack(L, argc, NULL);
+
+	// Joining the first two might make a tiny bit more sense.
+	lua_createtable(L, argc - 1, 0);
+	lua_pushstring(L, (string(argv[0]) + " " + argv[1]).c_str());
+	lua_rawseti(L, 1, 1);
+	for (int i = 2; i < argc; i++) {
+		lua_pushstring(L, argv[i]);
+		lua_rawseti(L, 1, i - 1);
+	}
+	lua_setglobal(L, "arg");
+
+	lua_pushcfunction(L, xlua_error_handler);
+	if (luaL_loadfile(L, strcmp(argv[1], "-") ? argv[1] : NULL))
+		goto error;
+	for (int i = 2; i < argc; i++)
+		lua_pushstring(L, argv[i]);
+	if (lua_pcall(L, argc - 2, 0, 1))
+		goto error;
+	lua_close(L);
+	return 0;
+
+error:
+	cerr << "error: " << lua_tostring(L, -1) << endl;
+	lua_close(L);
+	return 1;
+}
diff --git a/lpg/lpg.lua b/lpg/lpg.lua
new file mode 100644
index 0000000..07ee44a
--- /dev/null
+++ b/lpg/lpg.lua
@@ -0,0 +1,165 @@
+#!/usr/bin/env lpg
+function h1 (title)
+	return lpg.VBox {fontsize=18., fontweight=600,
+		title, lpg.HLine {2}, lpg.Filler {-1, 6}}
+end
+function h2 (title)
+	return lpg.VBox {fontsize=16., fontweight=600,
+		lpg.Filler {-1, 8}, title, lpg.HLine {1}, lpg.Filler {-1, 4}}
+end
+function h3 (title)
+	return lpg.VBox {fontsize=14., fontweight=600,
+		lpg.Filler {-1, 8}, title, lpg.HLine {.25}, lpg.Filler {-1, 4}}
+end
+function p (...)
+	return lpg.VBox {..., lpg.Filler {-1, 6}}
+end
+function pre (...)
+	return lpg.VBox {
+		lpg.Filler {-1, 4},
+		lpg.HBox {lpg.Filler {12}, lpg.VBox {...}, lpg.Filler {}},
+		lpg.Filler {-1, 6},
+	}
+end
+function define (name, ...)
+	return lpg.VBox {
+		lpg.Filler {-1, 2},
+		lpg.Text {fontweight=600, name}, lpg.Filler {-1, 2},
+		lpg.HBox {lpg.Filler {12}, lpg.VBox {...}, lpg.Filler {}},
+		lpg.Filler {-1, 2},
+	}
+end
+
+local page1 = lpg.VBox {fontfamily="sans serif", fontsize=12.,
+	h1("lpg User Manual"),
+	p("<b>lpg</b> is a Lua-based PDF document generator, exposing a trivial " ..
+		"layouting engine on top of the Cairo graphics library, " ..
+		"with manual paging."),
+	p("The author has primarily been using this system to typeset invoices."),
+
+	h2("Synopsis"),
+	p("<b>lpg</b> <i>program.lua</i> [<i>args...</i>]"),
+
+	h2("API"),
+	p("The Lua program receives <b>lpg</b>'s and its own path joined " ..
+		"as <tt>arg[0]</tt>.  Any remaining sequential elements " ..
+		"of this table represent the passed <i>args</i>."),
+
+	h3("Utilities"),
+
+	define("lpg.cm (centimeters)",
+		p("Returns how many document points are needed " ..
+			"for the given physical length.")),
+
+	define("lpg.ntoa {number [, precision=…]\n" ..
+		"\t[, thousands_sep=…] [, decimal_point=…] [, grouping=…]}",
+		p("Formats a number using the C++ localization " ..
+			"and I/O libraries.  " ..
+			"For example, the following call results in “3 141,59”:"),
+		pre("<tt>ntoa {3141.592, precision=2,\n" ..
+			"  thousands_sep=\" \", decimal_point=\",\", " ..
+			"grouping=\"\\003\"}</tt>")),
+
+	define("lpg.escape (values...)",
+		p("Interprets all values as strings, " ..
+			"and escapes them to be used as literal text—" ..
+			"all text within <b>lpg</b> is parsed Pango markup, " ..
+			"which is a subset of XML.")),
+
+	h3("PDF documents"),
+
+	define("lpg.Document (filename, width, height [, margin])",
+		p("Returns a new <i>Document</i> object, whose pages are all " ..
+			"the same size in 72 DPI points, as specified by <b>width</b> " ..
+			"and <b>height</b>.  The <b>margin</b> is used by <b>show</b> " ..
+			"on all sides of pages."),
+		p("The file is finalized when the object is garbage collected.")),
+
+	define("<i>Document</i>.title, author, subject, keywords, " ..
+		"creator, create_date, mod_date",
+		p("Write-only PDF <i>Info</i> dictionary metadata strings.")),
+
+	define("<i>Document</i>:show ([widget...])",
+		p("Starts a new document page, and renders <i>Widget</i> trees over " ..
+		"the whole print area.")),
+
+	lpg.Filler {},
+}
+
+local page2 = lpg.VBox {fontfamily="sans serif", fontsize=12.,
+	h3("Widgets"),
+	p("The layouting system makes heavy use of composition, " ..
+		"and thus stays simple."),
+	p("For convenience, anywhere a <i>Widget</i> is expected but another " ..
+		"kind of value is received, <b>lpg.Text</b> widget will be invoked " ..
+		"on that value."),
+	p("Once a <i>Widget</i> is included in another <i>Widget</i>, " ..
+		"the original Lua object can no longer be used, " ..
+		"as its reference has been consumed."),
+	p("<i>Widgets</i> can be indexed by strings to get or set " ..
+		"their <i>attributes</i>.  All <i>Widget</i> constructor tables " ..
+		"also accept attributes, for convenience.  Attributes can be " ..
+		"either strings or numbers, mostly only act " ..
+		"on specific <i>Widget</i> kinds, and are hereditary.  " ..
+		"Prefix their names with an underscore to set them ‘privately’."),
+	p("<i>Widget</i> sizes can be set negative, which signals to their " ..
+		"container that they should take any remaining space, " ..
+		"after all their siblings’ requests have been satisfied.  " ..
+		"When multiple widgets make this request, that space is distributed " ..
+		"in proportion to these negative values."),
+
+	define("lpg.Filler {[width] [, height]}",
+		p("Returns a new blank widget with the given dimensions, " ..
+			"which default to -1, -1.")),
+	define("lpg.HLine {[thickness]}",
+		p("Returns a new widget that draws a simple horizontal line " ..
+			"of the given <b>thickness</b>.")),
+	define("lpg.VLine {[thickness]}",
+		p("Returns a new widget that draws a simple vertical line " ..
+			"of the given <b>thickness</b>.")),
+	define("lpg.Text {[value...]}",
+		p("Returns a new text widget that renders the concatenation of all " ..
+			"passed values filtered through Lua’s <b>tostring</b> function."),
+		define("<i>Text</i>.fontfamily, fontsize, fontweight, lineheight",
+			p("Various font properties, similar to their CSS counterparts."))),
+	define("lpg.Frame {widget}",
+		p("Returns a special container widget that can override " ..
+			"a few interesting properties."),
+		define("<i>Frame</i>.color",
+			p("Text and line colour, for example <tt>0xff0000</tt> for red.")),
+		define("<i>Frame</i>.w_override",
+			p("Forcefully changes the child <i>Widget</i>’s " ..
+				"requested width, such as to negative values.")),
+		define("<i>Frame</i>.h_override",
+			p("Forcefully changes the child <i>Widget</i>’s " ..
+				"requested height, such as to negative values."))),
+
+	lpg.Filler {},
+}
+
+local page3 = lpg.VBox {fontfamily="sans serif", fontsize=12.,
+	-- TODO: Link
+	-- TODO: HBox
+	-- TODO: VBox
+	-- TODO: Picture
+	-- TODO: QR
+
+	lpg.Filler {},
+}
+
+if #arg < 1 then
+	io.stderr:write("Usage: " .. arg[0] .. " OUTPUT-PDF..." .. "\n")
+	os.exit(false)
+end
+local width, height, margin = lpg.cm(21), lpg.cm(29.7), lpg.cm(2.0)
+for i = 1, #arg do
+	local pdf = lpg.Document(arg[i], width, height, margin)
+	pdf.title = "lpg User Manual"
+	pdf.subject = "lpg User Manual"
+	pdf.author = "Přemysl Eric Janouch"
+	pdf.creator = "lpg"
+
+	pdf:show(page1)
+	pdf:show(page2)
+	pdf:show(page3)
+end
diff --git a/lpg/meson.build b/lpg/meson.build
new file mode 100644
index 0000000..b8d506c
--- /dev/null
+++ b/lpg/meson.build
@@ -0,0 +1,15 @@
+project('lpg', 'c', 'cpp', default_options : ['cpp_std=c++17'],
+	version : '1.1.1')
+
+conf = configuration_data()
+conf.set_quoted('PROJECT_NAME', meson.project_name())
+conf.set_quoted('PROJECT_VERSION', meson.project_version())
+configure_file(output : 'config.h', configuration : conf)
+
+luapp = dependency('lua++', allow_fallback : true)
+cairo = dependency('cairo')
+pangocairo = dependency('pangocairo')
+executable('lpg', 'lpg.cpp', 'libqr.c',
+	install : true,
+	dependencies : [luapp, cairo, pangocairo],
+    include_directories : include_directories('libqr'))
diff --git a/lpg/subprojects/lua++.wrap b/lpg/subprojects/lua++.wrap
new file mode 100644
index 0000000..1ddf5d6
--- /dev/null
+++ b/lpg/subprojects/lua++.wrap
@@ -0,0 +1,10 @@
+[wrap-file]
+directory = lua-5.4.7
+source_url = https://github.com/lua/lua/archive/refs/tags/v5.4.7.tar.gz
+source_filename = lua-5.4.7.tar.gz
+source_hash = 5c39111b3fc4c1c9e56671008955a1730f54a15b95e1f1bd0752b868b929d8e3
+patch_directory = lua-5.4.7
+
+[provide]
+lua++-5.4 = lua_dep
+lua++ = lua_dep
diff --git a/lpg/subprojects/packagefiles/lua-5.4.7/LICENSE.build b/lpg/subprojects/packagefiles/lua-5.4.7/LICENSE.build
new file mode 100644
index 0000000..c62f655
--- /dev/null
+++ b/lpg/subprojects/packagefiles/lua-5.4.7/LICENSE.build
@@ -0,0 +1,20 @@
+Copyright (c) 2025 Přemysl Eric Janouch <p@janouch.name>
+Copyright (c) 2021 The Meson development team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/lpg/subprojects/packagefiles/lua-5.4.7/meson.build b/lpg/subprojects/packagefiles/lua-5.4.7/meson.build
new file mode 100644
index 0000000..dbc8ff6
--- /dev/null
+++ b/lpg/subprojects/packagefiles/lua-5.4.7/meson.build
@@ -0,0 +1,50 @@
+project(
+  'lua-5.4',
+  'cpp',
+  license : 'MIT',
+  meson_version : '>=0.49.2',
+  version : '5.4.7',
+  default_options : ['c_std=c99', 'warning_level=2'],
+)
+
+cxx = meson.get_compiler('cpp')
+
+# Skip bogus warning.
+add_project_arguments(cxx.get_supported_arguments(
+  '-Wno-string-plus-int', '-Wno-stringop-overflow'), language : 'cpp')
+
+# Platform-specific defines.
+is_posix = host_machine.system() in ['cygwin', 'darwin', 'dragonfly', 'freebsd',
+  'gnu', 'haiku', 'linux', 'netbsd', 'openbsd', 'sunos']
+if is_posix
+  add_project_arguments('-DLUA_USE_POSIX', language : 'cpp')
+endif
+
+# Library dependencies.
+lua_lib_deps = [cxx.find_library('m', required : false)]
+
+if meson.version().version_compare('>= 0.62')
+  dl_dep = dependency('dl', required : get_option('loadlib'))
+else
+  dl_dep = cxx.find_library('dl', required : get_option('loadlib'))
+endif
+
+if dl_dep.found()
+  lua_lib_deps += dl_dep
+  add_project_arguments('-DLUA_USE_DLOPEN', language : 'cpp')
+endif
+
+# Targets.
+add_project_arguments('-DMAKE_LIB', language : 'cpp')
+lua_lib = static_library(
+  'lua',
+  'onelua.cpp',
+  dependencies : lua_lib_deps,
+  implicit_include_directories : false,
+)
+
+inc = include_directories('.')
+lua_dep = declare_dependency(
+  link_with : lua_lib,
+  include_directories : inc,
+)
diff --git a/lpg/subprojects/packagefiles/lua-5.4.7/meson_options.txt b/lpg/subprojects/packagefiles/lua-5.4.7/meson_options.txt
new file mode 100644
index 0000000..ea6f6c4
--- /dev/null
+++ b/lpg/subprojects/packagefiles/lua-5.4.7/meson_options.txt
@@ -0,0 +1,4 @@
+option(
+  'loadlib', type : 'feature',
+  description : 'Allow Lua to "require" C extension modules'
+)
diff --git a/lpg/subprojects/packagefiles/lua-5.4.7/onelua.cpp b/lpg/subprojects/packagefiles/lua-5.4.7/onelua.cpp
new file mode 100644
index 0000000..6517028
--- /dev/null
+++ b/lpg/subprojects/packagefiles/lua-5.4.7/onelua.cpp
@@ -0,0 +1 @@
+#include "onelua.c"
diff --git a/meson.build b/meson.build
index d68a99d..668b612 100644
--- a/meson.build
+++ b/meson.build
@@ -14,10 +14,10 @@ executable('pdf-simple-sign', 'pdf-simple-sign.cpp',
 asciidoctor = find_program('asciidoctor')
 foreach page : ['pdf-simple-sign']
 	custom_target('manpage for ' + page,
-		input: page + '.adoc', output: page + '.1',
-		command: [asciidoctor, '-b', 'manpage',
+		input : page + '.adoc', output: page + '.1',
+		command : [asciidoctor, '-b', 'manpage',
 			'-a', 'release-version=' + meson.project_version(),
 			'@INPUT@', '-o', '@OUTPUT@'],
-		install: true,
-		install_dir: join_paths(get_option('mandir'), 'man1'))
+		install : true,
+		install_dir : join_paths(get_option('mandir'), 'man1'))
 endforeach