Merge pull request #261 from biodranik/remove-const-ref

sammycage · web-flow · commit b350c01cb09b · 2026-02-05T07:59:06.000+01:00
Replaced const std::string_view&amp; with std::string_view for better performance
diff --git a/source/svgelement.cpp b/source/svgelement.cpp
@@ -10,7 +10,7 @@
 
 namespace lunasvg {
 
-ElementID elementid(const std::string_view& name)
+ElementID elementid(std::string_view name)
 {
     static const struct {
         std::string_view name;
@@ -129,23 +129,23 @@ SVGElement::SVGElement(Document* document, ElementID id)
 {
 }
 
-bool SVGElement::hasAttribute(const std::string_view& name) const
+bool SVGElement::hasAttribute(std::string_view name) const
 {
     auto id = propertyid(name);
     if(id == PropertyID::Unknown)
         return false;
     return hasAttribute(id);
 }
 
-const std::string& SVGElement::getAttribute(const std::string_view& name) const
+const std::string& SVGElement::getAttribute(std::string_view name) const
 {
     auto id = propertyid(name);
     if(id == PropertyID::Unknown)
         return emptyString;
     return getAttribute(id);
 }
 
-bool SVGElement::setAttribute(const std::string_view& name, const std::string& value)
+bool SVGElement::setAttribute(std::string_view name, const std::string& value)
 {
     auto id = propertyid(name);
     if(id == PropertyID::Unknown)
@@ -326,31 +326,31 @@ Rect SVGElement::paintBoundingBox() const
     return m_paintBoundingBox;
 }
 
-SVGMarkerElement* SVGElement::getMarker(const std::string_view& id) const
+SVGMarkerElement* SVGElement::getMarker(std::string_view id) const
 {
     auto element = rootElement()->getElementById(id);
     if(element && element->id() == ElementID::Marker)
         return static_cast<SVGMarkerElement*>(element);
     return nullptr;
 }
 
-SVGClipPathElement* SVGElement::getClipper(const std::string_view& id) const
+SVGClipPathElement* SVGElement::getClipper(std::string_view id) const
 {
     auto element = rootElement()->getElementById(id);
     if(element && element->id() == ElementID::ClipPath)
         return static_cast<SVGClipPathElement*>(element);
     return nullptr;
 }
 
-SVGMaskElement* SVGElement::getMasker(const std::string_view& id) const
+SVGMaskElement* SVGElement::getMasker(std::string_view id) const
 {
     auto element = rootElement()->getElementById(id);
     if(element && element->id() == ElementID::Mask)
         return static_cast<SVGMaskElement*>(element);
     return nullptr;
 }
 
-SVGPaintElement* SVGElement::getPainter(const std::string_view& id) const
+SVGPaintElement* SVGElement::getPainter(std::string_view id) const
 {
     auto element = rootElement()->getElementById(id);
     if(element && element->isPaintElement())
@@ -683,7 +683,7 @@ SVGRootElement* SVGRootElement::layoutIfNeeded()
     return this;
 }
 
-SVGElement* SVGRootElement::getElementById(const std::string_view& id) const
+SVGElement* SVGRootElement::getElementById(std::string_view id) const
 {
     auto it = m_idCache.find(id);
     if(it == m_idCache.end())
diff --git a/source/svgelement.h b/source/svgelement.h
@@ -108,7 +108,7 @@ enum class ElementID : uint8_t {
     Use
 };
 
-ElementID elementid(const std::string_view& name);
+ElementID elementid(std::string_view name);
 
 using SVGNodeList = std::list<std::unique_ptr<SVGNode>>;
 using SVGPropertyList = std::forward_list<SVGProperty*>;
@@ -129,9 +129,9 @@ class SVGElement : public SVGNode {
     SVGElement(Document* document, ElementID id);
     virtual ~SVGElement() = default;
 
-    bool hasAttribute(const std::string_view& name) const;
-    const std::string& getAttribute(const std::string_view& name) const;
-    bool setAttribute(const std::string_view& name, const std::string& value);
+    bool hasAttribute(std::string_view name) const;
+    const std::string& getAttribute(std::string_view name) const;
+    bool setAttribute(std::string_view name, const std::string& value);
 
     const Attribute* findAttribute(PropertyID id) const;
     bool hasAttribute(PropertyID id) const;
@@ -159,10 +159,10 @@ class SVGElement : public SVGNode {
     virtual Rect strokeBoundingBox() const;
     virtual Rect paintBoundingBox() const;
 
-    SVGMarkerElement* getMarker(const std::string_view& id) const;
-    SVGClipPathElement* getClipper(const std::string_view& id) const;
-    SVGMaskElement* getMasker(const std::string_view& id) const;
-    SVGPaintElement* getPainter(const std::string_view& id) const;
+    SVGMarkerElement* getMarker(std::string_view id) const;
+    SVGClipPathElement* getClipper(std::string_view id) const;
+    SVGMaskElement* getMasker(std::string_view id) const;
+    SVGPaintElement* getPainter(std::string_view id) const;
 
     SVGElement* elementFromPoint(float x, float y);
 
@@ -346,7 +346,7 @@ class SVGRootElement final : public SVGSVGElement {
 
     SVGRootElement* layoutIfNeeded();
 
-    SVGElement* getElementById(const std::string_view& id) const;
+    SVGElement* getElementById(std::string_view id) const;
     void addElementById(const std::string& id, SVGElement* element);
     void layout(SVGLayoutState& state) final;
 
diff --git a/source/svglayoutstate.cpp b/source/svglayoutstate.cpp
@@ -110,15 +110,15 @@ static float parseNumberOrPercentage(std::string_view input, bool allowPercentag
     return value;
 }
 
-static Length parseLength(const std::string_view& input, LengthNegativeMode mode, const Length& defaultValue)
+static Length parseLength(std::string_view input, LengthNegativeMode mode, const Length& defaultValue)
 {
     Length value;
     if(!value.parse(input, mode))
         value = defaultValue;
     return value;
 }
 
-static BaselineShift parseBaselineShift(const std::string_view& input)
+static BaselineShift parseBaselineShift(std::string_view input)
 {
     if(input.compare("baseline") == 0)
         return BaselineShift::Type::Baseline;
@@ -167,7 +167,7 @@ static float parseFontSize(std::string_view input, const SVGLayoutState* state)
 }
 
 template<typename Enum, unsigned int N>
-static Enum parseEnumValue(const std::string_view& input, const SVGEnumerationEntry<Enum>(&entries)[N], Enum defaultValue)
+static Enum parseEnumValue(std::string_view input, const SVGEnumerationEntry<Enum>(&entries)[N], Enum defaultValue)
 {
     for(const auto& entry : entries) {
         if(input == entry.second) {
@@ -178,7 +178,7 @@ static Enum parseEnumValue(const std::string_view& input, const SVGEnumerationEn
     return defaultValue;
 }
 
-static Display parseDisplay(const std::string_view& input)
+static Display parseDisplay(std::string_view input)
 {
     static const SVGEnumerationEntry<Display> entries[] = {
         {Display::Inline, "inline"},
@@ -188,7 +188,7 @@ static Display parseDisplay(const std::string_view& input)
     return parseEnumValue(input, entries, Display::Inline);
 }
 
-static Visibility parseVisibility(const std::string_view& input)
+static Visibility parseVisibility(std::string_view input)
 {
     static const SVGEnumerationEntry<Visibility> entries[] = {
         {Visibility::Visible, "visible"},
@@ -199,7 +199,7 @@ static Visibility parseVisibility(const std::string_view& input)
     return parseEnumValue(input, entries, Visibility::Visible);
 }
 
-static Overflow parseOverflow(const std::string_view& input)
+static Overflow parseOverflow(std::string_view input)
 {
     static const SVGEnumerationEntry<Overflow> entries[] = {
         {Overflow::Visible, "visible"},
@@ -209,7 +209,7 @@ static Overflow parseOverflow(const std::string_view& input)
     return parseEnumValue(input, entries, Overflow::Visible);
 }
 
-static PointerEvents parsePointerEvents(const std::string_view& input)
+static PointerEvents parsePointerEvents(std::string_view input)
 {
     static const SVGEnumerationEntry<PointerEvents> entries[] = {
         {PointerEvents::None,"none"},
@@ -228,7 +228,7 @@ static PointerEvents parsePointerEvents(const std::string_view& input)
     return parseEnumValue(input, entries, PointerEvents::Auto);
 }
 
-static FontWeight parseFontWeight(const std::string_view& input)
+static FontWeight parseFontWeight(std::string_view input)
 {
     static const SVGEnumerationEntry<FontWeight> entries[] = {
         {FontWeight::Normal, "normal"},
@@ -249,7 +249,7 @@ static FontWeight parseFontWeight(const std::string_view& input)
     return parseEnumValue(input, entries, FontWeight::Normal);
 }
 
-static FontStyle parseFontStyle(const std::string_view& input)
+static FontStyle parseFontStyle(std::string_view input)
 {
     static const SVGEnumerationEntry<FontStyle> entries[] = {
         {FontStyle::Normal, "normal"},
@@ -260,7 +260,7 @@ static FontStyle parseFontStyle(const std::string_view& input)
     return parseEnumValue(input, entries, FontStyle::Normal);
 }
 
-static AlignmentBaseline parseAlignmentBaseline(const std::string_view& input)
+static AlignmentBaseline parseAlignmentBaseline(std::string_view input)
 {
     static const SVGEnumerationEntry<AlignmentBaseline> entries[] = {
         {AlignmentBaseline::Auto, "auto"},
@@ -280,7 +280,7 @@ static AlignmentBaseline parseAlignmentBaseline(const std::string_view& input)
     return parseEnumValue(input, entries, AlignmentBaseline::Auto);
 }
 
-static DominantBaseline parseDominantBaseline(const std::string_view& input)
+static DominantBaseline parseDominantBaseline(std::string_view input)
 {
     static const SVGEnumerationEntry<DominantBaseline> entries[] = {
         {DominantBaseline::Auto, "auto"},
@@ -300,7 +300,7 @@ static DominantBaseline parseDominantBaseline(const std::string_view& input)
     return parseEnumValue(input, entries, DominantBaseline::Auto);
 }
 
-static Direction parseDirection(const std::string_view& input)
+static Direction parseDirection(std::string_view input)
 {
     static const SVGEnumerationEntry<Direction> entries[] = {
         {Direction::Ltr, "ltr"},
@@ -310,7 +310,7 @@ static Direction parseDirection(const std::string_view& input)
     return parseEnumValue(input, entries, Direction::Ltr);
 }
 
-static WritingMode parseWritingMode(const std::string_view& input)
+static WritingMode parseWritingMode(std::string_view input)
 {
     static const SVGEnumerationEntry<WritingMode> entries[] = {
         {WritingMode::Horizontal, "horizontal-tb"},
@@ -327,7 +327,7 @@ static WritingMode parseWritingMode(const std::string_view& input)
     return parseEnumValue(input, entries, WritingMode::Horizontal);
 }
 
-static TextOrientation parseTextOrientation(const std::string_view& input)
+static TextOrientation parseTextOrientation(std::string_view input)
 {
     static const SVGEnumerationEntry<TextOrientation> entries[] = {
         {TextOrientation::Mixed, "mixed"},
@@ -337,7 +337,7 @@ static TextOrientation parseTextOrientation(const std::string_view& input)
     return parseEnumValue(input, entries, TextOrientation::Mixed);
 }
 
-static TextAnchor parseTextAnchor(const std::string_view& input)
+static TextAnchor parseTextAnchor(std::string_view input)
 {
     static const SVGEnumerationEntry<TextAnchor> entries[] = {
         {TextAnchor::Start, "start"},
@@ -348,7 +348,7 @@ static TextAnchor parseTextAnchor(const std::string_view& input)
     return parseEnumValue(input, entries, TextAnchor::Start);
 }
 
-static WhiteSpace parseWhiteSpace(const std::string_view& input)
+static WhiteSpace parseWhiteSpace(std::string_view input)
 {
     static const SVGEnumerationEntry<WhiteSpace> entries[] = {
         {WhiteSpace::Default, "default"},
@@ -363,7 +363,7 @@ static WhiteSpace parseWhiteSpace(const std::string_view& input)
     return parseEnumValue(input, entries, WhiteSpace::Default);
 }
 
-static MaskType parseMaskType(const std::string_view& input)
+static MaskType parseMaskType(std::string_view input)
 {
     static const SVGEnumerationEntry<MaskType> entries[] = {
         {MaskType::Luminance, "luminance"},
@@ -373,7 +373,7 @@ static MaskType parseMaskType(const std::string_view& input)
     return parseEnumValue(input, entries, MaskType::Luminance);
 }
 
-static FillRule parseFillRule(const std::string_view& input)
+static FillRule parseFillRule(std::string_view input)
 {
     static const SVGEnumerationEntry<FillRule> entries[] = {
         {FillRule::NonZero, "nonzero"},
@@ -383,7 +383,7 @@ static FillRule parseFillRule(const std::string_view& input)
     return parseEnumValue(input, entries, FillRule::NonZero);
 }
 
-static LineCap parseLineCap(const std::string_view& input)
+static LineCap parseLineCap(std::string_view input)
 {
     static const SVGEnumerationEntry<LineCap> entries[] = {
         {LineCap::Butt, "butt"},
@@ -394,7 +394,7 @@ static LineCap parseLineCap(const std::string_view& input)
     return parseEnumValue(input, entries, LineCap::Butt);
 }
 
-static LineJoin parseLineJoin(const std::string_view& input)
+static LineJoin parseLineJoin(std::string_view input)
 {
     static const SVGEnumerationEntry<LineJoin> entries[] = {
         {LineJoin::Miter, "miter"},
diff --git a/source/svgparser.cpp b/source/svgparser.cpp
@@ -102,17 +102,17 @@ inline bool operator<(const RuleData& a, const RuleData& b) { return a.isLessTha
 
 using RuleDataList = std::vector<RuleData>;
 
-constexpr bool equals(const std::string_view& value, const std::string_view& subvalue)
+constexpr bool equals(std::string_view value, std::string_view subvalue)
 {
     return value.compare(subvalue) == 0;
 }
 
-constexpr bool contains(const std::string_view& value, const std::string_view& subvalue)
+constexpr bool contains(std::string_view value, std::string_view subvalue)
 {
     return value.find(subvalue) != std::string_view::npos;
 }
 
-constexpr bool includes(const std::string_view& value, const std::string_view& subvalue)
+constexpr bool includes(std::string_view value, std::string_view subvalue)
 {
     if(subvalue.empty() || subvalue.length() > value.length())
         return false;
@@ -130,21 +130,21 @@ constexpr bool includes(const std::string_view& value, const std::string_view& s
     return false;
 }
 
-constexpr bool startswith(const std::string_view& value, const std::string_view& subvalue)
+constexpr bool startswith(std::string_view value, std::string_view subvalue)
 {
     if(subvalue.empty() || subvalue.length() > value.length())
         return false;
     return subvalue == value.substr(0, subvalue.size());
 }
 
-constexpr bool endswith(const std::string_view& value, const std::string_view& subvalue)
+constexpr bool endswith(std::string_view value, std::string_view subvalue)
 {
     if(subvalue.empty() || subvalue.length() > value.length())
         return false;
     return subvalue == value.substr(value.size() - subvalue.size(), subvalue.size());
 }
 
-constexpr bool dashequals(const std::string_view& value, const std::string_view& subvalue)
+constexpr bool dashequals(std::string_view value, std::string_view subvalue)
 {
     if(startswith(value, subvalue))
         return (value.length() == subvalue.length() || value.at(subvalue.length()) == '-');
@@ -717,7 +717,7 @@ bool Document::parse(const char* data, size_t length)
     std::string styleSheet;
     SVGElement* currentElement = nullptr;
     int ignoring = 0;
-    auto handleText = [&](const std::string_view& text, bool in_cdata) {
+    auto handleText = [&](std::string_view text, bool in_cdata) {
         if(text.empty() || currentElement == nullptr || ignoring > 0)
             return;
         if(currentElement->id() != ElementID::Text && currentElement->id() != ElementID::Tspan && currentElement->id() != ElementID::Style) {
diff --git a/source/svgparserutils.h b/source/svgparserutils.h
@@ -78,7 +78,7 @@ constexpr bool skipDelimiter(std::string_view& input, char delimiter)
     return false;
 }
 
-constexpr bool skipString(std::string_view& input, const std::string_view& value)
+constexpr bool skipString(std::string_view& input, std::string_view value)
 {
     if(input.size() >= value.size() && value == input.substr(0, value.size())) {
         input.remove_prefix(value.size());
diff --git a/source/svgproperty.cpp b/source/svgproperty.cpp
@@ -6,7 +6,7 @@
 
 namespace lunasvg {
 
-PropertyID propertyid(const std::string_view& name)
+PropertyID propertyid(std::string_view name)
 {
     static const struct {
         std::string_view name;
@@ -67,7 +67,7 @@ PropertyID propertyid(const std::string_view& name)
     return it->value;
 }
 
-PropertyID csspropertyid(const std::string_view& name)
+PropertyID csspropertyid(std::string_view name)
 {
     static const struct {
         std::string_view name;
diff --git a/source/svgproperty.h b/source/svgproperty.h
@@ -96,8 +96,8 @@ enum class PropertyID : uint8_t {
     Y2
 };
 
-PropertyID propertyid(const std::string_view& name);
-PropertyID csspropertyid(const std::string_view& name);
+PropertyID propertyid(std::string_view name);
+PropertyID csspropertyid(std::string_view name);
 
 class SVGElement;
 

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`	`namespace lunasvg {`
`12`	`12`
`13`		`-ElementID elementid(const std::string_view& name)`
	`13`	`+ElementID elementid(std::string_view name)`
`14`	`14`	`{`
`15`	`15`	`static const struct {`
`16`	`16`	`std::string_view name;`
`@@ -129,23 +129,23 @@ SVGElement::SVGElement(Document* document, ElementID id)`
`129`	`129`	`{`
`130`	`130`	`}`
`131`	`131`
`132`		`-bool SVGElement::hasAttribute(const std::string_view& name) const`
	`132`	`+bool SVGElement::hasAttribute(std::string_view name) const`
`133`	`133`	`{`
`134`	`134`	`auto id = propertyid(name);`
`135`	`135`	`if(id == PropertyID::Unknown)`
`136`	`136`	`return false;`
`137`	`137`	`return hasAttribute(id);`
`138`	`138`	`}`
`139`	`139`
`140`		`-const std::string& SVGElement::getAttribute(const std::string_view& name) const`
	`140`	`+const std::string& SVGElement::getAttribute(std::string_view name) const`
`141`	`141`	`{`
`142`	`142`	`auto id = propertyid(name);`
`143`	`143`	`if(id == PropertyID::Unknown)`
`144`	`144`	`return emptyString;`
`145`	`145`	`return getAttribute(id);`
`146`	`146`	`}`
`147`	`147`
`148`		`-bool SVGElement::setAttribute(const std::string_view& name, const std::string& value)`
	`148`	`+bool SVGElement::setAttribute(std::string_view name, const std::string& value)`
`149`	`149`	`{`
`150`	`150`	`auto id = propertyid(name);`
`151`	`151`	`if(id == PropertyID::Unknown)`
`@@ -326,31 +326,31 @@ Rect SVGElement::paintBoundingBox() const`
`326`	`326`	`return m_paintBoundingBox;`
`327`	`327`	`}`
`328`	`328`
`329`		`-SVGMarkerElement* SVGElement::getMarker(const std::string_view& id) const`
	`329`	`+SVGMarkerElement* SVGElement::getMarker(std::string_view id) const`
`330`	`330`	`{`
`331`	`331`	`auto element = rootElement()->getElementById(id);`
`332`	`332`	`if(element && element->id() == ElementID::Marker)`
`333`	`333`	`return static_cast<SVGMarkerElement*>(element);`
`334`	`334`	`return nullptr;`
`335`	`335`	`}`
`336`	`336`
`337`		`-SVGClipPathElement* SVGElement::getClipper(const std::string_view& id) const`
	`337`	`+SVGClipPathElement* SVGElement::getClipper(std::string_view id) const`
`338`	`338`	`{`
`339`	`339`	`auto element = rootElement()->getElementById(id);`
`340`	`340`	`if(element && element->id() == ElementID::ClipPath)`
`341`	`341`	`return static_cast<SVGClipPathElement*>(element);`
`342`	`342`	`return nullptr;`
`343`	`343`	`}`
`344`	`344`
`345`		`-SVGMaskElement* SVGElement::getMasker(const std::string_view& id) const`
	`345`	`+SVGMaskElement* SVGElement::getMasker(std::string_view id) const`
`346`	`346`	`{`
`347`	`347`	`auto element = rootElement()->getElementById(id);`
`348`	`348`	`if(element && element->id() == ElementID::Mask)`
`349`	`349`	`return static_cast<SVGMaskElement*>(element);`
`350`	`350`	`return nullptr;`
`351`	`351`	`}`
`352`	`352`
`353`		`-SVGPaintElement* SVGElement::getPainter(const std::string_view& id) const`
	`353`	`+SVGPaintElement* SVGElement::getPainter(std::string_view id) const`
`354`	`354`	`{`
`355`	`355`	`auto element = rootElement()->getElementById(id);`
`356`	`356`	`if(element && element->isPaintElement())`
`@@ -683,7 +683,7 @@ SVGRootElement* SVGRootElement::layoutIfNeeded()`
`683`	`683`	`return this;`
`684`	`684`	`}`
`685`	`685`
`686`		`-SVGElement* SVGRootElement::getElementById(const std::string_view& id) const`
	`686`	`+SVGElement* SVGRootElement::getElementById(std::string_view id) const`
`687`	`687`	`{`
`688`	`688`	`auto it = m_idCache.find(id);`
`689`	`689`	`if(it == m_idCache.end())`
Original file line number	Diff line number	Diff line change
`@@ -110,15 +110,15 @@ static float parseNumberOrPercentage(std::string_view input, bool allowPercentag`
`110`	`110`	`return value;`
`111`	`111`	`}`
`112`	`112`
`113`		`-static Length parseLength(const std::string_view& input, LengthNegativeMode mode, const Length& defaultValue)`
	`113`	`+static Length parseLength(std::string_view input, LengthNegativeMode mode, const Length& defaultValue)`
`114`	`114`	`{`
`115`	`115`	`Length value;`
`116`	`116`	`if(!value.parse(input, mode))`
`117`	`117`	`value = defaultValue;`
`118`	`118`	`return value;`
`119`	`119`	`}`
`120`	`120`
`121`		`-static BaselineShift parseBaselineShift(const std::string_view& input)`
	`121`	`+static BaselineShift parseBaselineShift(std::string_view input)`
`122`	`122`	`{`
`123`	`123`	`if(input.compare("baseline") == 0)`
`124`	`124`	`return BaselineShift::Type::Baseline;`
`@@ -167,7 +167,7 @@ static float parseFontSize(std::string_view input, const SVGLayoutState* state)`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`template<typename Enum, unsigned int N>`
`170`		`-static Enum parseEnumValue(const std::string_view& input, const SVGEnumerationEntry<Enum>(&entries)[N], Enum defaultValue)`
	`170`	`+static Enum parseEnumValue(std::string_view input, const SVGEnumerationEntry<Enum>(&entries)[N], Enum defaultValue)`
`171`	`171`	`{`
`172`	`172`	`for(const auto& entry : entries) {`
`173`	`173`	`if(input == entry.second) {`
`@@ -178,7 +178,7 @@ static Enum parseEnumValue(const std::string_view& input, const SVGEnumerationEn`
`178`	`178`	`return defaultValue;`
`179`	`179`	`}`
`180`	`180`
`181`		`-static Display parseDisplay(const std::string_view& input)`
	`181`	`+static Display parseDisplay(std::string_view input)`
`182`	`182`	`{`
`183`	`183`	`static const SVGEnumerationEntry<Display> entries[] = {`
`184`	`184`	`{Display::Inline, "inline"},`
`@@ -188,7 +188,7 @@ static Display parseDisplay(const std::string_view& input)`
`188`	`188`	`return parseEnumValue(input, entries, Display::Inline);`
`189`	`189`	`}`
`190`	`190`
`191`		`-static Visibility parseVisibility(const std::string_view& input)`
	`191`	`+static Visibility parseVisibility(std::string_view input)`
`192`	`192`	`{`
`193`	`193`	`static const SVGEnumerationEntry<Visibility> entries[] = {`
`194`	`194`	`{Visibility::Visible, "visible"},`
`@@ -199,7 +199,7 @@ static Visibility parseVisibility(const std::string_view& input)`
`199`	`199`	`return parseEnumValue(input, entries, Visibility::Visible);`
`200`	`200`	`}`
`201`	`201`
`202`		`-static Overflow parseOverflow(const std::string_view& input)`
	`202`	`+static Overflow parseOverflow(std::string_view input)`
`203`	`203`	`{`
`204`	`204`	`static const SVGEnumerationEntry<Overflow> entries[] = {`
`205`	`205`	`{Overflow::Visible, "visible"},`
`@@ -209,7 +209,7 @@ static Overflow parseOverflow(const std::string_view& input)`
`209`	`209`	`return parseEnumValue(input, entries, Overflow::Visible);`
`210`	`210`	`}`
`211`	`211`
`212`		`-static PointerEvents parsePointerEvents(const std::string_view& input)`
	`212`	`+static PointerEvents parsePointerEvents(std::string_view input)`
`213`	`213`	`{`
`214`	`214`	`static const SVGEnumerationEntry<PointerEvents> entries[] = {`
`215`	`215`	`{PointerEvents::None,"none"},`
`@@ -228,7 +228,7 @@ static PointerEvents parsePointerEvents(const std::string_view& input)`
`228`	`228`	`return parseEnumValue(input, entries, PointerEvents::Auto);`
`229`	`229`	`}`
`230`	`230`
`231`		`-static FontWeight parseFontWeight(const std::string_view& input)`
	`231`	`+static FontWeight parseFontWeight(std::string_view input)`
`232`	`232`	`{`
`233`	`233`	`static const SVGEnumerationEntry<FontWeight> entries[] = {`
`234`	`234`	`{FontWeight::Normal, "normal"},`
`@@ -249,7 +249,7 @@ static FontWeight parseFontWeight(const std::string_view& input)`
`249`	`249`	`return parseEnumValue(input, entries, FontWeight::Normal);`
`250`	`250`	`}`
`251`	`251`
`252`		`-static FontStyle parseFontStyle(const std::string_view& input)`
	`252`	`+static FontStyle parseFontStyle(std::string_view input)`
`253`	`253`	`{`
`254`	`254`	`static const SVGEnumerationEntry<FontStyle> entries[] = {`
`255`	`255`	`{FontStyle::Normal, "normal"},`
`@@ -260,7 +260,7 @@ static FontStyle parseFontStyle(const std::string_view& input)`
`260`	`260`	`return parseEnumValue(input, entries, FontStyle::Normal);`
`261`	`261`	`}`
`262`	`262`
`263`		`-static AlignmentBaseline parseAlignmentBaseline(const std::string_view& input)`
	`263`	`+static AlignmentBaseline parseAlignmentBaseline(std::string_view input)`
`264`	`264`	`{`
`265`	`265`	`static const SVGEnumerationEntry<AlignmentBaseline> entries[] = {`
`266`	`266`	`{AlignmentBaseline::Auto, "auto"},`
`@@ -280,7 +280,7 @@ static AlignmentBaseline parseAlignmentBaseline(const std::string_view& input)`
`280`	`280`	`return parseEnumValue(input, entries, AlignmentBaseline::Auto);`
`281`	`281`	`}`
`282`	`282`
`283`		`-static DominantBaseline parseDominantBaseline(const std::string_view& input)`
	`283`	`+static DominantBaseline parseDominantBaseline(std::string_view input)`
`284`	`284`	`{`
`285`	`285`	`static const SVGEnumerationEntry<DominantBaseline> entries[] = {`
`286`	`286`	`{DominantBaseline::Auto, "auto"},`
`@@ -300,7 +300,7 @@ static DominantBaseline parseDominantBaseline(const std::string_view& input)`
`300`	`300`	`return parseEnumValue(input, entries, DominantBaseline::Auto);`
`301`	`301`	`}`
`302`	`302`
`303`		`-static Direction parseDirection(const std::string_view& input)`
	`303`	`+static Direction parseDirection(std::string_view input)`
`304`	`304`	`{`
`305`	`305`	`static const SVGEnumerationEntry<Direction> entries[] = {`
`306`	`306`	`{Direction::Ltr, "ltr"},`
`@@ -310,7 +310,7 @@ static Direction parseDirection(const std::string_view& input)`
`310`	`310`	`return parseEnumValue(input, entries, Direction::Ltr);`
`311`	`311`	`}`
`312`	`312`
`313`		`-static WritingMode parseWritingMode(const std::string_view& input)`
	`313`	`+static WritingMode parseWritingMode(std::string_view input)`
`314`	`314`	`{`
`315`	`315`	`static const SVGEnumerationEntry<WritingMode> entries[] = {`
`316`	`316`	`{WritingMode::Horizontal, "horizontal-tb"},`
`@@ -327,7 +327,7 @@ static WritingMode parseWritingMode(const std::string_view& input)`
`327`	`327`	`return parseEnumValue(input, entries, WritingMode::Horizontal);`
`328`	`328`	`}`
`329`	`329`
`330`		`-static TextOrientation parseTextOrientation(const std::string_view& input)`
	`330`	`+static TextOrientation parseTextOrientation(std::string_view input)`
`331`	`331`	`{`
`332`	`332`	`static const SVGEnumerationEntry<TextOrientation> entries[] = {`
`333`	`333`	`{TextOrientation::Mixed, "mixed"},`
`@@ -337,7 +337,7 @@ static TextOrientation parseTextOrientation(const std::string_view& input)`
`337`	`337`	`return parseEnumValue(input, entries, TextOrientation::Mixed);`
`338`	`338`	`}`
`339`	`339`
`340`		`-static TextAnchor parseTextAnchor(const std::string_view& input)`
	`340`	`+static TextAnchor parseTextAnchor(std::string_view input)`
`341`	`341`	`{`
`342`	`342`	`static const SVGEnumerationEntry<TextAnchor> entries[] = {`
`343`	`343`	`{TextAnchor::Start, "start"},`
`@@ -348,7 +348,7 @@ static TextAnchor parseTextAnchor(const std::string_view& input)`
`348`	`348`	`return parseEnumValue(input, entries, TextAnchor::Start);`
`349`	`349`	`}`
`350`	`350`
`351`		`-static WhiteSpace parseWhiteSpace(const std::string_view& input)`
	`351`	`+static WhiteSpace parseWhiteSpace(std::string_view input)`
`352`	`352`	`{`
`353`	`353`	`static const SVGEnumerationEntry<WhiteSpace> entries[] = {`
`354`	`354`	`{WhiteSpace::Default, "default"},`
`@@ -363,7 +363,7 @@ static WhiteSpace parseWhiteSpace(const std::string_view& input)`
`363`	`363`	`return parseEnumValue(input, entries, WhiteSpace::Default);`
`364`	`364`	`}`
`365`	`365`
`366`		`-static MaskType parseMaskType(const std::string_view& input)`
	`366`	`+static MaskType parseMaskType(std::string_view input)`
`367`	`367`	`{`
`368`	`368`	`static const SVGEnumerationEntry<MaskType> entries[] = {`
`369`	`369`	`{MaskType::Luminance, "luminance"},`
`@@ -373,7 +373,7 @@ static MaskType parseMaskType(const std::string_view& input)`
`373`	`373`	`return parseEnumValue(input, entries, MaskType::Luminance);`
`374`	`374`	`}`
`375`	`375`
`376`		`-static FillRule parseFillRule(const std::string_view& input)`
	`376`	`+static FillRule parseFillRule(std::string_view input)`
`377`	`377`	`{`
`378`	`378`	`static const SVGEnumerationEntry<FillRule> entries[] = {`
`379`	`379`	`{FillRule::NonZero, "nonzero"},`
`@@ -383,7 +383,7 @@ static FillRule parseFillRule(const std::string_view& input)`
`383`	`383`	`return parseEnumValue(input, entries, FillRule::NonZero);`
`384`	`384`	`}`
`385`	`385`
`386`		`-static LineCap parseLineCap(const std::string_view& input)`
	`386`	`+static LineCap parseLineCap(std::string_view input)`
`387`	`387`	`{`
`388`	`388`	`static const SVGEnumerationEntry<LineCap> entries[] = {`
`389`	`389`	`{LineCap::Butt, "butt"},`
`@@ -394,7 +394,7 @@ static LineCap parseLineCap(const std::string_view& input)`
`394`	`394`	`return parseEnumValue(input, entries, LineCap::Butt);`
`395`	`395`	`}`
`396`	`396`
`397`		`-static LineJoin parseLineJoin(const std::string_view& input)`
	`397`	`+static LineJoin parseLineJoin(std::string_view input)`
`398`	`398`	`{`
`399`	`399`	`static const SVGEnumerationEntry<LineJoin> entries[] = {`
`400`	`400`	`{LineJoin::Miter, "miter"},`
Original file line number	Diff line number	Diff line change
`@@ -102,17 +102,17 @@ inline bool operator<(const RuleData& a, const RuleData& b) { return a.isLessTha`
`102`	`102`
`103`	`103`	`using RuleDataList = std::vector<RuleData>;`
`104`	`104`
`105`		`-constexpr bool equals(const std::string_view& value, const std::string_view& subvalue)`
	`105`	`+constexpr bool equals(std::string_view value, std::string_view subvalue)`
`106`	`106`	`{`
`107`	`107`	`return value.compare(subvalue) == 0;`
`108`	`108`	`}`
`109`	`109`
`110`		`-constexpr bool contains(const std::string_view& value, const std::string_view& subvalue)`
	`110`	`+constexpr bool contains(std::string_view value, std::string_view subvalue)`
`111`	`111`	`{`
`112`	`112`	`return value.find(subvalue) != std::string_view::npos;`
`113`	`113`	`}`
`114`	`114`
`115`		`-constexpr bool includes(const std::string_view& value, const std::string_view& subvalue)`
	`115`	`+constexpr bool includes(std::string_view value, std::string_view subvalue)`
`116`	`116`	`{`
`117`	`117`	`if(subvalue.empty() \|\| subvalue.length() > value.length())`
`118`	`118`	`return false;`
`@@ -130,21 +130,21 @@ constexpr bool includes(const std::string_view& value, const std::string_view& s`
`130`	`130`	`return false;`
`131`	`131`	`}`
`132`	`132`
`133`		`-constexpr bool startswith(const std::string_view& value, const std::string_view& subvalue)`
	`133`	`+constexpr bool startswith(std::string_view value, std::string_view subvalue)`
`134`	`134`	`{`
`135`	`135`	`if(subvalue.empty() \|\| subvalue.length() > value.length())`
`136`	`136`	`return false;`
`137`	`137`	`return subvalue == value.substr(0, subvalue.size());`
`138`	`138`	`}`
`139`	`139`
`140`		`-constexpr bool endswith(const std::string_view& value, const std::string_view& subvalue)`
	`140`	`+constexpr bool endswith(std::string_view value, std::string_view subvalue)`
`141`	`141`	`{`
`142`	`142`	`if(subvalue.empty() \|\| subvalue.length() > value.length())`
`143`	`143`	`return false;`
`144`	`144`	`return subvalue == value.substr(value.size() - subvalue.size(), subvalue.size());`
`145`	`145`	`}`
`146`	`146`
`147`		`-constexpr bool dashequals(const std::string_view& value, const std::string_view& subvalue)`
	`147`	`+constexpr bool dashequals(std::string_view value, std::string_view subvalue)`
`148`	`148`	`{`
`149`	`149`	`if(startswith(value, subvalue))`
`150`	`150`	`return (value.length() == subvalue.length() \|\| value.at(subvalue.length()) == '-');`
`@@ -717,7 +717,7 @@ bool Document::parse(const char* data, size_t length)`
`717`	`717`	`std::string styleSheet;`
`718`	`718`	`SVGElement* currentElement = nullptr;`
`719`	`719`	`int ignoring = 0;`
`720`		`- auto handleText = [&](const std::string_view& text, bool in_cdata) {`
	`720`	`+ auto handleText = [&](std::string_view text, bool in_cdata) {`
`721`	`721`	`if(text.empty() \|\| currentElement == nullptr \|\| ignoring > 0)`
`722`	`722`	`return;`
`723`	`723`	`if(currentElement->id() != ElementID::Text && currentElement->id() != ElementID::Tspan && currentElement->id() != ElementID::Style) {`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ constexpr bool skipDelimiter(std::string_view& input, char delimiter)`
`78`	`78`	`return false;`
`79`	`79`	`}`
`80`	`80`
`81`		`-constexpr bool skipString(std::string_view& input, const std::string_view& value)`
	`81`	`+constexpr bool skipString(std::string_view& input, std::string_view value)`
`82`	`82`	`{`
`83`	`83`	`if(input.size() >= value.size() && value == input.substr(0, value.size())) {`
`84`	`84`	`input.remove_prefix(value.size());`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`namespace lunasvg {`
`8`	`8`
`9`		`-PropertyID propertyid(const std::string_view& name)`
	`9`	`+PropertyID propertyid(std::string_view name)`
`10`	`10`	`{`
`11`	`11`	`static const struct {`
`12`	`12`	`std::string_view name;`
`@@ -67,7 +67,7 @@ PropertyID propertyid(const std::string_view& name)`
`67`	`67`	`return it->value;`
`68`	`68`	`}`
`69`	`69`
`70`		`-PropertyID csspropertyid(const std::string_view& name)`
	`70`	`+PropertyID csspropertyid(std::string_view name)`
`71`	`71`	`{`
`72`	`72`	`static const struct {`
`73`	`73`	`std::string_view name;`