diff --git a/include/docpp.hpp b/include/docpp.hpp
index 0e06888..3be832e 100644
--- a/include/docpp.hpp
+++ b/include/docpp.hpp
@@ -17,10 +17,30 @@
  * @brief A namespace to represent HTML elements and documents
  */
 namespace docpp {
+#ifndef DOCPP_STRING_TYPE
+    using string_type = std::string;
+#else
+    using string_type = DOCPP_STRING_TYPE;
+#endif
+#ifndef DOCPP_SIZE_TYPE
+    using size_type = std::size_t;
+#else
+    using size_type = DOCPP_SIZE_TYPE;
+#endif
+#ifndef DOCPP_EXCEPTION_CLASS
+    using exception_type = std::exception;
+#else
+    using exception_type = DOCPP_EXCEPTION_CLASS;
+#endif
+#ifndef DOCPP_INTEGER_TYPE
+    using integer_type = int;
+#else
+    using integer_type = DOCPP_INTEGER_TYPE;
+#endif
     /**
      * @brief A class to represent an exception when an index is out of range
      */
-    class out_of_range : public std::exception {
+    class out_of_range : public exception_type {
         private:
             const char* message{"Out of range"};
         public:
@@ -34,7 +54,7 @@ namespace docpp {
     /**
      * @brief A class to represent an exception when an argument is invalid
      */
-    class invalid_argument : public std::exception {
+    class invalid_argument : public exception_type {
         private:
             const char* message{"Invalid argument"};
         public:
@@ -223,32 +243,30 @@ namespace docpp {
 
         /**
          * @brief Get a map of tags to strings and types.
-         * @return std::unordered_map<docpp::HTML::Tag, std::pair<std::string, docpp::HTML::Type>> The map of tags to strings and types.
+         * @return std::unordered_map<docpp::HTML::Tag, std::pair<string_type, docpp::HTML::Type>> The map of tags to strings and types.
          */
-        std::unordered_map<docpp::HTML::Tag, std::pair<std::string, docpp::HTML::Type>> get_tag_map();
+        std::unordered_map<docpp::HTML::Tag, std::pair<string_type, docpp::HTML::Type>> get_tag_map();
         /**
          * @brief Resolve a tag to a string and type.
          * @param tag The tag to resolve
-         * @return std::pair<std::string, Type> The resolved tag
+         * @return std::pair<string_type, Type> The resolved tag
          */
-        std::pair<std::string, Type> resolve_tag(Tag tag);
+        std::pair<string_type, Type> resolve_tag(Tag tag);
         /**
          * @brief Resolve a string tag to a Tag enum.
          * @param tag The tag to resolve
          * @return Tag The resolved tag
          */
-        Tag resolve_tag(const std::string& tag);
+        Tag resolve_tag(const string_type& tag);
 
         /**
          * @brief A class to represent an HTML property
          */
         class Property {
             private:
-                std::pair<std::string, std::string> property{};
+                std::pair<string_type, string_type> property{};
             protected:
             public:
-                using size_type = std::size_t;
-
                 /**
                  * @brief The npos value
                  */
@@ -259,7 +277,7 @@ namespace docpp {
                  * @param key The key of the property
                  * @param value The value of the property
                  */
-                Property(const std::string& key, const std::string& value) : property(std::make_pair(key, value)) {};
+                Property(const string_type& key, const string_type& value) : property(std::make_pair(key, value)) {};
                 /**
                  * @brief Construct a new Property object
                  * @param property The property to set
@@ -276,15 +294,15 @@ namespace docpp {
 
                 /**
                  * @brief Get the key of the property
-                 * @return std::string The key of the property
+                 * @return string_type The key of the property
                  */
-                [[nodiscard]] std::string get_key() const;
+                [[nodiscard]] string_type get_key() const;
                 /**
                  * @brief Get the key of the property in a specific type
                  * @return T The key of the property
                  */
                 template <typename T> T get_key() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                      return this->property.first;
                     }
 
@@ -292,30 +310,30 @@ namespace docpp {
                 };
                 /**
                  * @brief Get the value of the property
-                 * @return std::string The value of the property
+                 * @return string_type The value of the property
                  */
-                [[nodiscard]] std::string get_value() const;
+                [[nodiscard]] string_type get_value() const;
                 /**
                  * @brief Get the value of the property in a specific type
                  * @return T The value of the property
                  */
                 template <typename T> T get_value() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->property.second;
                     }
                     return T(this->property.second);
                 }
                 /**
                  * @brief Get the property.
-                 * @return std::pair<std::string, std::string> The value of the property
+                 * @return std::pair<string_type, string_type> The value of the property
                  */
-                [[nodiscard]] std::pair<std::string, std::string> get() const;
+                [[nodiscard]] std::pair<string_type, string_type> get() const;
                 /**
                  * @brief Get the property in a specific type.
                  * @return std::pair<T, T> The value of the property
                  */
                 template <typename T> std::pair<T, T> get() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->property;
                     }
 
@@ -325,17 +343,17 @@ namespace docpp {
                  * @brief Set the key of the property.
                  * @param key The key.
                  */
-                void set_key(const std::string& key);
+                void set_key(const string_type& key);
                 /**
                  * @brief Set the value of the property.
                  * @param value The value.
                  */
-                void set_value(const std::string& value);
+                void set_value(const string_type& value);
                 /**
                  * @brief Set the property
                  * @param property The property.
                  */
-                void set(const std::pair<std::string, std::string>& property);
+                void set(const std::pair<string_type, string_type>& property);
                 /**
                  * @brief Clear the property
                  */
@@ -360,7 +378,6 @@ namespace docpp {
                 std::vector<Property> properties{};
             protected:
             public:
-                using size_type = std::size_t;
                 using iterator = std::vector<Property>::iterator;
                 using const_iterator = std::vector<Property>::const_iterator;
                 using reverse_iterator = std::vector<Property>::reverse_iterator;
@@ -460,7 +477,7 @@ namespace docpp {
                  * @param str The property to find
                  * @return size_type The index of the property
                  */
-                [[nodiscard]] size_type find(const std::string& str) const;
+                [[nodiscard]] size_type find(const string_type& str) const;
                 /**
                  * @brief Swap two properties in the element
                  * @param index1 The index of the first property
@@ -548,13 +565,12 @@ namespace docpp {
          */
         class Element {
             private:
-                std::string tag{};
+                string_type tag{};
                 Properties properties{};
-                std::string data{};
+                string_type data{};
                 Type type{Type::Non_Self_Closing};
             protected:
             public:
-                using size_type = std::size_t;
                 /**
                  * @brief The npos value
                  */
@@ -567,14 +583,14 @@ namespace docpp {
                  * @param data The data of the element
                  * @param type The close tag type.
                  */
-                explicit Element(std::string tag, const Properties& properties = {}, std::string data = {}, const Type& type = Type::Non_Self_Closing) : tag(std::move(tag)), properties(properties), data(std::move(data)), type(type) {};
+                explicit Element(string_type tag, const Properties& properties = {}, string_type data = {}, const Type& type = Type::Non_Self_Closing) : tag(std::move(tag)), properties(properties), data(std::move(data)), type(type) {};
                 /**
                  * @brief Construct a new Element object
                  * @param tag The tag of the element
                  * @param properties The properties of the element
                  * @param data The data of the element
                  */
-                explicit Element(const Tag tag, const Properties& properties = {}, std::string data = {}) : tag(resolve_tag(tag).first), properties(properties), data(std::move(data)), type(resolve_tag(tag).second) {};
+                explicit Element(const Tag tag, const Properties& properties = {}, string_type data = {}) : tag(resolve_tag(tag).first), properties(properties), data(std::move(data)), type(resolve_tag(tag).second) {};
                 /**
                  * @brief Construct a new Element object
                  * @param element The element to set
@@ -595,19 +611,19 @@ namespace docpp {
                  * @param data The data of the element
                  * @param type The close tag type.
                  */
-                void set(const std::string& tag, const Properties& properties = {}, const std::string& data = {}, Type type = Type::Non_Self_Closing);
+                void set(const string_type& tag, const Properties& properties = {}, const string_type& data = {}, Type type = Type::Non_Self_Closing);
                 /**
                  * @brief Set the tag, properties, and data of the element
                  * @param tag The tag of the element
                  * @param properties The properties of the element
                  * @param data The data of the element
                  */
-                void set(Tag tag, const Properties& properties = {}, const std::string& data = {});
+                void set(Tag tag, const Properties& properties = {}, const string_type& data = {});
                 /**
                  * @brief Set the tag of the element
                  * @param tag The tag of the element
                  */
-                void set_tag(const std::string& tag);
+                void set_tag(const string_type& tag);
                 /**
                  * @brief Set the tag of the element
                  * @param tag The tag of the element
@@ -617,7 +633,7 @@ namespace docpp {
                  * @brief Set the data of the element
                  * @param data The data of the element
                  */
-                void set_data(const std::string& data);
+                void set_data(const string_type& data);
                 /**
                  * @brief Set the properties of the element
                  * @param properties The properties of the element
@@ -631,15 +647,15 @@ namespace docpp {
 
                 /**
                  * @brief Get the element in the form of an HTML tag.
-                 * @return std::string The tag of the element
+                 * @return string_type The tag of the element
                  */
-                [[nodiscard]] std::string get(Formatting formatting = Formatting::None, int tabc = 0) const;
+                [[nodiscard]] string_type get(Formatting formatting = Formatting::None, integer_type tabc = 0) const;
                 /**
                  * @brief Get the element in the form of a specific type.
                  * @return T The element in the form of a specific type
                  */
-                template <typename T> T get(const Formatting formatting = Formatting::None, const int tabc = 0) const {
-                    if (std::is_same_v<T, std::string>) {
+                template <typename T> T get(const Formatting formatting = Formatting::None, const integer_type tabc = 0) const {
+                    if (std::is_same_v<T, string_type>) {
                         return this->get(formatting, tabc);
                     }
                     return T(this->get(formatting, tabc));
@@ -647,15 +663,15 @@ namespace docpp {
 
                 /**
                  * @brief Get the tag of the element
-                 * @return std::string The data of the element
+                 * @return string_type The data of the element
                  */
-                [[nodiscard]] std::string get_tag() const;
+                [[nodiscard]] string_type get_tag() const;
                 /**
                  * @brief Get the tag of the element in a specific type
                  * @return T The tag of the element
                  */
                 template <typename T> T get_tag() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->tag;
                     }
                     return T(this->tag);
@@ -663,15 +679,15 @@ namespace docpp {
 
                 /**
                  * @brief Get the data of the element
-                 * @return std::string The data of the element
+                 * @return string_type The data of the element
                  */
-                [[nodiscard]] std::string get_data() const;
+                [[nodiscard]] string_type get_data() const;
                 /**
                  * @brief Get the data of the element in a specific type
                  * @return T The data of the element
                  */
                 template <typename T> T get_data() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->data;
                     }
                     return T(this->data);
@@ -697,7 +713,7 @@ namespace docpp {
                 [[nodiscard]] bool empty() const;
 
                 Element& operator=(const Element& element);
-                Element& operator+=(const std::string& data);
+                Element& operator+=(const string_type& data);
                 bool operator==(const Element& element) const;
                 bool operator!=(const Element& element) const;
         };
@@ -708,8 +724,6 @@ namespace docpp {
         class Section {
             protected:
             public:
-                using size_type = std::size_t;
-
                 /**
                  * @brief A class to represent an iterator for the Section class
                  */
@@ -737,7 +751,6 @@ namespace docpp {
                         }
                 };
 
-
                 using element_map = std::map<size_type, Element>;
                 using iterator = sect_iterator<element_map::iterator>;
                 using const_iterator = sect_iterator<element_map::const_iterator>;
@@ -878,7 +891,7 @@ namespace docpp {
                  * @param str The element or section to find
                  * @return size_type The index of the element or section
                  */
-                [[nodiscard]] size_type find(const std::string& str) const;
+                [[nodiscard]] size_type find(const string_type& str) const;
                 /**
                  * @brief Insert an element into the section
                  * @param index The index to insert the element
@@ -950,7 +963,7 @@ namespace docpp {
                  * @param tag The tag of the section
                  * @param properties The properties of the section
                  */
-                explicit Section(std::string tag, const Properties& properties = {}) : tag(std::move(tag)), properties(properties) {};
+                explicit Section(string_type tag, const Properties& properties = {}) : tag(std::move(tag)), properties(properties) {};
                 /**
                  * @brief Construct a new Section object
                  * @param tag The tag of the section
@@ -963,7 +976,7 @@ namespace docpp {
                  * @param properties The properties of the section
                  * @param elements The elements of the section
                  */
-                Section(std::string tag, const Properties& properties, const std::vector<Element>& elements) : tag(std::move(tag)), properties(properties) {
+                Section(string_type tag, const Properties& properties, const std::vector<Element>& elements) : tag(std::move(tag)), properties(properties) {
                     for (const auto& element : elements) this->push_back(element);
                 };
                 /**
@@ -981,7 +994,7 @@ namespace docpp {
                  * @param properties The properties of the section
                  * @param sections The sections of the section
                  */
-                Section(std::string tag, const Properties& properties, const std::vector<Section>& sections) : tag(std::move(tag)), properties(properties) {
+                Section(string_type tag, const Properties& properties, const std::vector<Section>& sections) : tag(std::move(tag)), properties(properties) {
                     for (const auto& section : sections) this->push_back(section);
                 };
                 /**
@@ -1017,7 +1030,7 @@ namespace docpp {
                  * @param tag The tag to assign to the section
                  * @param properties The properties to assign to the section tag
                  */
-                void set(const std::string& tag, const Properties& properties = {});
+                void set(const string_type& tag, const Properties& properties = {});
                 /**
                  * @brief Set the tag, id, and classes of the section
                  * @param tag The tag of the section
@@ -1028,7 +1041,7 @@ namespace docpp {
                  * @brief Set the tag of the section
                  * @param tag The tag of the section
                  */
-                void set_tag(const std::string& tag);
+                void set_tag(const string_type& tag);
                 /**
                  * @brief Set the tag of the section
                  * @param tag The tag of the section
@@ -1070,15 +1083,15 @@ namespace docpp {
 
                 /**
                  * @brief Dump the entire section.
-                 * @return std::string The section
+                 * @return string_type The section
                  */
-                [[nodiscard]] std::string get(Formatting formatting = Formatting::None, int tabc = 0) const;
+                [[nodiscard]] string_type get(Formatting formatting = Formatting::None, integer_type tabc = 0) const;
                 /**
                  * @brief Get the element in the form of a specific type.
                  * @return T The element in the form of a specific type
                  */
-                template <typename T> T get(const Formatting formatting = Formatting::None, const int tabc = 0) const {
-                    if (std::is_same_v<T, std::string>) {
+                template <typename T> T get(const Formatting formatting = Formatting::None, const integer_type tabc = 0) const {
+                    if (std::is_same_v<T, string_type>) {
                         return this->get(formatting, tabc);
                     }
                     return T(this->get(formatting, tabc));
@@ -1086,15 +1099,15 @@ namespace docpp {
 
                 /**
                  * @brief Get the tag of the section
-                 * @return std::string The tag of the section
+                 * @return string_type The tag of the section
                  */
-                [[nodiscard]] std::string get_tag() const;
+                [[nodiscard]] string_type get_tag() const;
                 /**
                  * @brief Get the tag of the section in a specific type
                  * @return T The tag of the section
                  */
                 template <typename T> T get_tag() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->tag;
                     }
                     return T(this->tag);
@@ -1113,11 +1126,11 @@ namespace docpp {
                 bool operator!=(const Element& element) const;
                 bool operator!=(const Section& section) const;
                 Element operator[](const int& index) const;
-                std::unordered_map<std::string, Element> operator[](const std::string& tag) const;
-                std::unordered_map<std::string, Element> operator[](Tag tag) const;
+                std::unordered_map<string_type, Element> operator[](const string_type& tag) const;
+                std::unordered_map<string_type, Element> operator[](Tag tag) const;
             private:
                 size_type index{};
-                std::string tag{};
+                string_type tag{};
                 Properties properties{};
 
                 std::map<size_type, Element> elements{};
@@ -1130,11 +1143,9 @@ namespace docpp {
         class Document {
             private:
                 Section document{};
-                std::string doctype{"<!DOCTYPE html>"};
+                string_type doctype{"<!DOCTYPE html>"};
             protected:
             public:
-                using size_type = std::size_t;
-
                 /**
                  * @brief The npos value
                  */
@@ -1144,15 +1155,15 @@ namespace docpp {
                  * @brief Get the document
                  * @param formatting The formatting type to use
                  * @param tabc Number of tab indents to start with, when using Formatting::Pretty
-                 * @return std::string The document
+                 * @return string_type The document
                  */
-                [[nodiscard]] std::string get(Formatting formatting = Formatting::None, int tabc = 0) const;
+                [[nodiscard]] string_type get(Formatting formatting = Formatting::None, integer_type tabc = 0) const;
                 /**
                  * @brief Get the document in the form of a specific type.
                  * @return T The document in the form of a specific type
                  */
-                template <typename T> T get(const Formatting formatting = Formatting::None, int tabc = 0) const {
-                    if (std::is_same_v<T, std::string>) {
+                template <typename T> T get(const Formatting formatting = Formatting::None, integer_type tabc = 0) const {
+                    if (std::is_same_v<T, string_type>) {
                         return this->get(formatting, tabc);
                     }
                     return T(this->get(formatting, tabc));
@@ -1169,15 +1180,15 @@ namespace docpp {
                 Section& get_section();
                 /**
                  * @brief Get the doctype of the document
-                 * @return std::string The doctype of the document
+                 * @return string_type The doctype of the document
                  */
-                [[nodiscard]] std::string get_doctype() const;
+                [[nodiscard]] string_type get_doctype() const;
                 /**
                  * @brief Get the doctype of the document in a specific type
                  * @return T The doctype of the document
                  */
                 template <typename T> T get_doctype() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->doctype;
                     }
                     return T(this->doctype);
@@ -1192,7 +1203,7 @@ namespace docpp {
                  * @brief Set the doctype of the document
                  * @param doctype The doctype to set
                  */
-                void set_doctype(const std::string& doctype);
+                void set_doctype(const string_type& doctype);
                 /**
                  * @brief Get the size of the document
                  * @return size_type The size of the document
@@ -1219,7 +1230,7 @@ namespace docpp {
                  * @param document The section to be assigned to the document
                  * @param doctype The doctype to prepend at the top, before the section
                  */
-                explicit Document(const Section& document, std::string doctype = "<!DOCTYPE html>") : document(document), doctype(std::move(doctype)) {};
+                explicit Document(const Section& document, string_type doctype = "<!DOCTYPE html>") : document(document), doctype(std::move(doctype)) {};
                 /**
                  * @brief Construct a new Document object
                  * @param document The document to set
@@ -1255,10 +1266,9 @@ namespace docpp {
          */
         class Property {
             private:
-                std::pair<std::string, std::string> property{};
+                std::pair<string_type, string_type> property{};
             protected:
             public:
-                using size_type = std::size_t;
                 /**
                  * @brief The npos value
                  */
@@ -1269,7 +1279,7 @@ namespace docpp {
                  * @param key The key of the property
                  * @param value The value of the property
                  */
-                Property(const std::string& key, const std::string& value) : property(std::make_pair(key, value)) {};
+                Property(const string_type& key, const string_type& value) : property(std::make_pair(key, value)) {};
                 /**
                  * @brief Construct a new Property object
                  */
@@ -1285,45 +1295,45 @@ namespace docpp {
 
                 /**
                  * @brief Get the key of the property
-                 * @return std::string The key of the property
+                 * @return string_type The key of the property
                  */
-                [[nodiscard]] std::string get_key() const;
+                [[nodiscard]] string_type get_key() const;
                 /**
                  * @brief Get the key of the property in a specific type
                  * @return T The key of the property
                  */
                 template <typename T> T get_key() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->property.first;
                     }
                     return T(this->property.first);
                 }
                 /**
                  * @brief Get the value of the property
-                 * @return std::string The value of the property
+                 * @return string_type The value of the property
                  */
-                [[nodiscard]] std::string get_value() const;
+                [[nodiscard]] string_type get_value() const;
                 /**
                  * @brief Get the value of the property in a specific type
                  * @return T The value of the property
                  */
                 template <typename T> T get_value() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->property.second;
                     }
                     return T(this->property.second);
                 }
                 /**
                  * @brief Get the property.
-                 * @return std::pair<std::string, std::string> The value of the property
+                 * @return std::pair<string_type, string_type> The value of the property
                  */
-                [[nodiscard]] std::pair<std::string, std::string> get() const;
+                [[nodiscard]] std::pair<string_type, string_type> get() const;
                 /**
                  * @brief Get the property in a specific type.
                  * @return std::pair<T, T> The value of the property
                  */
                 template <typename T> std::pair<T, T> get() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return std::make_pair(this->property.first, this->property.second);
                     }
                     return std::pair<T, T>(this->property.first, this->property.second);
@@ -1332,18 +1342,18 @@ namespace docpp {
                  * @brief Set the key of the property.
                  * @param key The key.
                  */
-                void set_key(const std::string& key);
+                void set_key(const string_type& key);
                 /**
                  * @brief Set the value of the property.
                  * @param value The value.
                  */
-                void set_value(const std::string& value);
+                void set_value(const string_type& value);
                 /**
                  * @brief Set the property
                  * @param key The key of the property
                  * @param value The value of the property
                  */
-                void set(const std::string& key, const std::string& value);
+                void set(const string_type& key, const string_type& value);
 
                 Property& operator=(const Property& property);
                 bool operator==(const Property& property) const;
@@ -1355,10 +1365,9 @@ namespace docpp {
          */
         class Element {
             private:
-                std::pair<std::string, std::vector<Property>> element{};
+                std::pair<string_type, std::vector<Property>> element{};
             protected:
             public:
-                using size_type = std::size_t;
                 using iterator = std::vector<Property>::iterator;
                 using const_iterator = std::vector<Property>::const_iterator;
                 using reverse_iterator = std::vector<Property>::reverse_iterator;
@@ -1425,7 +1434,7 @@ namespace docpp {
                  * @param tag The tag of the element
                  * @param properties The properties of the element
                  */
-                Element(const std::string& tag, const std::vector<Property>& properties) : element(std::make_pair(tag, properties)) {};
+                Element(const string_type& tag, const std::vector<Property>& properties) : element(std::make_pair(tag, properties)) {};
                 /**
                  * @brief Construct a new Element object
                  * @param element The element to set
@@ -1484,7 +1493,7 @@ namespace docpp {
                  * @param str The property to find
                  * @return size_type The index of the property
                  */
-                [[nodiscard]] size_type find(const std::string& str) const;
+                [[nodiscard]] size_type find(const string_type& str) const;
                 /**
                  * @brief Swap two properties in the element
                  * @param index1 The index of the first property
@@ -1536,7 +1545,7 @@ namespace docpp {
                  * @param tag The tag of the element
                  * @param properties The properties to set
                  */
-                void set(const std::string& tag, const std::vector<Property>& properties);
+                void set(const string_type& tag, const std::vector<Property>& properties);
                 /**
                  * @brief Set the properties of the element
                  * @param tag The tag of the element
@@ -1547,7 +1556,7 @@ namespace docpp {
                  * @brief Set the tag of the element
                  * @param tag The tag to set
                  */
-                void set_tag(const std::string& tag);
+                void set_tag(const string_type& tag);
                 /**
                  * @brief Set the tag of the element
                  * @param tag The tag to set
@@ -1560,30 +1569,30 @@ namespace docpp {
                 void set_properties(const std::vector<Property>& properties);
                 /**
                  * @brief Get the element
-                 * @return std::pair<std::string, std::vector<Property>> The element
+                 * @return std::pair<string_type, std::vector<Property>> The element
                  */
-                [[nodiscard]] std::string get(Formatting formatting = Formatting::None, int tabc = 0) const;
+                [[nodiscard]] string_type get(Formatting formatting = Formatting::None, integer_type tabc = 0) const;
                 /**
                  * @brief Get the element in the form of a specific type.
                  * @return T The element in the form of a specific type
                  */
-                template <typename T> T get(const Formatting formatting = Formatting::None, const int tabc = 0) const {
-                    if (std::is_same_v<T, std::string>) {
+                template <typename T> T get(const Formatting formatting = Formatting::None, const integer_type tabc = 0) const {
+                    if (std::is_same_v<T, string_type>) {
                         return this->get(formatting, tabc);
                     }
                     return T(this->get(formatting, tabc));
                 }
                 /**
                  * @brief Get the tag of the element
-                 * @return std::string The tag of the element
+                 * @return string_type The tag of the element
                  */
-                [[nodiscard]] std::string get_tag() const;
+                [[nodiscard]] string_type get_tag() const;
                 /**
                  * @brief Get the tag of the element in a specific type
                  * @return T The tag of the element
                  */
                 template <typename T> T get_tag() const {
-                    if (std::is_same_v<T, std::string>) {
+                    if (std::is_same_v<T, string_type>) {
                         return this->element.first;
                     }
                     return T(this->element.first);
@@ -1595,7 +1604,7 @@ namespace docpp {
                 [[nodiscard]] std::vector<Property> get_properties() const;
 
                 Element& operator=(const Element& element);
-                Element& operator=(const std::pair<std::string, std::vector<Property>>& element);
+                Element& operator=(const std::pair<string_type, std::vector<Property>>& element);
                 Element& operator+=(const Property& property);
                 Property operator[](const size_type& index) const;
                 bool operator==(const Element& element) const;
@@ -1610,7 +1619,6 @@ namespace docpp {
                 std::vector<Element> elements{};
             protected:
             public:
-                using size_type = std::size_t;
                 using iterator = std::vector<Element>::iterator;
                 using const_iterator = std::vector<Element>::const_iterator;
                 using reverse_iterator = std::vector<Element>::reverse_iterator;
@@ -1723,7 +1731,7 @@ namespace docpp {
                  * @param str The element to find, either the tag or the stylesheet itself
                  * @return size_type The index of the element
                  */
-                [[nodiscard]] size_type find(const std::string& str) const;
+                [[nodiscard]] size_type find(const string_type& str) const;
                 /**
                  * @brief Get the element at an index
                  * @param index The index of the element
@@ -1778,15 +1786,15 @@ namespace docpp {
                 [[nodiscard]] std::vector<Element> get_elements() const;
                 /**
                  * @brief Get the stylesheet
-                 * @return std::string The stylesheet
+                 * @return string_type The stylesheet
                  */
-                [[nodiscard]] std::string get(Formatting formatting = Formatting::None, int tabc = 0) const;
+                [[nodiscard]] string_type get(Formatting formatting = Formatting::None, integer_type tabc = 0) const;
                 /**
                  * @brief Get the stylesheet in the form of a specific type.
                  * @return T The stylesheet in the form of a specific type
                  */
-                template <typename T> T get(const Formatting formatting = Formatting::None, const int tabc = 0) const {
-                    if (std::is_same_v<T, std::string>) {
+                template <typename T> T get(const Formatting formatting = Formatting::None, const integer_type tabc = 0) const {
+                    if (std::is_same_v<T, string_type>) {
                         return this->get(formatting, tabc);
                     }
                     return T(this->get(formatting, tabc));
@@ -1806,5 +1814,5 @@ namespace docpp {
      * @brief Get the version of the library
      * @return std::tuple<int, int, int> The version of the library
      */
-    std::tuple<int, int, int> version();
+    std::tuple<integer_type, integer_type, integer_type> version();
 } // namespace docpp
diff --git a/src/docpp.cpp b/src/docpp.cpp
index 91303f7..fa7df85 100644
--- a/src/docpp.cpp
+++ b/src/docpp.cpp
@@ -11,27 +11,27 @@
 #include <vector>
 #include <algorithm>
 
-std::string docpp::HTML::Property::get_key() const {
+docpp::string_type docpp::HTML::Property::get_key() const {
     return this->property.first;
 }
 
-std::string docpp::HTML::Property::get_value() const {
+docpp::string_type docpp::HTML::Property::get_value() const {
     return this->property.second;
 }
 
-std::pair<std::string, std::string> docpp::HTML::Property::get() const {
+std::pair<docpp::string_type, docpp::string_type> docpp::HTML::Property::get() const {
     return this->property;
 }
 
-void docpp::HTML::Property::set_key(const std::string& key) {
+void docpp::HTML::Property::set_key(const docpp::string_type& key) {
     this->property.first = key;
 }
 
-void docpp::HTML::Property::set_value(const std::string& value) {
+void docpp::HTML::Property::set_value(const docpp::string_type& value) {
     this->property.second = value;
 }
 
-void docpp::HTML::Property::set(const std::pair<std::string, std::string>& property) {
+void docpp::HTML::Property::set(const std::pair<docpp::string_type, docpp::string_type>& property) {
     this->property = property;
 }
 
@@ -149,10 +149,10 @@ void docpp::HTML::Properties::push_back(const docpp::HTML::Property& property) {
     this->properties.push_back(property);
 }
 
-docpp::HTML::Properties::size_type docpp::HTML::Properties::find(const docpp::HTML::Property& property) const {
+docpp::size_type docpp::HTML::Properties::find(const docpp::HTML::Property& property) const {
     for (size_type i{0}; i < this->properties.size(); i++) {
-        if (this->properties.at(i).get_value().find(property.get_value()) != std::string::npos
-            || this->properties.at(i).get_key().find(property.get_key()) != std::string::npos) {
+        if (this->properties.at(i).get_value().find(property.get_value()) != docpp::string_type::npos
+            || this->properties.at(i).get_key().find(property.get_key()) != docpp::string_type::npos) {
             return i;
         }
     }
@@ -160,10 +160,10 @@ docpp::HTML::Properties::size_type docpp::HTML::Properties::find(const docpp::HT
     return docpp::HTML::Properties::npos;
 }
 
-docpp::HTML::Properties::size_type docpp::HTML::Properties::find(const std::string& str) const {
+docpp::size_type docpp::HTML::Properties::find(const docpp::string_type& str) const {
     for (size_type i{0}; i < this->properties.size(); i++) {
-        if (this->properties.at(i).get_key().find(str) != std::string::npos ||
-            this->properties.at(i).get_value().find(str) != std::string::npos) {
+        if (this->properties.at(i).get_key().find(str) != docpp::string_type::npos ||
+            this->properties.at(i).get_value().find(str) != docpp::string_type::npos) {
             return i;
         }
     }
@@ -179,7 +179,7 @@ docpp::HTML::Property docpp::HTML::Properties::back() const {
     return this->properties.back();
 }
 
-docpp::HTML::Properties::size_type docpp::HTML::Properties::size() const {
+docpp::size_type docpp::HTML::Properties::size() const {
     return this->properties.size();
 }
 
@@ -209,7 +209,7 @@ docpp::HTML::Element& docpp::HTML::Element::operator=(const docpp::HTML::Element
     return *this;
 }
 
-docpp::HTML::Element& docpp::HTML::Element::operator+=(const std::string& data) {
+docpp::HTML::Element& docpp::HTML::Element::operator+=(const docpp::string_type& data) {
     this->data += data;
     return *this;
 }
@@ -222,30 +222,30 @@ bool docpp::HTML::Element::operator!=(const docpp::HTML::Element& element) const
     return this->tag != element.get_tag() || this->properties != element.properties || this->data != element.get_data() || this->type != element.type;
 }
 
-void docpp::HTML::Element::set(const std::string& tag, const Properties& properties, const std::string& data, const Type type) {
+void docpp::HTML::Element::set(const docpp::string_type& tag, const Properties& properties, const docpp::string_type& data, const Type type) {
     this->set_tag(tag);
     this->set_properties(properties);
     this->set_data(data);
     this->set_type(type);
 }
 
-void docpp::HTML::Element::set(const Tag tag, const Properties& properties, const std::string& data) {
+void docpp::HTML::Element::set(const Tag tag, const Properties& properties, const docpp::string_type& data) {
     this->set_tag(tag);
     this->set_properties(properties);
     this->set_data(data);
 }
 
-void docpp::HTML::Element::set_tag(const std::string& tag) {
+void docpp::HTML::Element::set_tag(const docpp::string_type& tag) {
     this->tag = tag;
 }
 
 void docpp::HTML::Element::set_tag(const Tag tag) {
-    std::pair<std::string, docpp::HTML::Type> resolved{resolve_tag(tag)};
+    std::pair<docpp::string_type, docpp::HTML::Type> resolved{resolve_tag(tag)};
     this->tag = resolved.first;
     this->type = resolved.second;
 }
 
-void docpp::HTML::Element::set_data(const std::string& data) {
+void docpp::HTML::Element::set_data(const docpp::string_type& data) {
     this->data = data;
 }
 
@@ -257,8 +257,8 @@ void docpp::HTML::Element::set_properties(const Properties& properties) {
     this->properties = properties;
 }
 
-std::string docpp::HTML::Element::get(const Formatting formatting, const int tabc) const {
-    std::string ret{};
+docpp::string_type docpp::HTML::Element::get(const Formatting formatting, const docpp::integer_type tabc) const {
+    docpp::string_type ret{};
 
     if (this->type == docpp::HTML::Type::Text_No_Formatting) {
         return this->data;
@@ -309,11 +309,11 @@ std::string docpp::HTML::Element::get(const Formatting formatting, const int tab
     return ret;
 }
 
-std::string docpp::HTML::Element::get_tag() const {
+docpp::string_type docpp::HTML::Element::get_tag() const {
     return this->tag;
 }
 
-std::string docpp::HTML::Element::get_data() const {
+docpp::string_type docpp::HTML::Element::get_data() const {
     return this->data;
 }
 
@@ -347,12 +347,12 @@ docpp::HTML::Section& docpp::HTML::Section::operator+=(const docpp::HTML::Sectio
     return *this;
 }
 
-docpp::HTML::Element docpp::HTML::Section::operator[](const int& index) const {
+docpp::HTML::Element docpp::HTML::Section::operator[](const docpp::integer_type& index) const {
     return this->at(index);
 }
 
-std::unordered_map<std::string, docpp::HTML::Element> docpp::HTML::Section::operator[](const std::string& tag) const {
-    std::unordered_map<std::string, docpp::HTML::Element> ret{};
+std::unordered_map<docpp::string_type, docpp::HTML::Element> docpp::HTML::Section::operator[](const docpp::string_type& tag) const {
+    std::unordered_map<docpp::string_type, docpp::HTML::Element> ret{};
 
     for (const Element& it : this->get_elements()) {
         if (it.get_tag() == tag) {
@@ -363,8 +363,8 @@ std::unordered_map<std::string, docpp::HTML::Element> docpp::HTML::Section::oper
     return ret;
 }
 
-std::unordered_map<std::string, docpp::HTML::Element> docpp::HTML::Section::operator[](const Tag tag) const {
-    std::unordered_map<std::string, docpp::HTML::Element> ret{};
+std::unordered_map<docpp::string_type, docpp::HTML::Element> docpp::HTML::Section::operator[](const Tag tag) const {
+    std::unordered_map<docpp::string_type, docpp::HTML::Element> ret{};
 
     for (const Element& it : this->get_elements()) {
         if (it.get_tag() == resolve_tag(tag).first) {
@@ -396,17 +396,17 @@ bool docpp::HTML::Section::operator!=(const docpp::HTML::Element& element) const
     });
 }
 
-void docpp::HTML::Section::set(const std::string& tag, const Properties& properties) {
+void docpp::HTML::Section::set(const docpp::string_type& tag, const Properties& properties) {
     this->tag = tag;
     this->properties = properties;
 }
 
-void docpp::HTML::Section::set_tag(const std::string& tag) {
+void docpp::HTML::Section::set_tag(const docpp::string_type& tag) {
     this->tag = tag;
 }
 
 void docpp::HTML::Section::set_tag(const Tag tag) {
-    std::pair<std::string, docpp::HTML::Type> resolved{resolve_tag(tag)};
+    std::pair<docpp::string_type, docpp::HTML::Type> resolved{resolve_tag(tag)};
     this->tag = resolved.first;
 }
 
@@ -414,7 +414,7 @@ void docpp::HTML::Section::set_properties(const Properties& properties) {
     this->properties = properties;
 }
 
-std::unordered_map<docpp::HTML::Tag, std::pair<std::string, docpp::HTML::Type>> docpp::HTML::get_tag_map() {
+std::unordered_map<docpp::HTML::Tag, std::pair<docpp::string_type, docpp::HTML::Type>> docpp::HTML::get_tag_map() {
     return {
         {Tag::Empty, {"", Type::Text}},
         {Tag::Empty_No_Formatting, {"", Type::Text_No_Formatting}},
@@ -564,19 +564,19 @@ std::unordered_map<docpp::HTML::Tag, std::pair<std::string, docpp::HTML::Type>>
     };
 }
 
-std::pair<std::string, docpp::HTML::Type> docpp::HTML::resolve_tag(const Tag tag) {
-    const std::unordered_map<docpp::HTML::Tag, std::pair<std::string, docpp::HTML::Type>> tag_map{get_tag_map()};
+std::pair<docpp::string_type, docpp::HTML::Type> docpp::HTML::resolve_tag(const Tag tag) {
+    const std::unordered_map<docpp::HTML::Tag, std::pair<docpp::string_type, docpp::HTML::Type>> tag_map{get_tag_map()};
 
     if (tag_map.find(tag) != tag_map.end()) {
         return tag_map.at(tag);
     }
 
-    const std::string throwmsg{"Invalid tag: " + std::to_string(static_cast<int>(tag))};
+    const docpp::string_type throwmsg{"Invalid tag: " + std::to_string(static_cast<docpp::integer_type>(tag))};
     throw docpp::invalid_argument{throwmsg.c_str()};
 }
 
-docpp::HTML::Tag docpp::HTML::resolve_tag(const std::string& tag) {
-    const std::unordered_map<docpp::HTML::Tag, std::pair<std::string, docpp::HTML::Type>> tag_map{get_tag_map()};
+docpp::HTML::Tag docpp::HTML::resolve_tag(const docpp::string_type& tag) {
+    const std::unordered_map<docpp::HTML::Tag, std::pair<docpp::string_type, docpp::HTML::Type>> tag_map{get_tag_map()};
 
     for (const auto& it : tag_map) {
         if (it.second.first == tag) {
@@ -707,7 +707,7 @@ docpp::HTML::Section& docpp::HTML::Section::at_section(const size_type index) {
     throw docpp::out_of_range("Index out of range");
 }
 
-docpp::HTML::Section::size_type docpp::HTML::Section::find(const Element& element) const {
+docpp::size_type docpp::HTML::Section::find(const Element& element) const {
     for (size_type i{0}; i < this->size(); i++) {
         const Element it = this->get_elements().at(i);
 
@@ -719,7 +719,7 @@ docpp::HTML::Section::size_type docpp::HTML::Section::find(const Element& elemen
     return docpp::HTML::Section::npos;
 }
 
-docpp::HTML::Section::size_type docpp::HTML::Section::find(const Section& section) const {
+docpp::size_type docpp::HTML::Section::find(const Section& section) const {
     for (size_type i{0}; i < this->size(); i++) {
         const Section it = this->get_sections().at(i);
 
@@ -731,7 +731,7 @@ docpp::HTML::Section::size_type docpp::HTML::Section::find(const Section& sectio
     return docpp::HTML::Section::npos;
 }
 
-docpp::HTML::Section::size_type docpp::HTML::Section::find(const std::string& str) const {
+docpp::size_type docpp::HTML::Section::find(const docpp::string_type& str) const {
     const std::vector<docpp::HTML::Element> elements{this->get_elements()};
 
     for (size_type i{0}; i < this->size(); i++) {
@@ -823,7 +823,7 @@ docpp::HTML::Section& docpp::HTML::Section::back_section() {
     throw docpp::out_of_range("Index out of range");
 }
 
-docpp::HTML::Section::size_type docpp::HTML::Section::size() const {
+docpp::size_type docpp::HTML::Section::size() const {
     return this->index;
 }
 
@@ -863,9 +863,9 @@ std::vector<docpp::HTML::Section> docpp::HTML::Section::get_sections() const {
     return ret;
 }
 
-std::string docpp::HTML::Section::get(const Formatting formatting, const int tabc) const { // NOLINT
-    std::string ret{};
-    int tabcount{tabc};
+docpp::string_type docpp::HTML::Section::get(const Formatting formatting, const docpp::integer_type tabc) const { // NOLINT
+    docpp::string_type ret{};
+    docpp::integer_type tabcount{tabc};
 
     if (this->tag.empty() && this->properties.empty() && this->sections.empty() && this->elements.empty()) {
         return {};
@@ -923,7 +923,7 @@ std::string docpp::HTML::Section::get(const Formatting formatting, const int tab
     return ret;
 }
 
-std::string docpp::HTML::Section::get_tag() const {
+docpp::string_type docpp::HTML::Section::get_tag() const {
     return this->tag;
 }
 
@@ -949,7 +949,7 @@ void docpp::HTML::Section::swap(const Section& section1, const Section& section2
     this->swap(this->find(section1), this->find(section2));
 }
 
-std::string docpp::HTML::Document::get(const Formatting formatting, const int tabc) const {
+docpp::string_type docpp::HTML::Document::get(const Formatting formatting, const docpp::integer_type tabc) const {
     return this->doctype + (formatting == Formatting::Pretty ? "\n" : formatting == Formatting::Newline ? "\n" : "") + this->document.get(formatting, tabc);
 }
 
@@ -965,11 +965,11 @@ void docpp::HTML::Document::set(const docpp::HTML::Section& document) {
     this->document = document;
 }
 
-docpp::HTML::Document::size_type docpp::HTML::Document::size() const {
+docpp::size_type docpp::HTML::Document::size() const {
     return this->document.size();
 }
 
-void docpp::HTML::Document::set_doctype(const std::string& doctype) {
+void docpp::HTML::Document::set_doctype(const docpp::string_type& doctype) {
     this->doctype = doctype;
 }
 
@@ -1009,31 +1009,31 @@ bool docpp::HTML::Document::operator!=(const docpp::HTML::Section& section) cons
     return this->document != section;
 }
 
-std::string docpp::HTML::Document::get_doctype() const {
+docpp::string_type docpp::HTML::Document::get_doctype() const {
     return this->doctype;
 }
 
-std::string docpp::CSS::Property::get_key() const {
+docpp::string_type docpp::CSS::Property::get_key() const {
     return this->property.first;
 }
 
-std::string docpp::CSS::Property::get_value() const {
+docpp::string_type docpp::CSS::Property::get_value() const {
     return this->property.second;
 }
 
-std::pair<std::string, std::string> docpp::CSS::Property::get() const {
+std::pair<docpp::string_type, docpp::string_type> docpp::CSS::Property::get() const {
     return this->property;
 }
 
-void docpp::CSS::Property::set_key(const std::string& key) {
+void docpp::CSS::Property::set_key(const docpp::string_type& key) {
     this->property.first = key;
 }
 
-void docpp::CSS::Property::set_value(const std::string& value) {
+void docpp::CSS::Property::set_value(const docpp::string_type& value) {
     this->property.second = value;
 }
 
-void docpp::CSS::Property::set(const std::string& key, const std::string& value) {
+void docpp::CSS::Property::set(const docpp::string_type& key, const docpp::string_type& value) {
     this->property = std::make_pair(key, value);
 }
 
@@ -1072,12 +1072,12 @@ bool docpp::CSS::Element::operator!=(const docpp::CSS::Element& element) const {
     return this->get() != element.get();
 }
 
-void docpp::CSS::Element::set(const std::string& tag, const std::vector<Property>& properties) {
+void docpp::CSS::Element::set(const docpp::string_type& tag, const std::vector<Property>& properties) {
     this->element.first = tag;
     this->element.second = properties;
 }
 
-void docpp::CSS::Element::set_tag(const std::string& tag) {
+void docpp::CSS::Element::set_tag(const docpp::string_type& tag) {
     this->element.first = tag;
 }
 
@@ -1129,7 +1129,7 @@ docpp::CSS::Property& docpp::CSS::Element::at(const size_type index) {
     return this->element.second.at(index);
 }
 
-docpp::CSS::Element::size_type docpp::CSS::Element::find(const Property& property) const {
+docpp::size_type docpp::CSS::Element::find(const Property& property) const {
     for (size_type i{0}; i < this->element.second.size(); i++) {
         if (this->element.second.at(i).get() == property.get()) {
             return i;
@@ -1139,7 +1139,7 @@ docpp::CSS::Element::size_type docpp::CSS::Element::find(const Property& propert
     return docpp::CSS::Element::npos;
 }
 
-docpp::CSS::Element::size_type docpp::CSS::Element::find(const std::string& str) const {
+docpp::size_type docpp::CSS::Element::find(const docpp::string_type& str) const {
     for (size_type i{0}; i < this->element.second.size(); i++) {
         if (this->element.second.at(i).get_key() == str || this->element.second.at(i).get_value() == str) {
             return i;
@@ -1165,7 +1165,7 @@ docpp::CSS::Property& docpp::CSS::Element::back() {
     return this->element.second.back();
 }
 
-docpp::CSS::Element::size_type docpp::CSS::Element::size() const {
+docpp::size_type docpp::CSS::Element::size() const {
     return this->element.second.size();
 }
 
@@ -1190,8 +1190,8 @@ void docpp::CSS::Element::swap(const Property& property1, const Property& proper
     this->swap(this->find(property1), this->find(property2));
 }
 
-std::string docpp::CSS::Element::get(const Formatting formatting, const int tabc) const {
-    std::string ret{};
+docpp::string_type docpp::CSS::Element::get(const Formatting formatting, const docpp::integer_type tabc) const {
+    docpp::string_type ret{};
 
     if (!this->element.first.empty()) {
         if (formatting == docpp::CSS::Formatting::Pretty) {
@@ -1240,7 +1240,7 @@ std::string docpp::CSS::Element::get(const Formatting formatting, const int tabc
     return ret;
 }
 
-std::string docpp::CSS::Element::get_tag() const {
+docpp::string_type docpp::CSS::Element::get_tag() const {
     return this->element.first;
 }
 
@@ -1286,7 +1286,7 @@ docpp::CSS::Stylesheet& docpp::CSS::Stylesheet::operator+=(const Element& elemen
     return *this;
 }
 
-docpp::CSS::Element docpp::CSS::Stylesheet::operator[](const int& index) const {
+docpp::CSS::Element docpp::CSS::Stylesheet::operator[](const docpp::integer_type& index) const {
     return this->at(index);
 }
 
@@ -1306,7 +1306,7 @@ docpp::CSS::Element docpp::CSS::Stylesheet::at(const size_type index) const {
     return this->elements.at(index);
 }
 
-docpp::CSS::Stylesheet::size_type docpp::CSS::Stylesheet::find(const Element& element) const {
+docpp::size_type docpp::CSS::Stylesheet::find(const Element& element) const {
     for (size_type i{0}; i < this->elements.size(); i++) {
         if (this->elements.at(i).get() == element.get()) {
             return i;
@@ -1316,7 +1316,7 @@ docpp::CSS::Stylesheet::size_type docpp::CSS::Stylesheet::find(const Element& el
     return docpp::CSS::Stylesheet::npos;
 }
 
-docpp::CSS::Stylesheet::size_type docpp::CSS::Stylesheet::find(const std::string& str) const {
+docpp::size_type docpp::CSS::Stylesheet::find(const docpp::string_type& str) const {
     for (size_type i{0}; i < this->elements.size(); i++) {
         if (this->elements.at(i).get() == str || this->elements.at(i).get_tag() == str) {
             return i;
@@ -1326,7 +1326,7 @@ docpp::CSS::Stylesheet::size_type docpp::CSS::Stylesheet::find(const std::string
     return docpp::CSS::Stylesheet::npos;
 }
 
-docpp::CSS::Stylesheet::size_type docpp::CSS::Stylesheet::size() const {
+docpp::size_type docpp::CSS::Stylesheet::size() const {
     return this->elements.size();
 }
 
@@ -1362,8 +1362,8 @@ std::vector<docpp::CSS::Element> docpp::CSS::Stylesheet::get_elements() const {
     return this->elements;
 }
 
-std::string docpp::CSS::Stylesheet::get(const Formatting formatting, const int tabc) const {
-    std::string ret{};
+docpp::string_type docpp::CSS::Stylesheet::get(const Formatting formatting, const docpp::integer_type tabc) const {
+    docpp::string_type ret{};
 
     for (const Element& it : this->elements) {
         ret += it.get(formatting, tabc);
@@ -1372,20 +1372,20 @@ std::string docpp::CSS::Stylesheet::get(const Formatting formatting, const int t
     return ret;
 }
 
-std::tuple<int, int, int> docpp::version() {
+std::tuple<docpp::integer_type, docpp::integer_type, docpp::integer_type> docpp::version() {
 #ifdef DOCPP_VERSION
-    std::string version{DOCPP_VERSION};
+    docpp::string_type version{DOCPP_VERSION};
 
-    if (version.find('.') != std::string::npos) {
-        std::string major = version.substr(0, version.find('.'));
+    if (version.find('.') != docpp::string_type::npos) {
+        docpp::string_type major = version.substr(0, version.find('.'));
         version = version.substr(version.find('.') + 1);
 
-        if (version.find('.') != std::string::npos) {
-            std::string minor = version.substr(0, version.find('.'));
+        if (version.find('.') != docpp::string_type::npos) {
+            docpp::string_type minor = version.substr(0, version.find('.'));
             version = version.substr(version.find('.') + 1);
 
-            if (version.find('.') != std::string::npos) {
-                std::string patch = version.substr(0, version.find('.'));
+            if (version.find('.') != docpp::string_type::npos) {
+                docpp::string_type patch = version.substr(0, version.find('.'));
                 return {std::stoi(major), std::stoi(minor), std::stoi(patch)};
             }
         }