css.cpp

Go to the documentation of this file.

/*******************************************************************************
Copyright (c) 2021, Jan Koester jan.koester@gmx.net
All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the <organization> nor the
      names of its contributors may be used to endorse or promote products
      derived from this software without specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
 
#include "css.h"
#include "exception.h"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <sstream>
 
namespace {
 
    bool isWhitespace(char c) {
        return c == ' ' || c == '\t' || c == '\n' || c == '\r';
    }
 
    std::string trim(const std::string &s) {
        size_t start = 0;
        while (start < s.size() && isWhitespace(s[start])) ++start;
        size_t end = s.size();
        while (end > start && isWhitespace(s[end - 1])) --end;
        return s.substr(start, end - start);
    }
 
    // Strips a trailing "!important" (case-insensitive, any whitespace
    // before the "!") from a CSS declaration value, returning whether it was
    // present. CSSDeclaration's parser captures "!important" as ordinary
    // trailing text with no special handling, so a caller comparing/storing
    // plain property values needs this to see past it.
    bool stripImportant(std::string &value) {
        size_t bang = value.rfind('!');
        if (bang == std::string::npos) return false;
 
        size_t start = value.find_first_not_of(" \t\n\r", bang + 1);
        size_t end = value.find_last_not_of(" \t\n\r");
        if (start == std::string::npos || end == std::string::npos || start > end) return false;
 
        std::string tail = value.substr(start, end - start + 1);
        std::transform(tail.begin(), tail.end(), tail.begin(),
            [](unsigned char c) { return std::tolower(c); });
        if (tail != "important") return false;
 
        size_t valEnd = bang;
        while (valEnd > 0 && isWhitespace(value[valEnd - 1])) --valEnd;
        value.resize(valEnd);
        return true;
    }
 
    // A combinator-stripped compound selector like "div.card.featured#hero"
    // broken into its optional bare tag (lowercased), every ".class" token,
    // and an optional "#id" token.
    struct CompoundParts {
        std::string tag;
        std::vector<std::string> classes;
        std::string id;
        // Attribute-selector conditions from the ORIGINAL (pre-
        // stripAttributeSelectors) compound text -- only ever populated for
        // the target compound (see parseAttributeConditions's callers);
        // left empty for ancestor compounds, which have no attribute map to
        // check against. Checked by compoundMatches when a target attribute
        // map is available, ignored (as before) otherwise.
        std::vector<libhtmlpp::AttributeCondition> attrConditions;
    };
 
    // Parses every "[name]"/"[name=value]"/"[name~=value]"/etc. group found
    // anywhere in `sel` (a compound selector's RAW text, before
    // stripAttributeSelectors removes them) into an AttributeCondition --
    // e.g. "[data-fit=fill]" -> {name="data-fit", op="=", value="fill"},
    // a bare "[data-atom]" -> {name="data-atom", op="", value=""}. A quoted
    // value has its surrounding '"'/'\'' stripped. Deliberately approximate
    // like the rest of this file: doesn't handle a case-sensitivity flag
    // ("i"/"s" before the closing "]") or backslash-escaped characters --
    // this matcher only needs to compare against a plain attribute-value
    // map, not implement the full CSS attribute-selector grammar.
    std::vector<libhtmlpp::AttributeCondition> parseAttributeConditions(const std::string &sel) {
        std::vector<libhtmlpp::AttributeCondition> out;
        size_t pos = 0;
        while (pos < sel.size()) {
            if (sel[pos] != '[') { ++pos; continue; }
            size_t close = sel.find(']', pos + 1);
            if (close == std::string::npos) break;
            std::string inner = trim(sel.substr(pos + 1, close - pos - 1));
            pos = close + 1;
            if (inner.empty()) continue;
 
            libhtmlpp::AttributeCondition cond;
            size_t eq = inner.find('=');
            if (eq == std::string::npos) {
                cond.name = inner;
            } else {
                size_t opStart = eq;
                if (eq > 0 && std::string("~|^$*").find(inner[eq - 1]) != std::string::npos)
                    opStart = eq - 1;
                cond.op = inner.substr(opStart, eq - opStart + 1);
                cond.name = trim(inner.substr(0, opStart));
                std::string value = trim(inner.substr(eq + 1));
                if (value.size() >= 2 &&
                    ((value.front() == '"' && value.back() == '"') ||
                     (value.front() == '\'' && value.back() == '\'')))
                    value = value.substr(1, value.size() - 2);
                cond.value = value;
            }
            out.push_back(std::move(cond));
        }
        return out;
    }
 
    // Whether `actual` (the target element's real attribute value) satisfies
    // one attribute-selector operator/expected pair. An unrecognized
    // operator (shouldn't happen given parseAttributeConditions's own
    // grammar) is treated as satisfied rather than guessed wrong, same "not
    // proven to not match" philosophy as the rest of this file.
    bool attributeValueMatches(const std::string &op, const std::string &expected, const std::string &actual) {
        if (op.empty()) return true; // bare "[name]" -- existence already confirmed by the caller
        if (op == "=") return actual == expected;
        if (op == "~=") {
            std::istringstream iss(actual);
            std::string tok;
            while (iss >> tok) if (tok == expected) return true;
            return false;
        }
        if (op == "^=") return !expected.empty() && actual.compare(0, expected.size(), expected) == 0;
        if (op == "$=") return !expected.empty() && expected.size() <= actual.size() &&
                                actual.compare(actual.size() - expected.size(), expected.size(), expected) == 0;
        if (op == "*=") return !expected.empty() && actual.find(expected) != std::string::npos;
        if (op == "|=") return actual == expected || actual.compare(0, expected.size() + 1, expected + "-") == 0;
        return true;
    }
 
    // Whether every attribute condition parsed off the TARGET compound (see
    // CompoundParts::attrConditions) holds against @p targetAttrs. Absent
    // conditions (none, or no attribute map available -- e.g. an ancestor
    // compound, or a caller that didn't supply one) are vacuously satisfied,
    // preserving this matcher's original "ignore attribute selectors"
    // behavior wherever an attribute map genuinely isn't available.
    bool attributeConditionsSatisfied(const std::vector<libhtmlpp::AttributeCondition> &conditions,
                                       const std::map<std::string,std::string> *targetAttrs)
    {
        if (conditions.empty()) return true;
        if (!targetAttrs) return true;
        for (const auto &cond : conditions) {
            auto it = targetAttrs->find(cond.name);
            if (it == targetAttrs->end()) return false;
            if (!attributeValueMatches(cond.op, cond.value, it->second)) return false;
        }
        return true;
    }
 
    CompoundParts parseCompoundSelector(const std::string &matchSel) {
        CompoundParts result;
        size_t pos = 0;
        while (pos < matchSel.size()) {
            char c = matchSel[pos];
            if (c == '.' || c == '#') {
                size_t next = matchSel.find_first_of(".#", pos + 1);
                size_t tokenEnd = (next == std::string::npos) ? matchSel.size() : next;
                std::string token = matchSel.substr(pos + 1, tokenEnd - (pos + 1));
                if (c == '.') result.classes.push_back(token);
                else result.id = token;
                pos = tokenEnd;
            } else {
                size_t next = matchSel.find_first_of(".#", pos);
                size_t tokenEnd = (next == std::string::npos) ? matchSel.size() : next;
                result.tag = matchSel.substr(pos, tokenEnd - pos);
                pos = tokenEnd;
            }
        }
        std::transform(result.tag.begin(), result.tag.end(), result.tag.begin(),
            [](unsigned char c) { return std::tolower(c); });
        return result;
    }
 
    // Whether `compound`'s tag/classes/id are ALL present on the given
    // candidate tag/classes/id -- every class listed must be present, not
    // just one. Shared by compoundMatches (the target element, which adds
    // its own "bare tag after combinator" guard on top -- see there) and
    // ancestorChainSatisfies (a specific ancestor frame, which needs no such
    // guard: a lone tag requirement checked against one concrete candidate
    // is a meaningful constraint, not the blanket-match hazard a lone tag
    // with no ancestor to check it against would be). A compound with
    // nothing specified at all (tag/classes/id all empty -- e.g. it was
    // purely an attribute selector or pseudo-class, see
    // stripAttributeSelectors/hasUnsupportedSelectorSyntax) trivially
    // matches anything: this helper has no opinion on whether an empty
    // compound should count as a real requirement, that's each caller's
    // call (compoundMatches rejects it via specifiedSomething,
    // ancestorChainSatisfies treats it as vacuously satisfied).
    bool compoundPartsMatch(const CompoundParts &compound, const std::string &tag,
                             const std::vector<std::string> &classes, const std::string &id)
    {
        bool tagOk = compound.tag.empty() || compound.tag == tag;
        bool idOk = compound.id.empty() || compound.id == id;
        bool classesOk = true;
        for (const auto &cls : compound.classes) {
            if (std::find(classes.begin(), classes.end(), cls) == classes.end()) {
                classesOk = false;
                break;
            }
        }
        return tagOk && idOk && classesOk;
    }
 
    // A selector matches only if EVERY part it specifies is present on this
    // element -- in particular every class listed, not just one. A bare tag
    // left over after stripping a combinator's ancestor part (e.g.
    // "[data-atom=header]>div" reduces to bare "div") is rejected outright
    // for the TARGET compound, even when @p targetAttrs/ancestor
    // verification is available: on a real component-library/page-builder
    // site, a generic "layout plumbing" ancestor condition like
    // "[data-atom][data-atom=header]" is common enough (used on nearly
    // every content block) that a bare "div" child of it is still
    // effectively a near-blanket match once combined with this file's
    // specificity ordering (see computeSpecificity) -- confirmed on a real
    // scraped page: relaxing this guard for a "genuinely verified" ancestor
    // let "[data-atom][data-atom=header]>div{width:var(--a-width)}" (pure
    // layout plumbing, specificity (0,2,1)) win over a much more specific,
    // content-driven ".status-dot{width:12px}" (specificity (0,1,0)) rule
    // purely because the plumbing rule now qualified as a real match, even
    // though genuinely verifying its own ancestor chain didn't make it safe
    // to trust the bare-tag side too. A class/id/attribute qualifier
    // alongside the tag (e.g. "div.foo") is already specific enough to
    // check on its own and never triggers this rejection.
    bool compoundMatches(const CompoundParts &compound, bool hadCombinator,
                          const std::string &tag, const std::vector<std::string> &classes,
                          const std::string &id,
                          const std::map<std::string,std::string> *targetAttrs = nullptr)
    {
        bool bareTagAfterCombinator = hadCombinator &&
            compound.classes.empty() && compound.id.empty() &&
            compound.attrConditions.empty() && !compound.tag.empty();
        // An attribute condition only counts as "this compound specifies a
        // real requirement" when @p targetAttrs is actually available to
        // check it against -- a caller with no attribute map (e.g.
        // approximateSelectorMatch's own callers, which never pass one)
        // still can't verify it, so a purely-attribute compound like
        // "[data-x]" reverts to the old "nothing specified, reject" outcome
        // for them instead of permissively matching every element.
        bool specifiedSomething = !compound.tag.empty() || !compound.classes.empty() ||
                                   !compound.id.empty() ||
                                   (!compound.attrConditions.empty() && targetAttrs != nullptr);
        if (bareTagAfterCombinator || !specifiedSomething) return false;
 
        return compoundPartsMatch(compound, tag, classes, id) &&
               attributeConditionsSatisfied(compound.attrConditions, targetAttrs);
    }
 
    // Splits a single (already comma-branch-isolated) selector into its
    // combinator-separated compounds, left-to-right / outermost-ancestor-
    // first -- e.g. ".a .b > .c" -> [".a", ".b", ".c"]. Combinator type
    // (space/">"/"+"/"~") is discarded, same simplification this matcher
    // always made even when it only ever looked at the trailing compound:
    // it never distinguished child from descendant/sibling combinators.
    // Verifying ancestors approximately -- present somewhere in the chain,
    // in left-to-right order, not necessarily adjacent -- is still far more
    // correct than not verifying them at all (see ancestorChainSatisfies).
    std::vector<std::string> splitCombinatorChain(const std::string &selector) {
        std::vector<std::string> parts;
        std::string cur;
        for (char c : selector) {
            if (c == ' ' || c == '\t' || c == '\n' || c == '\r' ||
                c == '>' || c == '+' || c == '~') {
                if (!cur.empty()) { parts.push_back(cur); cur.clear(); }
            } else {
                cur += c;
            }
        }
        if (!cur.empty()) parts.push_back(cur);
        return parts;
    }
 
    // Whether every compound in `ancestorCompounds` (left-to-right /
    // outermost-first -- see splitCombinatorChain) can be matched, in that
    // order, against some frame in `ancestors` (also outermost-first,
    // closest/immediate-parent last -- see AncestorFrame). Each compound
    // consumes the ancestor it matched and everything closer to the target
    // than it, so a later compound can never be satisfied by an ancestor
    // farther out than one an earlier compound already matched --
    // approximating real left-to-right descendant-selector semantics
    // without distinguishing combinator type, requiring adjacency, or
    // computing true specificity. A compound with NEITHER tag/class/id NOR
    // any attribute condition (unsafe syntax reduced to nothing, see
    // splitCombinatorChain's callers -- an unsupported pseudo-class was
    // present) is vacuously satisfied without consuming an ancestor slot --
    // an unverifiable requirement shouldn't by itself invalidate an
    // otherwise plausible match, same "not proven to not match" philosophy
    // as the rest of this file. If @p usedUnverifiableAncestor is non-null,
    // it's set to true whenever this happens, so a caller merging
    // declarations into a props map (see collectApproximateMatches) can
    // single out display:none/visibility:hidden from such a match -- unlike
    // most properties, a wrong guess there doesn't just mis-style an
    // element, it makes the element and its whole subtree disappear from
    // the import. A compound that DOES carry attribute conditions (e.g.
    // "[data-fit=fill]" in ".fade-box[data-fit=fill] img") is a real,
    // checkable requirement: it's matched against each candidate frame's own
    // attributes (see AncestorFrame::attributes) the same way
    // compoundPartsMatch checks tag/class/id -- a frame with no attributes
    // supplied (an empty map, meaning the caller didn't populate that field)
    // can't refute it, so it's treated as satisfied for that frame rather
    // than guessed wrong.
    bool ancestorChainSatisfies(const std::vector<CompoundParts> &ancestorCompounds,
                                 const std::vector<libhtmlpp::AncestorFrame> &ancestors,
                                 bool *usedUnverifiableAncestor = nullptr)
    {
        size_t idx = 0;
        for (const auto &compound : ancestorCompounds) {
            bool specifiedSomething = !compound.tag.empty() || !compound.classes.empty() ||
                                       !compound.id.empty() || !compound.attrConditions.empty();
            if (!specifiedSomething) {
                if (usedUnverifiableAncestor) *usedUnverifiableAncestor = true;
                continue;
            }
 
            bool found = false;
            while (idx < ancestors.size()) {
                const libhtmlpp::AncestorFrame &frame = ancestors[idx];
                ++idx;
                if (compoundPartsMatch(compound, frame.tag, frame.classes, frame.id) &&
                    attributeConditionsSatisfied(compound.attrConditions,
                        frame.attributes.empty() ? nullptr : &frame.attributes)) {
                    found = true;
                    break;
                }
            }
            if (!found) return false;
        }
        return true;
    }
 
    // Selector syntax this matcher can't safely evaluate -- pseudo-
    // classes/elements describe state (":hover") this matcher has no way to
    // check, and "*" would blanket-match every element. Guessing wrong here
    // is worse than not matching at all. Attribute selectors ("[href]") are
    // handled separately (see stripAttributeSelectors) rather than rejected
    // here, since by the time this runs they've already been removed from
    // whatever compound they were attached to.
    bool hasUnsupportedSelectorSyntax(const std::string &matchSel) {
        return matchSel.find(':') != std::string::npos ||
               matchSel == "*";
    }
 
    // Removes every "[...]" attribute-selector segment from a compound
    // selector (already combinator-stripped -- see stripCombinator), so a
    // compound like ".card[data-variant=featured]" is still checkable on
    // its verifiable ".card" part instead of being thrown away entirely.
    // This matcher has no per-element attribute map to verify the
    // condition itself (collectApproximateMatches only ever gets a single
    // element's tag/class/id, see its own doc comment), so the condition is
    // simply ignored rather than guessed -- on a component-library site
    // (e.g. a page builder) nearly every layout/visibility toggle is
    // expressed as "known class + [data-variant=x]" rather than a distinct
    // class per variant, so rejecting the whole compound meant NONE of
    // those rules were ever seen. This can still occasionally pick a
    // sibling variant's declarations when several "[data-variant=...]"
    // rules share the same base class (last rule of equal priority wins,
    // the same cascade approximation used everywhere else in this file),
    // but that is far closer to the source page than matching nothing.
    // Malformed/unterminated "[" is left in place rather than risk
    // corrupting the rest of the compound.
    std::string stripAttributeSelectors(const std::string &matchSel) {
        if (matchSel.find('[') == std::string::npos) return matchSel;
        std::string out;
        out.reserve(matchSel.size());
        size_t pos = 0;
        while (pos < matchSel.size()) {
            if (matchSel[pos] == '[') {
                size_t close = matchSel.find(']', pos + 1);
                if (close == std::string::npos) { out += matchSel.substr(pos); break; }
                pos = close + 1;
            } else {
                out += matchSel[pos];
                ++pos;
            }
        }
        return out;
    }
 
    // Finds the index of the ')' matching the '(' at `openPos` (which must
    // point at '(' itself), respecting nested parens. Returns npos if
    // unterminated.
    size_t findMatchingParen(const std::string &s, size_t openPos) {
        int depth = 0;
        for (size_t i = openPos; i < s.size(); ++i) {
            if (s[i] == '(') ++depth;
            else if (s[i] == ')') {
                --depth;
                if (depth == 0) return i;
            }
        }
        return std::string::npos;
    }
 
    // Approximate CSS specificity of one full comma-branch selector (e.g.
    // "div.card#hero[data-x]:hover .child"), as the standard (id-count,
    // class/attribute/pseudo-class-count, type/pseudo-element-count) triple
    // -- compared lexicographically, so any number of classes always loses
    // to a single id, any number of tags always loses to a single class,
    // same as a real browser's cascade. Used to let a more specific
    // matching rule win regardless of source order (see
    // collectApproximateMatches), instead of this file's usual plain
    // last-rule-wins approximation -- unlike matching itself, specificity
    // doesn't need per-element context, so it's computed once per rule
    // from the raw selector text and cached (see _CompoundCacheBranch),
    // covering compounds this matcher can't safely verify (attribute
    // selectors, pseudo-classes -- see stripAttributeSelectors/
    // hasUnsupportedSelectorSyntax) exactly the same as ones it can: real
    // CSS specificity is a property of the selector text, independent of
    // whether this approximate matcher happens to be able to verify every
    // part of it. Deliberately approximate like the rest of this file: a
    // literal '.'/'#'/'[' inside a quoted attribute value (e.g.
    // "[href=\"a.b\"]") could miscount since this scans raw text rather
    // than a real tokenizer, but attribute selectors are always skipped as
    // one atomic "[...]" unit (never scanned inside), so that specific case
    // doesn't actually miscount.
    std::array<int,3> computeSpecificity(const std::string &selector) {
        std::array<int,3> spec{0, 0, 0};
        size_t pos = 0;
        auto skipIdent = [&](size_t p) {
            while (p < selector.size() &&
                   (std::isalnum(static_cast<unsigned char>(selector[p])) ||
                    selector[p] == '-' || selector[p] == '_' || selector[p] == '\\')) {
                ++p;
            }
            return p;
        };
        while (pos < selector.size()) {
            char c = selector[pos];
            if (c == '#') {
                ++spec[0];
                pos = skipIdent(pos + 1);
            } else if (c == '.') {
                ++spec[1];
                pos = skipIdent(pos + 1);
            } else if (c == '[') {
                ++spec[1];
                size_t close = selector.find(']', pos + 1);
                pos = (close == std::string::npos) ? selector.size() : close + 1;
            } else if (c == ':') {
                bool pseudoElement = pos + 1 < selector.size() && selector[pos + 1] == ':';
                ++spec[pseudoElement ? 2 : 1];
                pos = skipIdent(pos + (pseudoElement ? 2 : 1));
                if (pos < selector.size() && selector[pos] == '(') {
                    size_t close = findMatchingParen(selector, pos);
                    pos = (close == std::string::npos) ? selector.size() : close + 1;
                }
            } else if (c == '*') {
                ++pos; // universal selector: contributes nothing, per spec
            } else if (std::isalpha(static_cast<unsigned char>(c)) || c == '_') {
                size_t next = skipIdent(pos);
                if (next > pos) ++spec[2];
                pos = next;
            } else {
                ++pos; // whitespace/combinators/etc -- not part of any token
            }
        }
        return spec;
    }
 
    // Splits `inner` (the text between "var(" and its matching ")") at the
    // first top-level comma (depth 0, not inside a nested "(...)") into a
    // trimmed custom-property name and a trimmed fallback ("" if no comma
    // is present, i.e. no fallback was given).
    void splitVarArgs(const std::string &inner, std::string &name, std::string &fallback) {
        int depth = 0;
        size_t commaPos = std::string::npos;
        for (size_t i = 0; i < inner.size(); ++i) {
            if (inner[i] == '(') ++depth;
            else if (inner[i] == ')') --depth;
            else if (inner[i] == ',' && depth == 0) { commaPos = i; break; }
        }
        std::string rawName = (commaPos == std::string::npos) ? inner : inner.substr(0, commaPos);
        std::string rawFallback = (commaPos == std::string::npos) ? "" : inner.substr(commaPos + 1);
        name = trim(rawName);
        fallback = trim(rawFallback);
    }
 
    // Substitutes every var(...) occurrence in `value`, recursively --
    // `resolving` (the set of custom-property names currently being
    // expanded on this call stack) provides cycle detection: a name already
    // in it resolves to "" instead of recursing forever. `sawUnresolved` is
    // set to true (never reset to false) whenever a var() reference turns
    // out invalid per spec (cyclic, or absent with no fallback) -- callers
    // use this to tell "resolved cleanly" apart from "silently substituted
    // an empty string", since the latter, left in a still-live declaration
    // like `calc( * 1px + ...)`, is worse than dropping the declaration:
    // it's syntactically-broken-but-not-obviously-invalid text rather than
    // a clean absence.
    std::string substituteVars(const std::string &value,
                                const std::map<std::string,std::string> &customProperties,
                                std::set<std::string> &resolving,
                                bool &sawUnresolved)
    {
        if (value.find("var(") == std::string::npos) return value;
 
        std::string out;
        out.reserve(value.size());
        size_t pos = 0;
        while (pos < value.size()) {
            if (value.compare(pos, 4, "var(") == 0) {
                size_t openParen = pos + 3;
                size_t closeParen = findMatchingParen(value, openParen);
                if (closeParen == std::string::npos) {
                    // Malformed/unterminated var( -- leave the rest as-is
                    // rather than risk corrupting it.
                    out += value.substr(pos);
                    break;
                }
                std::string inner = value.substr(openParen + 1, closeParen - openParen - 1);
                std::string name, fallback;
                splitVarArgs(inner, name, fallback);
 
                std::string substitution;
                if (resolving.count(name)) {
                    substitution = ""; // cyclic reference -- invalid per spec
                    sawUnresolved = true;
                } else {
                    auto it = customProperties.find(name);
                    if (it != customProperties.end()) {
                        resolving.insert(name);
                        substitution = substituteVars(it->second, customProperties, resolving, sawUnresolved);
                        resolving.erase(name);
                    } else if (!fallback.empty()) {
                        substitution = substituteVars(fallback, customProperties, resolving, sawUnresolved);
                    } else {
                        substitution = ""; // unresolvable, no fallback -- invalid per spec
                        sawUnresolved = true;
                    }
                }
                out += substitution;
                pos = closeParen + 1;
            } else {
                out += value[pos];
                ++pos;
            }
        }
        return out;
    }
 
}
 
// --- CSSProperty ---
 
libhtmlpp::CSSProperty::CSSProperty() {}
 
libhtmlpp::CSSProperty::CSSProperty(const std::string &name, const std::string &value)
    : _Name(name), _Value(value) {}
 
libhtmlpp::CSSProperty::CSSProperty(const CSSProperty &prop)
    : _Name(prop._Name), _Value(prop._Value) {}
 
libhtmlpp::CSSProperty::~CSSProperty() {}
 
libhtmlpp::CSSProperty& libhtmlpp::CSSProperty::operator=(const CSSProperty &prop) {
    if (this != &prop) {
        _Name  = prop._Name;
        _Value = prop._Value;
    }
    return *this;
}
 
const std::string& libhtmlpp::CSSProperty::getName() const { return _Name; }
void libhtmlpp::CSSProperty::setName(const std::string &name) { _Name = name; }
 
const std::string& libhtmlpp::CSSProperty::getValue() const { return _Value; }
void libhtmlpp::CSSProperty::setValue(const std::string &value) { _Value = value; }
 
// --- CSSDeclaration ---
 
libhtmlpp::CSSDeclaration::CSSDeclaration() {}
 
libhtmlpp::CSSDeclaration::CSSDeclaration(const CSSDeclaration &decl)
    : _Properties(decl._Properties) {}
 
libhtmlpp::CSSDeclaration::~CSSDeclaration() {}
 
libhtmlpp::CSSDeclaration& libhtmlpp::CSSDeclaration::operator=(const CSSDeclaration &decl) {
    if (this != &decl) {
        _Properties = decl._Properties;
    }
    return *this;
}
 
void libhtmlpp::CSSDeclaration::addProperty(const std::string &name, const std::string &value) {
    std::string tname  = trim(name);
    std::string tvalue = trim(value);
 
    if (tname.empty()) return;
 
    for (auto &prop : _Properties) {
        if (prop.getName() == tname) {
            prop.setValue(tvalue);
            return;
        }
    }
    _Properties.emplace_back(tname, tvalue);
}
 
void libhtmlpp::CSSDeclaration::removeProperty(const std::string &name) {
    std::string tname = trim(name);
    _Properties.erase(
        std::remove_if(_Properties.begin(), _Properties.end(),
            [&tname](const CSSProperty &p) { return p.getName() == tname; }),
        _Properties.end()
    );
}
 
const libhtmlpp::CSSProperty* libhtmlpp::CSSDeclaration::getProperty(const std::string &name) const {
    std::string tname = trim(name);
    for (const auto &prop : _Properties) {
        if (prop.getName() == tname) return &prop;
    }
    return nullptr;
}
 
const std::vector<libhtmlpp::CSSProperty>& libhtmlpp::CSSDeclaration::getProperties() const {
    return _Properties;
}
 
std::string libhtmlpp::CSSDeclaration::serialize() const {
    std::string result;
    for (size_t i = 0; i < _Properties.size(); ++i) {
        result += _Properties[i].getName();
        result += ": ";
        result += _Properties[i].getValue();
        result += ";";
        if (i + 1 < _Properties.size()) result += " ";
    }
    return result;
}
 
void libhtmlpp::CSSDeclaration::parse(const std::string &input) {
    _Properties.clear();
 
    size_t pos = 0;
    size_t len = input.size();
 
    while (pos < len) {
        // Skip whitespace
        while (pos < len && isWhitespace(input[pos])) ++pos;
        if (pos >= len) break;
 
        // Find the colon separating property name from value
        size_t colon = input.find(':', pos);
        if (colon == std::string::npos) break;
 
        std::string propName = trim(input.substr(pos, colon - pos));
 
        pos = colon + 1;
 
        // Find the semicolon ending this declaration
        // Handle parentheses for functions like rgb(), url()
        size_t valueStart = pos;
        int parenDepth = 0;
        bool inSingleQuote = false;
        bool inDoubleQuote = false;
 
        while (pos < len) {
            char c = input[pos];
 
            if (inSingleQuote) {
                if (c == '\'') inSingleQuote = false;
                ++pos;
                continue;
            }
            if (inDoubleQuote) {
                if (c == '"') inDoubleQuote = false;
                ++pos;
                continue;
            }
 
            if (c == '\'') { inSingleQuote = true; ++pos; continue; }
            if (c == '"')  { inDoubleQuote = true; ++pos; continue; }
            if (c == '(')  { ++parenDepth; ++pos; continue; }
            if (c == ')')  { if (parenDepth > 0) --parenDepth; ++pos; continue; }
 
            if (c == ';' && parenDepth == 0) {
                break;
            }
            ++pos;
        }
 
        std::string propValue = trim(input.substr(valueStart, pos - valueStart));
 
        if (!propName.empty()) {
            addProperty(propName, propValue);
        }
 
        if (pos < len && input[pos] == ';') ++pos;
    }
}
 
void libhtmlpp::CSSDeclaration::clear() {
    _Properties.clear();
}
 
// --- CSSRule ---
 
libhtmlpp::CSSRule::CSSRule() {}
 
libhtmlpp::CSSRule::CSSRule(const std::string &selector)
    : _Selector(trim(selector)) {}
 
libhtmlpp::CSSRule::CSSRule(const CSSRule &rule)
    : _Selector(rule._Selector), _Declaration(rule._Declaration) {}
 
libhtmlpp::CSSRule::~CSSRule() {}
 
libhtmlpp::CSSRule& libhtmlpp::CSSRule::operator=(const CSSRule &rule) {
    if (this != &rule) {
        _Selector    = rule._Selector;
        _Declaration = rule._Declaration;
    }
    return *this;
}
 
const std::string& libhtmlpp::CSSRule::getSelector() const { return _Selector; }
void libhtmlpp::CSSRule::setSelector(const std::string &selector) { _Selector = trim(selector); }
 
libhtmlpp::CSSDeclaration& libhtmlpp::CSSRule::getDeclaration() { return _Declaration; }
const libhtmlpp::CSSDeclaration& libhtmlpp::CSSRule::getDeclaration() const { return _Declaration; }
 
std::string libhtmlpp::CSSRule::serialize(bool formatted) const {
    std::string result;
    if (formatted) {
        result += _Selector + " {\n";
        for (const auto &prop : _Declaration.getProperties()) {
            result += "    " + prop.getName() + ": " + prop.getValue() + ";\n";
        }
        result += "}";
    } else {
        result += _Selector + "{";
        result += _Declaration.serialize();
        result += "}";
    }
    return result;
}
 
// --- CSSStyleSheet ---
 
libhtmlpp::CSSStyleSheet::CSSStyleSheet() {}
 
libhtmlpp::CSSStyleSheet::CSSStyleSheet(const CSSStyleSheet &sheet)
    : _Rules(sheet._Rules) {}
 
libhtmlpp::CSSStyleSheet::~CSSStyleSheet() {}
 
libhtmlpp::CSSStyleSheet& libhtmlpp::CSSStyleSheet::operator=(const CSSStyleSheet &sheet) {
    if (this != &sheet) {
        _Rules = sheet._Rules;
        _compoundCacheValid = false;
    }
    return *this;
}
 
void libhtmlpp::CSSStyleSheet::_skipWhitespace(const std::string &input, size_t &pos) const {
    while (pos < input.size() && isWhitespace(input[pos])) ++pos;
}
 
void libhtmlpp::CSSStyleSheet::_skipComment(const std::string &input, size_t &pos) const {
    if (pos + 1 < input.size() && input[pos] == '/' && input[pos + 1] == '*') {
        pos += 2;
        while (pos + 1 < input.size()) {
            if (input[pos] == '*' && input[pos + 1] == '/') {
                pos += 2;
                return;
            }
            ++pos;
        }
        pos = input.size();
    }
}
 
void libhtmlpp::CSSStyleSheet::parse(const std::string &input) {
    _Rules.clear();
    _compoundCacheValid = false;
 
    size_t pos = 0;
    size_t len = input.size();
 
    while (pos < len) {
        _skipWhitespace(input, pos);
        if (pos >= len) break;
 
        // Skip comments
        if (pos + 1 < len && input[pos] == '/' && input[pos + 1] == '*') {
            _skipComment(input, pos);
            continue;
        }
 
        // Handle @-rules
        if (input[pos] == '@') {
            size_t atStart = pos;
 
            // Check for @-rules with blocks like @media, @keyframes, @supports, @font-face
            // and simple @-rules like @import, @charset
            size_t semiPos = input.find(';', pos);
            size_t bracePos = input.find('{', pos);
 
            if (bracePos != std::string::npos && (semiPos == std::string::npos || bracePos < semiPos)) {
                // Block @-rule: find matching closing brace
                std::string atSelector = trim(input.substr(atStart, bracePos - atStart));
                pos = bracePos + 1;
 
                int depth = 1;
                size_t blockStart = pos;
                while (pos < len && depth > 0) {
                    if (input[pos] == '{') ++depth;
                    else if (input[pos] == '}') --depth;
                    if (depth > 0) ++pos;
                }
 
                std::string blockContent = input.substr(blockStart, pos - blockStart);
                pos = (pos < len) ? pos + 1 : pos;
 
                // Parse nested rules inside the @-block
                CSSStyleSheet nested;
                nested.parse(blockContent);
 
                // Wrap each nested rule with the @-selector
                for (const auto &nestedRule : nested.getRules()) {
                    CSSRule rule;
                    rule.setSelector(atSelector + " " + nestedRule.getSelector());
                    for (const auto &prop : nestedRule.getDeclaration().getProperties()) {
                        rule.getDeclaration().addProperty(prop.getName(), prop.getValue());
                    }
                    _Rules.push_back(rule);
                }
 
                // If no nested rules (e.g. @font-face), store as single rule
                if (nested.getRuleCount() == 0 && !blockContent.empty()) {
                    CSSRule rule(atSelector);
                    rule.getDeclaration().parse(blockContent);
                    _Rules.push_back(rule);
                }
            } else if (semiPos != std::string::npos) {
                // Simple @-rule ending with semicolon (e.g. @import, @charset)
                std::string atRule = trim(input.substr(atStart, semiPos - atStart));
                CSSRule rule(atRule);
                _Rules.push_back(rule);
                pos = semiPos + 1;
            } else {
                // Malformed @-rule, skip
                ++pos;
            }
            continue;
        }
 
        // Standard rule: find selector then { declarations }
        size_t braceOpen = input.find('{', pos);
        if (braceOpen == std::string::npos) break;
 
        std::string selector = trim(input.substr(pos, braceOpen - pos));
        pos = braceOpen + 1;
 
        // Find matching closing brace
        int depth = 1;
        size_t declStart = pos;
        while (pos < len && depth > 0) {
            if (pos + 1 < len && input[pos] == '/' && input[pos + 1] == '*') {
                _skipComment(input, pos);
                continue;
            }
            if (input[pos] == '{') ++depth;
            else if (input[pos] == '}') --depth;
            if (depth > 0) ++pos;
        }
 
        std::string declarations = input.substr(declStart, pos - declStart);
        pos = (pos < len) ? pos + 1 : pos;
 
        if (!selector.empty()) {
            CSSRule rule(selector);
            rule.getDeclaration().parse(declarations);
            _Rules.push_back(rule);
        }
    }
}
 
void libhtmlpp::CSSStyleSheet::addRule(const CSSRule &rule) {
    _Rules.push_back(rule);
    _compoundCacheValid = false;
}
 
void libhtmlpp::CSSStyleSheet::removeRule(size_t index) {
    if (index < _Rules.size()) {
        _Rules.erase(_Rules.begin() + static_cast<std::ptrdiff_t>(index));
        _compoundCacheValid = false;
    }
}
 
const libhtmlpp::CSSRule* libhtmlpp::CSSStyleSheet::getRule(size_t index) const {
    if (index < _Rules.size()) return &_Rules[index];
    return nullptr;
}
 
size_t libhtmlpp::CSSStyleSheet::getRuleCount() const {
    return _Rules.size();
}
 
const std::vector<libhtmlpp::CSSRule>& libhtmlpp::CSSStyleSheet::getRules() const {
    return _Rules;
}
 
std::string libhtmlpp::CSSStyleSheet::serialize(bool formatted) const {
    std::string result;
    for (size_t i = 0; i < _Rules.size(); ++i) {
        result += _Rules[i].serialize(formatted);
        if (formatted) result += "\n";
        if (i + 1 < _Rules.size() && formatted) result += "\n";
    }
    return result;
}
 
void libhtmlpp::CSSStyleSheet::clear() {
    _Rules.clear();
    _compoundCacheValid = false;
}
 
libhtmlpp::CSSDeclaration libhtmlpp::CSSStyleSheet::parseInlineStyle(const std::string &style) {
    CSSDeclaration decl;
    decl.parse(style);
    return decl;
}
 
bool libhtmlpp::CSSStyleSheet::approximateSelectorMatch(const std::string &selector,
                                                          const std::string &tag,
                                                          const std::vector<std::string> &classes,
                                                          const std::string &id,
                                                          const std::vector<AncestorFrame> *ancestors)
{
    std::string tagLower = tag;
    std::transform(tagLower.begin(), tagLower.end(), tagLower.begin(),
        [](unsigned char c) { return std::tolower(c); });
 
    std::istringstream selStream(selector);
    std::string singleSel;
    while (std::getline(selStream, singleSel, ',')) {
        size_t start = singleSel.find_first_not_of(" \t\n\r");
        if (start == std::string::npos) continue;
        size_t end = singleSel.find_last_not_of(" \t\n\r");
        singleSel = singleSel.substr(start, end - start + 1);
 
        std::vector<std::string> chain = splitCombinatorChain(singleSel);
        if (chain.empty()) continue;
        bool hadCombinator = chain.size() > 1;
 
        std::string matchSel = stripAttributeSelectors(chain.back());
        if (hasUnsupportedSelectorSyntax(matchSel)) continue;
 
        CompoundParts compound = parseCompoundSelector(matchSel);
        compound.attrConditions = parseAttributeConditions(chain.back());
        if (!compoundMatches(compound, hadCombinator, tagLower, classes, id)) continue;
 
        if (ancestors && chain.size() > 1) {
            std::vector<CompoundParts> ancestorCompounds;
            for (size_t i = 0; i + 1 < chain.size(); ++i) {
                std::string aSel = stripAttributeSelectors(chain[i]);
                if (hasUnsupportedSelectorSyntax(aSel)) {
                    ancestorCompounds.push_back({});
                } else {
                    CompoundParts aCompound = parseCompoundSelector(aSel);
                    aCompound.attrConditions = parseAttributeConditions(chain[i]);
                    ancestorCompounds.push_back(std::move(aCompound));
                }
            }
            if (!ancestorChainSatisfies(ancestorCompounds, *ancestors)) continue;
        }
        return true;
    }
    return false;
}
 
// Pre-parses every rule's selector list (comma-split, trim, strip combinator,
// reject unsupported syntax, split into tag/classes/id) exactly the way
// collectApproximateMatches used to redo inline on every call -- see this
// cache's doc comment in css.h for why. Must be re-run (via
// _compoundCacheValid) whenever _Rules changes.
void libhtmlpp::CSSStyleSheet::_rebuildCompoundCache() const {
    _compoundCache.clear();
    _compoundCache.reserve(_Rules.size());
 
    for (const auto &rule : _Rules) {
        std::vector<_CompoundCacheBranch> branches;
        const std::string &sel = rule.getSelector();
 
        if (!sel.empty()) {
            bool isAtRule = sel[0] == '@';
            std::string atWrapper;
            std::string innerSel;
            bool atRuleUnparseable = false;
 
            if (isAtRule) {
                size_t parenDepth = 0;
                size_t splitPos = std::string::npos;
                for (size_t i = 0; i < sel.size(); ++i) {
                    if (sel[i] == '(') ++parenDepth;
                    else if (sel[i] == ')') {
                        if (parenDepth > 0) --parenDepth;
                        if (parenDepth == 0) {
                            splitPos = i + 1;
                            // A compound condition -- e.g. "@media
                            // (min-width:768px) and (max-width:992px)" --
                            // chains multiple parenthesized feature tests
                            // with "and"/"or"/"not" (media queries and
                            // @supports both use this). Without this check,
                            // the wrapper would end after the FIRST feature
                            // test and everything from "and (...)" onward
                            // would be misread as the rule's own selector
                            // list instead of the rest of its condition.
                            size_t next = sel.find_first_not_of(" \t\n\r", splitPos);
                            if (next == std::string::npos) break;
                            size_t kwEnd = next;
                            while (kwEnd < sel.size() &&
                                   std::isalpha(static_cast<unsigned char>(sel[kwEnd]))) {
                                ++kwEnd;
                            }
                            std::string kw = sel.substr(next, kwEnd - next);
                            std::transform(kw.begin(), kw.end(), kw.begin(),
                                [](unsigned char c) { return std::tolower(c); });
                            if (kw == "and" || kw == "or" || kw == "not") {
                                size_t afterKw = sel.find_first_not_of(" \t\n\r", kwEnd);
                                if (afterKw != std::string::npos && sel[afterKw] == '(') {
                                    i = afterKw - 1; // for-loop's ++i lands on afterKw
                                    continue;
                                }
                            }
                            break;
                        }
                    }
                }
                if (splitPos != std::string::npos && splitPos < sel.size()) {
                    atWrapper = sel.substr(0, splitPos);
                    size_t innerStart = sel.find_first_not_of(" \t\n\r", splitPos);
                    if (innerStart != std::string::npos) innerSel = sel.substr(innerStart);
                }
                if (innerSel.empty()) atRuleUnparseable = true;
            }
 
            if (!atRuleUnparseable) {
                const std::string &matchTarget = isAtRule ? innerSel : sel;
 
                std::istringstream selStream(matchTarget);
                std::string singleSel;
                while (std::getline(selStream, singleSel, ',')) {
                    size_t start = singleSel.find_first_not_of(" \t\n\r");
                    if (start == std::string::npos) continue;
                    size_t end = singleSel.find_last_not_of(" \t\n\r");
                    singleSel = singleSel.substr(start, end - start + 1);
 
                    _CompoundCacheBranch branch;
                    branch.isAtRule = isAtRule;
                    branch.atWrapper = atWrapper;
                    branch.trimmedSelector = singleSel;
                    branch.specificity = computeSpecificity(singleSel);
 
                    std::vector<std::string> chain = splitCombinatorChain(singleSel);
                    bool hadCombinator = chain.size() > 1;
                    std::string matchSel = chain.empty() ? std::string()
                                                          : stripAttributeSelectors(chain.back());
                    if (chain.empty() || hasUnsupportedSelectorSyntax(matchSel)) {
                        branch.skip = true;
                    } else {
                        CompoundParts compound = parseCompoundSelector(matchSel);
                        branch.skip = false;
                        branch.tag = compound.tag;
                        branch.classes = compound.classes;
                        branch.id = compound.id;
                        branch.attrConditions = parseAttributeConditions(chain.back());
                        branch.hadCombinator = hadCombinator;
                        for (size_t i = 0; i + 1 < chain.size(); ++i) {
                            std::string aSel = stripAttributeSelectors(chain[i]);
                            if (hasUnsupportedSelectorSyntax(aSel)) {
                                branch.ancestorCompounds.push_back({});
                            } else {
                                CompoundParts aCompound = parseCompoundSelector(aSel);
                                branch.ancestorCompounds.push_back(
                                    {aCompound.tag, aCompound.classes, aCompound.id,
                                     parseAttributeConditions(chain[i])});
                            }
                        }
                    }
                    branches.push_back(std::move(branch));
                }
            }
        }
 
        _compoundCache.push_back(std::move(branches));
    }
 
    _compoundCacheValid = true;
}
 
void libhtmlpp::CSSStyleSheet::collectApproximateMatches(
    const std::string &tag,
    const std::string &cssClass,
    const std::string &id,
    std::map<std::string,std::string> &props,
    std::string &mediaRules,
    std::set<std::string> &seenMediaBlocks,
    const std::vector<AncestorFrame> *ancestors,
    const std::map<std::string,std::string> *targetAttributes) const
{
    std::string tagLower = tag;
    std::transform(tagLower.begin(), tagLower.end(), tagLower.begin(),
        [](unsigned char c) { return std::tolower(c); });
 
    std::vector<std::string> classes;
    if (!cssClass.empty()) {
        std::istringstream iss(cssClass);
        std::string cls;
        while (iss >> cls) classes.push_back(cls);
    }
 
    // Property names already present in @p props when we're called (e.g.
    // the element's own inline style, set by the caller before calling this)
    // outrank a plain stylesheet rule, unless that rule is "!important" --
    // matching real cascade precedence.
    std::set<std::string> inlineKeys;
    for (const auto &kv : props) inlineKeys.insert(kv.first);
    std::set<std::string> importantKeys;
    // Specificity of whichever rule currently "owns" each property, kept
    // separately per precedence tier (plain vs !important) so a more
    // specific rule wins regardless of source order within its own tier --
    // real CSS cascade order is (origin/importance, specificity, source
    // order); a later-but-less-specific rule should never beat an earlier
    // one (confirmed on a real page-builder site: a plain
    // ".fade-box img{width:auto}" was winning over an earlier but more
    // specific ".fade-box[data-fit=fill] img{object-fit:cover}" purely
    // because it came later in the stylesheet).
    std::map<std::string, std::array<int,3>> plainSpecOf;
    std::map<std::string, std::array<int,3>> importantSpecOf;
 
    if (!_compoundCacheValid) _rebuildCompoundCache();
 
    for (size_t ri = 0; ri < _Rules.size(); ++ri) {
        const CSSRule &rule = _Rules[ri];
        const auto &branches = _compoundCache[ri];
 
        for (const auto &branch : branches) {
            if (branch.skip) continue;
 
            CompoundParts compound;
            compound.tag = branch.tag;
            compound.classes = branch.classes;
            compound.id = branch.id;
            compound.attrConditions = branch.attrConditions;
            if (!compoundMatches(compound, branch.hadCombinator, tagLower, classes, id, targetAttributes))
                continue;
 
            bool usedUnverifiableAncestor = false;
            if (ancestors && !branch.ancestorCompounds.empty()) {
                std::vector<CompoundParts> ancestorCompounds;
                for (const auto &ac : branch.ancestorCompounds) {
                    ancestorCompounds.push_back({ac.tag, ac.classes, ac.id, ac.attrConditions});
                }
                if (!ancestorChainSatisfies(ancestorCompounds, *ancestors, &usedUnverifiableAncestor))
                    continue;
            }
 
            if (branch.isAtRule) {
                // The same @media block, once present anywhere in the final
                // output, applies document-wide regardless of which element
                // it's attached to -- so including it more than once across
                // many matching elements is pure bloat, not a correctness
                // requirement.
                std::string block = branch.atWrapper + " { " + branch.trimmedSelector + " { ";
                for (const auto &prop : rule.getDeclaration().getProperties()) {
                    block += prop.getName() + ": " + prop.getValue() + "; ";
                }
                block += "} } ";
                if (seenMediaBlocks.insert(block).second) {
                    mediaRules += block;
                }
            } else {
                for (const auto &prop : rule.getDeclaration().getProperties()) {
                    std::string value = prop.getValue();
                    bool isImportant = stripImportant(value);
                    const std::string &key = prop.getName();
 
                    // Inline style and an already-!important value both
                    // outrank a later plain rule.
                    if (inlineKeys.count(key) && !isImportant) continue;
                    if (importantKeys.count(key) && !isImportant) continue;
 
                    // Within a precedence tier (plain vs !important, see
                    // above), a rule with LOWER specificity than whichever
                    // one currently owns this property loses -- same as a
                    // real cascade. Equal specificity still falls through
                    // to "later rule wins" below, matching real CSS.
                    auto &specOf = isImportant ? importantSpecOf : plainSpecOf;
                    auto specIt = specOf.find(key);
                    if (specIt != specOf.end() && specIt->second > branch.specificity)
                        continue;
 
                    // A match that only went through because an ancestor
                    // condition we can't verify (see
                    // ancestorChainSatisfies/usedUnverifiableAncestor) was
                    // treated as vacuously satisfied is exactly the kind of
                    // "maybe wrong" guess this file otherwise tolerates --
                    // except here: display:none/visibility:hidden don't
                    // just mis-style the element, they remove it and its
                    // whole subtree from the import. Drop just these two
                    // destructive values from an unverifiable match; every
                    // other property from the same rule still applies.
                    if (usedUnverifiableAncestor &&
                        ((key == "display" && value == "none") ||
                         (key == "visibility" && value == "hidden")))
                        continue;
 
                    props[key] = value;
                    specOf[key] = branch.specificity;
                    if (isImportant) importantKeys.insert(key);
                }
            }
        }
    }
}
 
std::string libhtmlpp::resolveCSSVariables(const std::string &value,
                                             const std::map<std::string,std::string> &customProperties,
                                             bool *unresolved)
{
    std::set<std::string> resolving;
    bool sawUnresolved = false;
    std::string result = substituteVars(value, customProperties, resolving, sawUnresolved);
    if (unresolved) *unresolved = sawUnresolved;
    return result;
}