openscad-cpp-evaluator 1.49.0__tar.gz → 1.49.2__tar.gz

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.0
+Version: 1.49.2
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -406,9 +406,14 @@ enum class Op {
     // for an attachable()-style multi-body operand) and appends it, as a
     // Value, onto csgWrapStack.back().groupSizes -- exactly one entry per
     // top-level geometry statement, in source order, mirroring resolveCsg's
-    // own `groupSizes.push_back(Value{...})` loop.
+    // own `groupSizes.push_back(Value{...})` loop. Bit 4 of `a`: the statement is an `if` (no else), an operand
+    // exactly when it took its branch, read from ev.lastIfTaken.
     CsgGroupEnd,
 
+    // Sets ev.lastIfTaken = (a != 0) as an `if` (no else) finishes. See
+    // Evaluator::lastIfTaken.
+    SetLastIfTaken,
+
     // One `children(..., separate=true)` statement inside a CSG bracket.
     // `a` interns the ModularCall in nativeStatements.
     //

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -228,6 +228,11 @@ public:
     // contributed by comparing this before/after evaluating just that one
     // statement.
     size_t currentTreeFrameSize() const { return treeStack_.back().size(); }
+    // Whether the last `if` (no else) to finish took its branch. Written as
+    // the statement ENDS, so after evaluating an outer `if` it describes
+    // that one and not an `if` nested inside it. Read by the CSG operand
+    // rule (emptyStatementIsAnOperand), which is its only reason to exist.
+    bool lastIfTaken = false;
 
 
     // Generate pass: walks `tree` bottom-up (children before their own

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/pyproject.toml

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

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/src/builtins/booleans.cpp

@@ -97,7 +97,12 @@ bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt) {
     const oscad::NodeKind k = stmt.kind();
     return k == oscad::NodeKind::ModularCall || k == oscad::NodeKind::ModularFor ||
            k == oscad::NodeKind::ModularIntersectionFor || k == oscad::NodeKind::ModularLet ||
-           k == oscad::NodeKind::ModularModifierShowOnly || k == oscad::NodeKind::ModularModifierHighlight;
+           k == oscad::NodeKind::ModularModifierShowOnly || k == oscad::NodeKind::ModularModifierHighlight ||
+           k == oscad::NodeKind::ModularIfElse;
+}
+
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt, bool ifTaken) {
+    return emptyStatementIsAnOperand(stmt) || (stmt.kind() == oscad::NodeKind::ModularIf && ifTaken);
 }
 
 CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
@@ -140,16 +145,20 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
         //
         // The reference builds a node for a module instantiation and for a
         // loop whatever they contain, so an empty one is an empty operand
-        // and annihilates an intersection. An `if` that takes no branch, a
-        // bare block, and a `*`-disabled statement build no node at all, so
-        // they are not operands and must be skipped.
+        // and annihilates an intersection. So does an `if` that TAKES a
+        // branch, even one that draws nothing -- `if (true) {}` empties an
+        // intersection, and so does BOSL2's partition() when its child
+        // draws only one half (`if ($children>0) children();`). An `if`
+        // that takes no branch, a bare block, and a `*`-disabled statement
+        // build no node at all, so they are not operands and must be
+        // skipped. An if/else always takes one.
         //
         // Every line of this was checked against OpenSCAD rather than
         // reasoned about -- `intersection(){ cube(10); X; }` keeps the cube
         // for `if(false) sphere(6)`, `{ }` and `*cube(1)`, and comes out
         // empty for `for(i=[1:0]) sphere(6)`, `union(){}`, `group(){}` and
         // a call to an empty user module.
-        emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*geoNode)});
+        emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*geoNode, ev.lastIfTaken)});
         backgroundStmt.push_back(Value{geoNode->kind() == oscad::NodeKind::ModularModifierBackground});
     }
 

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/src/builtins/builtins.hpp

@@ -264,6 +264,8 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
 // Whether a statement that produced no geometry still counts as a boolean
 // operand (and so empties an intersection) -- see resolveCsg.
 bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt);
+// The same, for a statement just evaluated: `ifTaken` is ev.lastIfTaken.
+bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt, bool ifTaken);
 
 // OpenSCAD's sin_degrees/cos_degrees/tan_degrees/atan2_degrees: exact at
 // multiples of 30 and 45 degrees.

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/src/builtins/control.cpp

@@ -138,7 +138,7 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
                 const size_t before = ev.currentTreeFrameSize();
                 ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, parentCtx);
                 groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
-                emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*stmt)});
+                emptyIsAGroup.push_back(Value{emptyStatementIsAnOperand(*stmt, ev.lastIfTaken)});
                 backgroundStmt.push_back(Value{stmt->kind() == oscad::NodeKind::ModularModifierBackground});
             }
             return;

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/src/bytecode_compiler.cpp

@@ -1480,9 +1480,11 @@ public:
             compileStatementList(std::vector<const oscad::ASTNode*>{geoNode}, out);
             // `a` = whether a group that turns out EMPTY is still an
             // operand. See emptyStatementIsAnOperand (booleans.cpp).
-            // and bit 2 = it is a `%` statement, never an operand at all.
+            // and bit 2 = it is a `%` statement, never an operand at all,
+            // and bit 4 = an `if`, decided at run time.
             const int flags = (emptyStatementIsAnOperand(*geoNode) ? 1 : 0) |
-                              (geoNode->kind() == oscad::NodeKind::ModularModifierBackground ? 2 : 0);
+                              (geoNode->kind() == oscad::NodeKind::ModularModifierBackground ? 2 : 0) |
+                              (geoNode->kind() == oscad::NodeKind::ModularIf ? 4 : 0);
             out.push_back({Op::CsgGroupEnd, flags, 0, nullptr});
         }
     }
@@ -1794,7 +1796,12 @@ public:
                 out.push_back({Op::OpenLetScope, 0, 0, nullptr});
                 compileStatementList(n.trueBranch, out);
                 out.push_back({Op::CloseExprScope, 0, 0, nullptr});
+                out.push_back({Op::SetLastIfTaken, 1, 0, nullptr});
+                const int jumpEndIdx = static_cast<int>(out.size());
+                out.push_back({Op::Jump, 0, 0, nullptr});
                 out[static_cast<size_t>(jumpFalseIdx)].b = static_cast<int>(out.size());
+                out.push_back({Op::SetLastIfTaken, 0, 0, nullptr});
+                out[static_cast<size_t>(jumpEndIdx)].a = static_cast<int>(out.size());
                 return;
             }
             case NodeKind::ModularIfElse: {

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/src/bytecode_vm.cpp

@@ -1444,11 +1444,15 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     ++f.pc;
                     break;
                 }
+                case Op::SetLastIfTaken:
+                    ev.lastIfTaken = ins.a != 0;
+                    ++f.pc;
+                    break;
                 case Op::CsgGroupEnd: {
                     PendingCsgWrap& pending = f.csgWrapStack.back();
                     const size_t after = ev.treeStack_.back().size();
                     pending.groupSizes.push_back(Value{static_cast<double>(after - pending.groupStartSize)});
-                    pending.emptyIsAGroup.push_back(Value{(ins.a & 1) != 0});
+                    pending.emptyIsAGroup.push_back(Value{(ins.a & 1) != 0 || ((ins.a & 4) != 0 && ev.lastIfTaken)});
                     pending.backgroundStmt.push_back(Value{(ins.a & 2) != 0});
                     ++f.pc;
                     break;

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/src/stmt_eval.cpp

@@ -279,12 +279,14 @@ void Evaluator::evalStatement(const oscad::ASTNode& node, EvalContext& ctx) {
         // `_check_debug(branch[0] if branch else node, ctx, expr_level=True)`.
         case oscad::NodeKind::ModularIf: {
             auto& n = static_cast<const oscad::ModularIf&>(node);
-            if (truthy(evalExprMaybeCompiled(*n.condition, ctx))) {
+            const bool taken = truthy(evalExprMaybeCompiled(*n.condition, ctx));
+            if (taken) {
                 checkDebug(n.trueBranch.empty() ? node : *n.trueBranch.front(), ctx, /*forced=*/false,
                             /*exprLevel=*/true);
                 EvalContext branchCtx = blockScope(ctx);
                 evalChildren(n.trueBranch, branchCtx);
             }
+            lastIfTaken = taken;
             return;
         }
         case oscad::NodeKind::ModularIfElse: {

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/src/zip_stored.cpp

@@ -52,6 +52,7 @@ uint16_t readU16(const uint8_t* p) { return static_cast<uint16_t>(p[0] | (p[1] <
 uint32_t readU32(const uint8_t* p) {
     return static_cast<uint32_t>(p[0] | (p[1] << 8) | (p[2] << 16) | (static_cast<uint32_t>(p[3]) << 24));
 }
+uint64_t readU64(const uint8_t* p) { return readU32(p) | (static_cast<uint64_t>(readU32(p + 4)) << 32); }
 
 // A fixed, valid DOS date/time (2020-01-01 00:00:00) -- the exact instant
 // doesn't matter for a generated 3MF, just that it's a well-formed DOS
@@ -156,9 +157,9 @@ void writeZipEntries(const std::string& path, const std::vector<PlacedEntry>& en
 struct CentralDirEntry {
     std::string name;
     uint16_t method;
-    uint32_t compressedSize;
-    uint32_t uncompressedSize;
-    uint32_t localHeaderOffset;
+    uint64_t compressedSize;
+    uint64_t uncompressedSize;
+    uint64_t localHeaderOffset;
 };
 
 std::vector<uint8_t> readWholeFile(const std::string& path) {
@@ -189,25 +190,57 @@ std::vector<CentralDirEntry> parseCentralDirectory(const std::vector<uint8_t>& f
     }
     if (eocd == std::string::npos) throw std::runtime_error("'" + path + "' is not a valid ZIP archive (no EOCD)");
 
-    const uint16_t entryCount = readU16(&file[eocd + 10]);
-    const uint32_t cdOffset = readU32(&file[eocd + 16]);
+    uint64_t entryCount = readU16(&file[eocd + 10]);
+    uint64_t cdOffset = readU32(&file[eocd + 16]);
+    // ZIP64: a field too big for the classic record is all ones, and the
+    // real value is in the ZIP64 end record the locator just before it
+    // points to. lib3mf -- behind OpenSCAD's and most slicers' 3MF export --
+    // writes one even for a tiny file, so without this nearly every 3MF
+    // read as "corrupt central directory offset" (BelfrySCAD #800).
+    if ((entryCount == 0xFFFFu || cdOffset == 0xFFFFFFFFu) && eocd >= 20 &&
+        readU32(&file[eocd - 20]) == 0x07064b50u) {
+        const uint64_t z64 = readU64(&file[eocd - 20 + 8]);
+        if (z64 + 56 > file.size() || readU32(&file[z64]) != 0x06064b50u) {
+            throw std::runtime_error("'" + path + "': corrupt ZIP64 end of central directory");
+        }
+        entryCount = readU64(&file[z64 + 32]);
+        cdOffset = readU64(&file[z64 + 48]);
+    }
     if (cdOffset >= file.size()) throw std::runtime_error("'" + path + "': corrupt central directory offset");
 
     std::vector<CentralDirEntry> entries;
     size_t p = cdOffset;
-    for (uint16_t i = 0; i < entryCount; ++i) {
+    for (uint64_t i = 0; i < entryCount; ++i) {
         if (p + 46 > file.size() || readU32(&file[p]) != 0x02014b50u) {
             throw std::runtime_error("'" + path + "': corrupt central directory entry");
         }
         const uint16_t method = readU16(&file[p + 10]);
-        const uint32_t compressedSize = readU32(&file[p + 20]);
-        const uint32_t uncompressedSize = readU32(&file[p + 24]);
+        uint64_t compressedSize = readU32(&file[p + 20]);
+        uint64_t uncompressedSize = readU32(&file[p + 24]);
         const uint16_t nameLen = readU16(&file[p + 28]);
         const uint16_t extraLen = readU16(&file[p + 30]);
         const uint16_t commentLen = readU16(&file[p + 32]);
-        const uint32_t localHeaderOffset = readU32(&file[p + 42]);
-        if (p + 46 + nameLen > file.size()) throw std::runtime_error("'" + path + "': corrupt central directory entry name");
+        uint64_t localHeaderOffset = readU32(&file[p + 42]);
+        if (p + 46 + nameLen + extraLen > file.size()) throw std::runtime_error("'" + path + "': corrupt central directory entry name");
         std::string name(reinterpret_cast<const char*>(&file[p + 46]), nameLen);
+        // A ZIP64 extra field (id 1) holds, in this order, only the values
+        // whose 32-bit field above is all ones.
+        for (size_t x = p + 46 + nameLen, xEnd = x + extraLen; x + 4 <= xEnd;) {
+            const uint16_t id = readU16(&file[x]);
+            const uint16_t len = readU16(&file[x + 2]);
+            size_t q = x + 4;
+            const size_t qEnd = std::min<size_t>(q + len, xEnd);
+            if (id == 0x0001u) {
+                for (uint64_t* v : {&uncompressedSize, &compressedSize, &localHeaderOffset}) {
+                    if (*v != 0xFFFFFFFFu) continue;
+                    if (q + 8 > qEnd) throw std::runtime_error("'" + path + "': corrupt ZIP64 extra field");
+                    *v = readU64(&file[q]);
+                    q += 8;
+                }
+                break;
+            }
+            x = q + len;
+        }
         entries.push_back(CentralDirEntry{std::move(name), method, compressedSize, uncompressedSize, localHeaderOffset});
         p += 46 + nameLen + extraLen + commentLen;
     }

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/tests/test_booleans.cpp

@@ -11,6 +11,14 @@
 using namespace oscadeval;
 using namespace oscadeval::test;
 
+namespace {
+class ScopedVm {
+public:
+    explicit ScopedVm(bool enabled) { Evaluator::setBytecodeVmEnabledForTesting(enabled); }
+    ~ScopedVm() { Evaluator::setBytecodeVmEnabledForTesting(std::nullopt); }
+};
+} // namespace
+
 // -- difference / intersection -------------------------------------------
 
 TEST(Difference, SubtractsInnerCubeVolume) {
@@ -66,10 +74,17 @@ TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
     // falls out: a module instantiation or a loop builds a node whatever it
     // contains, so an empty one is an empty operand and annihilates; an
     // `if` with no branch taken, a bare block and a `*`-disabled statement
-    // build no node at all and are not operands.
+    // build no node at all and are not operands. An `if` that takes a
+    // branch is one, whatever the branch draws.
     struct Case { const char* stmt; bool keepsTheCube; };
     const Case cases[] = {
         {"if (false) sphere(6);",            true},
+        {"if (true) { }",                    false},
+        {"if (true) if (false) sphere(6);",  false},
+        {"if (true) { x = 1; }",             false},
+        {"if (false) sphere(6); else { }",   false},
+        {"if (false) sphere(6); else if (false) sphere(6);", false},
+        {"{ if (false) sphere(6); }",        true},
         {"{ }",                              true},
         {"*cube(1);",                        true},
         {"for (i = [1:0]) sphere(6);",       false},
@@ -78,9 +93,16 @@ TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
         {"let(x = 1) { }",                   false},
         {"#union() { }",                     false},
     };
+    // Each at top level and inside a module body, under both the
+    // interpreter and the VM, which decide an `if` separately.
+    for (const bool vm : {false, true})
+    for (const char* wrap : {"%s", "module w() { %s } w();"})
     for (const Case& c : cases) {
-        const std::string src =
+        ScopedVm scoped(vm);
+        const std::string inner =
             std::string("intersection() { cube(10, center=true); ") + c.stmt + " }";
+        std::string src = wrap;
+        src.replace(src.find("%s"), 2, inner);
         Evaluated e = evalSrc(src);
         if (c.keepsTheCube) {
             ASSERT_EQ(e.bodies.size(), 1u) << src;
@@ -94,6 +116,24 @@ TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
     }
 }
 
+TEST(Intersection, BOSL2PartitionShowsOnlyTheHalfItsChildDraws) {
+    // partition()'s own shape: `intersection() { if ($children>0)
+    // children(); mask }`, once per half. A child drawing nothing for one
+    // half must empty that half, not leave its mask behind -- which is what
+    // `partition() if ($idx==0) cylinder(...)` drew. Verified against
+    // OpenSCAD: only the cube's own volume.
+    for (const bool vm : {false, true}) {
+        ScopedVm scoped(vm);
+        Evaluated e = evalSrc(
+            "module m() { intersection() { if ($children > 0) children(); cube(10); } }"
+            "m() if (false) sphere(5);");
+        const bool anyVolume = std::any_of(
+            e.bodies.begin(), e.bodies.end(),
+            [](const ColoredBody& b) { return b.body && !b.body->IsEmpty(); });
+        EXPECT_FALSE(anyVolume) << "vm=" << vm;
+    }
+}
+
 TEST(Intersection, AnEmptyUserModuleIsStillAnOperand) {
     // The reference builds a node for a module instantiation whatever the
     // module's body does, so calling one that draws nothing empties the

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/tests/test_zip_stored.cpp

@@ -253,3 +253,90 @@ TEST(ZipStored, StoredZipWritesMethod0) {
     EXPECT_EQ(centralDirMethodBySuffix(path.string(), "3dmodel.model"), 0);
     std::filesystem::remove(path);
 }
+
+TEST(ZipStored, ReadsZip64Archive) {
+    // The shape lib3mf writes (BelfrySCAD #800): every size and offset in the
+    // central directory and classic end record all ones, the real values in a
+    // ZIP64 extra field and a ZIP64 end record found through its locator.
+    const std::string name = "3D/3dmodel.model";
+    const std::string content = "zip64 payload";
+    std::vector<uint8_t> out;
+
+    putLE<uint32_t>(out, 0x04034b50u);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, static_cast<uint32_t>(content.size()));
+    putLE<uint32_t>(out, static_cast<uint32_t>(content.size()));
+    putLE<uint16_t>(out, static_cast<uint16_t>(name.size()));
+    putLE<uint16_t>(out, 0);
+    out.insert(out.end(), name.begin(), name.end());
+    out.insert(out.end(), content.begin(), content.end());
+
+    const uint64_t cdStart = out.size();
+    putLE<uint32_t>(out, 0x02014b50u);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint16_t>(out, static_cast<uint16_t>(name.size()));
+    putLE<uint16_t>(out, 4 + 24 + 4 + 4); // an unrelated field first, then ZIP64
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    out.insert(out.end(), name.begin(), name.end());
+    putLE<uint16_t>(out, 0x5455);
+    putLE<uint16_t>(out, 4);
+    putLE<uint32_t>(out, 0);
+    putLE<uint16_t>(out, 0x0001);
+    putLE<uint16_t>(out, 24);
+    putLE<uint64_t>(out, content.size());
+    putLE<uint64_t>(out, content.size());
+    putLE<uint64_t>(out, 0);
+    const uint64_t cdSize = out.size() - cdStart;
+
+    const uint64_t z64 = out.size();
+    putLE<uint32_t>(out, 0x06064b50u);
+    putLE<uint64_t>(out, 44);
+    putLE<uint16_t>(out, 45);
+    putLE<uint16_t>(out, 45);
+    putLE<uint32_t>(out, 0);
+    putLE<uint32_t>(out, 0);
+    putLE<uint64_t>(out, 1);
+    putLE<uint64_t>(out, 1);
+    putLE<uint64_t>(out, cdSize);
+    putLE<uint64_t>(out, cdStart);
+
+    putLE<uint32_t>(out, 0x07064b50u);
+    putLE<uint32_t>(out, 0);
+    putLE<uint64_t>(out, z64);
+    putLE<uint32_t>(out, 1);
+
+    putLE<uint32_t>(out, 0x06054b50u);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0);
+    putLE<uint16_t>(out, 0xFFFF);
+    putLE<uint16_t>(out, 0xFFFF);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint32_t>(out, 0xFFFFFFFFu);
+    putLE<uint16_t>(out, 0);
+
+    const auto path = tempPath("zip64.zip");
+    {
+        std::ofstream f(path, std::ios::binary);
+        f.write(reinterpret_cast<const char*>(out.data()), static_cast<std::streamsize>(out.size()));
+    }
+    const std::vector<uint8_t> read = readStoredZipEntry(path.string(), name);
+    EXPECT_EQ(std::string(read.begin(), read.end()), content);
+    std::filesystem::remove(path);
+}

{openscad_cpp_evaluator-1.49.0 → openscad_cpp_evaluator-1.49.2}/uv.lock

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