openscad-cpp-evaluator 1.28.0__tar.gz → 1.28.2__tar.gz

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.28.0
+Version: 1.28.2
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/include/openscad_cpp_evaluator/text_metrics.hpp

@@ -12,7 +12,12 @@ namespace oscadeval {
 // for `size`. `glyphs` is what text() places: each shaped glyph with its
 // pen position, already scaled. An inkless glyph (a space) still advances
 // the pen and still gets a glyphs entry -- it just contributes nothing to
-// ascent/descent/inkMinX/inkMaxX.
+// the ink box or ascent/descent.
+//
+// As in OpenSCAD's ShapeResults: left/right/bottom/top is the ink box of the
+// glyphs where they are placed, while ascent/descent are the glyphs' own
+// extents above and below THEIR baseline, ignoring where they sit. The two
+// only differ for a vertical run or a glyph the shaper offsets (a mark).
 //
 // The run comes from the shaper, so kerning and ligatures are already
 // applied and `spacing` scales the shaped advances rather than raw
@@ -23,8 +28,11 @@ struct TextMeasurement {
         double x = 0, y = 0;
     };
 
-    double ascent = 0, descent = 0, inkMinX = 0, inkMaxX = 0;
+    double ascent = 0, descent = 0;
+    double left = 0, right = 0, bottom = 0, top = 0;
     double advanceX = 0, advanceY = 0;
+    bool hasInk = false;
+    bool vertical = false;  // shaped ttb/btt
     std::vector<Placed> glyphs;
 };
 
@@ -32,7 +40,9 @@ TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::stri
                             double spacing, const ShapeOptions& opts = {});
 
 // (offsetX, offsetY) translation for halign/valign, given a
-// TextMeasurement. Shared by textmetrics() (reports it) and text()
+// TextMeasurement. "default" is left/baseline for a horizontal run and
+// center/top for a vertical one, as in OpenSCAD; text with no ink is not
+// moved at all. Shared by textmetrics() (reports it) and text()
 // (applies it).
 std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
                                           const TextMeasurement& m);

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.28.0"
+version = "1.28.2"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/src/builtins/function_builtins.cpp

@@ -792,8 +792,8 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
     // `font` being name-only here is what made
     // `textmetrics("Hi", 10, "Liberation Sans:style=Bold")` silently
     // measure the default face (BelfrySCAD #381).
-    const std::string halign = asStringOr(getArg(args, 6, "halign", Value{std::string("left")}), "left");
-    const std::string valign = asStringOr(getArg(args, 7, "valign", Value{std::string("baseline")}), "baseline");
+    const std::string halign = asStringOr(getArg(args, 6, "halign", Value{std::string("default")}), "default");
+    const std::string valign = asStringOr(getArg(args, 7, "valign", Value{std::string("default")}), "default");
     const double spacing = toDoubleLenient(getArg(args, 8, "spacing", Value{1.0}));
     const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
     ShapeOptions shape;
@@ -807,8 +807,8 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
     const auto [offsetX, offsetY] = textAlignOffset(halign, valign, m);
 
     return objectOf({
-        {"position", numList({offsetX + m.inkMinX, offsetY + m.descent})},
-        {"size", numList({m.inkMaxX - m.inkMinX, m.ascent - m.descent})},
+        {"position", numList({offsetX + m.left, offsetY + m.bottom})},
+        {"size", numList({m.right - m.left, m.top - m.bottom})},
         {"ascent", Value{m.ascent}},
         {"descent", Value{m.descent}},
         {"offset", numList({offsetX, offsetY})},

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/src/builtins/primitives_3d.cpp

@@ -102,18 +102,25 @@ std::string describeEdge(const M& mesh, std::pair<uint32_t, uint32_t> edge) {
 
 CSGParams resolveCube(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    Value sizeArg = getArg(args, 0, "size", Value{1.0});
+    const Value sizeArg = getArg(args, 0, "size", Value{});
     const bool center = truthy(getArg(args, 1, "center", Value{false}));
 
-    std::vector<Value> sizeVec;
+    // As OpenSCAD reads it: undef (absent or explicit) is the default of 1, a
+    // number or three numbers are the size, and anything else warns and
+    // falls back to 1. Explicit undef built a zero-size cube -- nothing --
+    // and a 2-vector or a string was converted leniently, without a word.
+    std::vector<Value> sizeVec(3, Value{1.0});
+    const ListPtr* l = std::get_if<ListPtr>(&sizeArg);
     if (const double* s = std::get_if<double>(&sizeArg)) {
         sizeVec = {Value{*s}, Value{*s}, Value{*s}};
-    } else if (const ListPtr* l = std::get_if<ListPtr>(&sizeArg); l && *l) {
-        for (size_t i = 0; i < 3; ++i) {
-            sizeVec.push_back(Value{i < (*l)->items.size() ? toDoubleLenient((*l)->items[i]) : 0.0});
-        }
-    } else {
-        sizeVec = {Value{0.0}, Value{0.0}, Value{0.0}};
+    } else if (l && *l && (*l)->items.size() == 3 &&
+               std::all_of((*l)->items.begin(), (*l)->items.end(),
+                           [](const Value& v) { return std::holds_alternative<double>(v); })) {
+        sizeVec = (*l)->items;
+    } else if (!std::holds_alternative<std::monostate>(sizeArg)) {
+        ev.warn("Unable to convert cube(size=" + fmtValue(sizeArg) +
+                    ", ...) parameter to a number or a vec3 of numbers",
+                &node.position());
     }
 
     CSGParams params;

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/src/builtins/text.cpp

@@ -7,7 +7,7 @@
 
 #include <algorithm>
 
-// text(text=, size=10, font=, halign="left", valign="baseline", spacing=1,
+// text(text=, size=10, font=, halign="default", valign="default", spacing=1,
 // direction=, language=, script=) -- renders `text` as 2D glyph outlines
 // through the FontProvider (Evaluator::fontProvider(), lazily the built-in
 // FreetypeFontProvider if none was injected).
@@ -46,8 +46,8 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     // genuinely differ here -- textmetrics takes all nine positionally --
     // so neither can be assumed from the other.
     const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
-    const std::string halign = asStringOr(getArg(args, std::nullopt, "halign", Value{std::string("left")}), "left");
-    const std::string valign = asStringOr(getArg(args, std::nullopt, "valign", Value{std::string("baseline")}), "baseline");
+    const std::string halign = asStringOr(getArg(args, std::nullopt, "halign", Value{std::string("default")}), "default");
+    const std::string valign = asStringOr(getArg(args, std::nullopt, "valign", Value{std::string("default")}), "default");
     const double spacing = toDoubleLenient(getArg(args, std::nullopt, "spacing", Value{1.0}));
     ShapeOptions shape;
     shape.direction = asStringOr(getArg(args, std::nullopt, "direction", Value{std::string("")}), "");

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/src/text/freetype_font_provider.cpp

@@ -31,6 +31,45 @@ void scaleHbFontToEm(hb_font_t* font, unsigned int unitsPerEm) {
     hb_font_set_scale(font, static_cast<int>(unitsPerEm), static_cast<int>(unitsPerEm));
 }
 
+// Vertical metrics come from FreeType, as they do in OpenSCAD (which shapes
+// through hb-ft). For a font with no vmtx -- nearly every Latin font,
+// Liberation Sans included -- the two disagree: hb-ot falls back to hhea
+// ascender-descender, FreeType to OS/2 typo ascender-descender, so a ttb
+// run of "abc" was 46.5 tall here and 39.1 there. Mirrors hb-ft's own
+// callbacks; font units in and out, since the hb font is scaled to the em.
+hb_position_t ftVAdvance(hb_font_t*, void* data, hb_codepoint_t glyph, void*) {
+    FT_Face ft = static_cast<FT_Face>(data);
+    if (FT_Load_Glyph(ft, glyph, FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING | FT_LOAD_VERTICAL_LAYOUT) != 0) return 0;
+    return static_cast<hb_position_t>(-ft->glyph->metrics.vertAdvance);  // FreeType's vertical grows downward
+}
+
+hb_bool_t ftVOrigin(hb_font_t*, void* data, hb_codepoint_t glyph, hb_position_t* x, hb_position_t* y, void*) {
+    FT_Face ft = static_cast<FT_Face>(data);
+    if (FT_Load_Glyph(ft, glyph, FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING | FT_LOAD_VERTICAL_LAYOUT) != 0) return false;
+    const FT_Glyph_Metrics& m = ft->glyph->metrics;
+    *x = static_cast<hb_position_t>(m.horiBearingX - m.vertBearingX);
+    *y = static_cast<hb_position_t>(m.horiBearingY + m.vertBearingY);
+    return true;
+}
+
+// hb-ot for everything, with the vertical metrics overridden by FreeType.
+hb_font_t* makeHbFont(hb_face_t* face, FT_Face ft, unsigned int unitsPerEm) {
+    static hb_font_funcs_t* vfuncs = [] {
+        hb_font_funcs_t* f = hb_font_funcs_create();
+        hb_font_funcs_set_glyph_v_advance_func(f, ftVAdvance, nullptr, nullptr);
+        hb_font_funcs_set_glyph_v_origin_func(f, ftVOrigin, nullptr, nullptr);
+        hb_font_funcs_make_immutable(f);
+        return f;
+    }();
+    hb_font_t* parent = hb_font_create(face);
+    hb_ot_font_set_funcs(parent);
+    scaleHbFontToEm(parent, unitsPerEm);
+    hb_font_t* font = hb_font_create_sub_font(parent);  // everything unset delegates to parent
+    hb_font_destroy(parent);
+    hb_font_set_funcs(font, vfuncs, ft, nullptr);
+    return font;
+}
+
 struct OutlineSink {
     GlyphContours contours;
     std::vector<std::array<double, 2>> current;
@@ -159,10 +198,8 @@ struct FreetypeFontProvider::Impl {
             return std::nullopt;
         }
         f.hbFace = hb_face_create(f.blob, static_cast<unsigned>(index));
-        f.hbFont = hb_font_create(f.hbFace);
-        hb_ot_font_set_funcs(f.hbFont);
         f.metrics = readMetrics(f.ft);
-        scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
+        f.hbFont = makeHbFont(f.hbFace, f.ft, static_cast<unsigned>(f.metrics.unitsPerEm));
         faces.push_back(f);
         return faces.size() - 1;
     }
@@ -185,10 +222,8 @@ struct FreetypeFontProvider::Impl {
             f.blob = hb_blob_create(reinterpret_cast<const char*>(src.data),
                                     static_cast<unsigned>(src.size), HB_MEMORY_MODE_READONLY, nullptr, nullptr);
             f.hbFace = hb_face_create(f.blob, 0);
-            f.hbFont = hb_font_create(f.hbFace);
-            hb_ot_font_set_funcs(f.hbFont);
             f.metrics = readMetrics(f.ft);
-            scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
+            f.hbFont = makeHbFont(f.hbFace, f.ft, static_cast<unsigned>(f.metrics.unitsPerEm));
             faces.push_back(f);
         }
     }

openscad_cpp_evaluator-1.28.2/src/text/text_metrics.cpp

@@ -0,0 +1,80 @@
+#include "openscad_cpp_evaluator/text_metrics.hpp"
+
+#include <algorithm>
+#include <cctype>
+
+namespace oscadeval {
+
+TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::string& text, double size,
+                            double spacing, const ShapeOptions& opts) {
+    const FontMetrics fm = fp.metrics(handle);
+    // The 100/72 factor is real OpenSCAD's long-standing text() size bug
+    // (its issue #4304: FT_Set_Char_Size is given 100 dpi where 72 is
+    // correct, making glyphs ~1.39x the nominal size). It is reproduced
+    // deliberately -- a decade of models are drawn to it, and OpenSCAD
+    // itself chose to keep the bug and add an `em=` parameter rather than
+    // fix it.
+    const double scale = size * (100.0 / 72.0) / fm.unitsPerEm;
+
+    TextMeasurement m;
+    // hb_direction_from_string reads only the first letter, so this is
+    // exactly the set of strings the shaper takes as vertical.
+    const char d = opts.direction.empty() ? 'l' : static_cast<char>(std::tolower(opts.direction[0]));
+    m.vertical = d == 't' || d == 'b';
+    double penX = 0.0, penY = 0.0;
+
+    for (const ShapedGlyph& g : fp.shapeText(handle, text, opts)) {
+        const double x = (penX + g.xOffset) * scale;
+        const double y = (penY + g.yOffset) * scale;
+
+        if (const std::optional<std::array<double, 4>> b = fp.glyphInkBounds(handle, g.glyph)) {
+            const double gl = x + (*b)[0] * scale, gr = x + (*b)[2] * scale;
+            const double gb = y + (*b)[1] * scale, gt = y + (*b)[3] * scale;
+            const double asc = (*b)[3] * scale, desc = (*b)[1] * scale;
+            if (!m.hasInk) {
+                m.left = gl, m.right = gr, m.bottom = gb, m.top = gt;
+                m.ascent = asc, m.descent = desc;
+                m.hasInk = true;
+            } else {
+                m.left = std::min(m.left, gl);
+                m.right = std::max(m.right, gr);
+                m.bottom = std::min(m.bottom, gb);
+                m.top = std::max(m.top, gt);
+                m.ascent = std::max(m.ascent, asc);
+                m.descent = std::min(m.descent, desc);
+            }
+        }
+
+        m.glyphs.push_back(TextMeasurement::Placed{g.glyph, x, y});
+        penX += g.xAdvance * spacing;
+        penY += g.yAdvance * spacing;
+    }
+
+    m.advanceX = penX * scale;
+    m.advanceY = penY * scale;
+    return m;
+}
+
+// OpenSCAD's ShapeResults::calc_offsets_horiz/_vert. An unknown value (and,
+// for a vertical run, valign="baseline") does not move the text there
+// either; OpenSCAD also warns, which this does not.
+std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
+                                          const TextMeasurement& m) {
+    if (!m.hasInk) return {0.0, 0.0};
+    double offsetX = 0.0, offsetY = 0.0;
+    if (m.vertical) {
+        if (halign == "right") offsetX = -m.right;
+        else if (halign == "left") offsetX = -m.left;
+        if (valign == "center") offsetY = -m.advanceY / 2;
+        else if (valign == "bottom") offsetY = -m.advanceY;
+    } else {
+        if (halign == "center") offsetX = -0.5 * m.advanceX;
+        else if (halign == "right") offsetX = -m.advanceX;
+        if (valign == "top") offsetY = -m.ascent;
+        else if (valign == "center") offsetY = -(m.ascent + m.descent) / 2;
+        else if (valign == "bottom") offsetY = -m.descent;
+    }
+    return {offsetX, offsetY};
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/tests/test_primitives.cpp

@@ -438,3 +438,32 @@ TEST(SphereStyle, StyleRespectsFnAndRadius) {
     const double v20 = sphereStats("sphere(r=20, style=\"aligned\", $fn=24);").volume;
     EXPECT_NEAR(v20 / v10, 8.0, 1e-6);   // volume goes as r^3
 }
+
+// cube()'s size as OpenSCAD 2026.02.01 reads it: undef, absent or explicit,
+// is the default of 1; anything but a number or three numbers warns and
+// falls back to 1. Explicit undef built a zero-size cube -- nothing at all.
+TEST(Primitives, CubeBadSizeIsAUnitCube) {
+    const std::pair<const char*, const char*> cases[] = {
+        {"undef", ""},
+        {"\"a\"", "size=\"a\""},
+        {"[1,2]", "size=[1, 2]"},
+        {"[1,2,undef]", "size=[1, 2, undef]"},
+        {"true", "size=true"},
+        {"[1,\"a\",3]", "size=[1, \"a\", 3]"},
+    };
+    for (const auto& [arg, shown] : cases) {
+        std::vector<std::string> log;
+        Evaluated e = evalSrc(std::string("cube(") + arg + ");", [&](const std::string& m) { log.push_back(m); });
+        ASSERT_EQ(e.bodies.size(), 1u) << arg;
+        ASSERT_TRUE(e.bodies[0].body.has_value()) << arg;
+        EXPECT_NEAR(e.bodies[0].body->Volume(), 1.0, 1e-9) << arg;
+        if (*shown == '\0') {
+            EXPECT_TRUE(log.empty()) << arg;
+        } else {
+            ASSERT_EQ(log.size(), 1u) << arg;
+            EXPECT_EQ(log[0], std::string("WARNING: Unable to convert cube(") + shown +
+                                  ", ...) parameter to a number or a vec3 of numbers in file <string>, line 1")
+                << arg;
+        }
+    }
+}

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/tests/test_text.cpp

@@ -97,6 +97,42 @@ TEST(Textmetrics, AdvanceXIsPositiveForNonEmptyText) {
     EXPECT_DOUBLE_EQ(asNum(items[1]), 0.0);
 }
 
+// Vertical runs, against OpenSCAD 2026.02.01 (it hints, so ~0.01 apart).
+// Its vertical metrics are FreeType's -- OS/2 typo ascender-descender for a
+// font without vmtx -- not hb-ot's hhea fallback, which gave 46.5 here.
+namespace {
+double vec(const Value& obj, const std::string& key, int i) {
+    return asNum(std::get<ListPtr>(objGet(obj, key))->items[i]);
+}
+} // namespace
+
+TEST(Textmetrics, VerticalRunMatchesOpenscad) {
+    Evaluator ev;
+    Value v = asExpr("textmetrics(\"abc\", size=10, direction=\"ttb\")", ev);
+    EXPECT_NEAR(vec(v, "advance", 1), -39.1032, 1e-3);
+    EXPECT_NEAR(vec(v, "position", 0), -3.2733, 0.01);
+    EXPECT_NEAR(vec(v, "position", 1), -36.3957, 0.01);
+    EXPECT_NEAR(vec(v, "size", 1), 33.6848, 0.01);
+    EXPECT_NEAR(asNum(objGet(v, "ascent")), 10.0672, 0.01);  // the glyphs' own, not their placement
+}
+
+TEST(Textmetrics, VerticalRunAlignsByItsOwnRules) {
+    Evaluator ev;
+    Value lc = asExpr("textmetrics(\"abc\", size=10, direction=\"ttb\", halign=\"left\", valign=\"center\")", ev);
+    EXPECT_NEAR(vec(lc, "offset", 0), 3.2733, 0.01);
+    EXPECT_NEAR(vec(lc, "offset", 1), 19.5516, 1e-3);
+    Value rb = asExpr("textmetrics(\"abc\", size=10, direction=\"ttb\", halign=\"right\", valign=\"bottom\")", ev);
+    EXPECT_NEAR(vec(rb, "offset", 0), -3.8627, 0.01);
+    EXPECT_NEAR(vec(rb, "offset", 1), 39.1032, 1e-3);
+}
+
+TEST(Textmetrics, InklessTextIsNotAligned) {
+    Evaluator ev;
+    Value v = asExpr("textmetrics(\"  \", size=10, halign=\"right\")", ev);
+    EXPECT_EQ(vec(v, "offset", 0), 0.0);
+    EXPECT_GT(vec(v, "advance", 0), 7.0);
+}
+
 TEST(Textmetrics, AscentIsPositiveDescentIsNonPositive) {
     Evaluator ev;
     Value v = asExpr("textmetrics(text=\"Hi\", size=10)", ev);

{openscad_cpp_evaluator-1.28.0 → openscad_cpp_evaluator-1.28.2}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.28.0"
+version = "1.28.2"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },

openscad_cpp_evaluator-1.28.0/src/text/text_metrics.cpp

@@ -1,70 +0,0 @@
-#include "openscad_cpp_evaluator/text_metrics.hpp"
-
-#include <algorithm>
-
-namespace oscadeval {
-
-TextMeasurement measureText(FontProvider& fp, FontHandle handle, const std::string& text, double size,
-                            double spacing, const ShapeOptions& opts) {
-    const FontMetrics fm = fp.metrics(handle);
-    // The 100/72 factor is real OpenSCAD's long-standing text() size bug
-    // (its issue #4304: FT_Set_Char_Size is given 100 dpi where 72 is
-    // correct, making glyphs ~1.39x the nominal size). It is reproduced
-    // deliberately -- a decade of models are drawn to it, and OpenSCAD
-    // itself chose to keep the bug and add an `em=` parameter rather than
-    // fix it.
-    const double scale = size * (100.0 / 72.0) / fm.unitsPerEm;
-
-    TextMeasurement m;
-    double penX = 0.0, penY = 0.0;
-    bool hasInk = false;
-
-    for (const ShapedGlyph& g : fp.shapeText(handle, text, opts)) {
-        const double x = (penX + g.xOffset) * scale;
-        const double y = (penY + g.yOffset) * scale;
-
-        if (const std::optional<std::array<double, 4>> b = fp.glyphInkBounds(handle, g.glyph)) {
-            const double left = x + (*b)[0] * scale;
-            const double right = x + (*b)[2] * scale;
-            const double bottom = y + (*b)[1] * scale;
-            const double top = y + (*b)[3] * scale;
-            if (!hasInk) {
-                m.inkMinX = left;
-                m.inkMaxX = right;
-                m.ascent = top;
-                m.descent = bottom;
-                hasInk = true;
-            } else {
-                m.inkMinX = std::min(m.inkMinX, left);
-                m.inkMaxX = std::max(m.inkMaxX, right);
-                m.ascent = std::max(m.ascent, top);
-                m.descent = std::min(m.descent, bottom);
-            }
-        }
-
-        m.glyphs.push_back(TextMeasurement::Placed{g.glyph, x, y});
-        penX += g.xAdvance * spacing;
-        penY += g.yAdvance * spacing;
-    }
-
-    m.advanceX = penX * scale;
-    m.advanceY = penY * scale;
-    return m;
-}
-
-std::pair<double, double> textAlignOffset(const std::string& halign, const std::string& valign,
-                                          const TextMeasurement& m) {
-    double offsetX = 0.0;
-    if (halign == "center") offsetX = -0.5 * m.advanceX;
-    else if (halign == "right") offsetX = -1.0 * m.advanceX;
-
-    double offsetY = 0.0;
-    if (valign == "top") offsetY = -m.ascent;
-    else if (valign == "center") offsetY = -(m.ascent + m.descent) / 2;
-    else if (valign == "bottom") offsetY = -m.descent;
-    // "baseline" (or anything else) -> 0
-
-    return {offsetX, offsetY};
-}
-
-} // namespace oscadeval