diff --git a/src/AsyncEventSource.cpp b/src/AsyncEventSource.cpp
index 4cafdae..66daa77 100644
--- a/src/AsyncEventSource.cpp
+++ b/src/AsyncEventSource.cpp
@@ -22,26 +22,27 @@
   #include <rom/ets_sys.h>
 #endif
 #include "AsyncEventSource.h"
+#include "literals.h"
 
 static String generateEventMessage(const char* message, const char* event, uint32_t id, uint32_t reconnect) {
   String ev;
 
   if (reconnect) {
-    ev += F("retry: ");
+    ev += T_retry_;
     ev += reconnect;
-    ev += F("\r\n");
+    ev += T_rn;
   }
 
   if (id) {
-    ev += F("id: ");
-    ev += String(id);
-    ev += F("\r\n");
+    ev += T_id__;
+    ev += id;
+    ev += T_rn;
   }
 
   if (event != NULL) {
-    ev += F("event: ");
-    ev += String(event);
-    ev += F("\r\n");
+    ev += T_event_;
+    ev += event;
+    ev += T_rn;
   }
 
   if (message != NULL) {
@@ -57,9 +58,9 @@ static String generateEventMessage(const char* message, const char* event, uint3
         if (ldata != NULL) {
           memcpy(ldata, lineStart, llen);
           ldata[llen] = 0;
-          ev += F("data: ");
+          ev += T_data_;
           ev += ldata;
-          ev += F("\r\n\r\n");
+          ev += T_rnrn;
           free(ldata);
         }
         lineStart = (char*)message + messageLen;
@@ -92,14 +93,14 @@ static String generateEventMessage(const char* message, const char* event, uint3
         if (ldata != NULL) {
           memcpy(ldata, lineStart, llen);
           ldata[llen] = 0;
-          ev += F("data: ");
+          ev += T_data_;
           ev += ldata;
-          ev += F("\r\n");
+          ev += T_rn;
           free(ldata);
         }
         lineStart = nextLine;
         if (lineStart == ((char*)message + messageLen))
-          ev += F("\r\n");
+          ev += T_rn;
       }
     } while (lineStart < ((char*)message + messageLen));
   }
@@ -158,8 +159,8 @@ AsyncEventSourceClient::AsyncEventSourceClient(AsyncWebServerRequest* request, A
   _client = request->client();
   _server = server;
   _lastId = 0;
-  if (request->hasHeader(F("Last-Event-ID")))
-    _lastId = atoi(request->getHeader(F("Last-Event-ID"))->value().c_str());
+  if (request->hasHeader(T_Last_Event_ID))
+    _lastId = atoi(request->getHeader(T_Last_Event_ID)->value().c_str());
 
   _client->setRxTimeout(0);
   _client->onError(NULL, NULL);
@@ -360,8 +361,8 @@ bool AsyncEventSource::canHandle(AsyncWebServerRequest* request) {
   if (request->method() != HTTP_GET || !request->url().equals(_url)) {
     return false;
   }
-  request->addInterestingHeader(F("Last-Event-ID"));
-  request->addInterestingHeader("Cookie");
+  request->addInterestingHeader(T_Last_Event_ID);
+  request->addInterestingHeader(T_Cookie);
   return true;
 }
 
@@ -382,10 +383,10 @@ void AsyncEventSource::handleRequest(AsyncWebServerRequest* request) {
 AsyncEventSourceResponse::AsyncEventSourceResponse(AsyncEventSource* server) {
   _server = server;
   _code = 200;
-  _contentType = F("text/event-stream");
+  _contentType = T_text_event_stream;
   _sendContentLength = false;
-  addHeader(F("Cache-Control"), F("no-cache"));
-  addHeader(F("Connection"), F("keep-alive"));
+  addHeader(T_Cache_Control, T_no_cache);
+  addHeader(T_Connection, T_keep_alive);
 }
 
 void AsyncEventSourceResponse::_respond(AsyncWebServerRequest* request) {
diff --git a/src/AsyncWebSocket.cpp b/src/AsyncWebSocket.cpp
index e978afc..fa7c22d 100644
--- a/src/AsyncWebSocket.cpp
+++ b/src/AsyncWebSocket.cpp
@@ -1108,7 +1108,7 @@ void AsyncWebSocket::handleRequest(AsyncWebServerRequest* request) {
   const AsyncWebHeader* version = request->getHeader(WS_STR_VERSION);
   if (version->value().toInt() != 13) {
     AsyncWebServerResponse* response = request->beginResponse(400);
-    response->addHeader(WS_STR_VERSION, F("13"));
+    response->addHeader(WS_STR_VERSION, T_13);
     request->send(response);
     return;
   }
@@ -1173,7 +1173,7 @@ AsyncWebSocketResponse::AsyncWebSocketResponse(const String& key, AsyncWebSocket
   int len = base64_encode_block((const char*)hash, 20, buffer, &_state);
   len = base64_encode_blockend((buffer + len), &_state);
   addHeader(WS_STR_CONNECTION, WS_STR_UPGRADE);
-  addHeader(WS_STR_UPGRADE, F("websocket"));
+  addHeader(WS_STR_UPGRADE, T_WS);
   addHeader(WS_STR_ACCEPT, buffer);
 }
 
diff --git a/src/ESPAsyncWebServer.h b/src/ESPAsyncWebServer.h
index 77c5de7..ef94ab3 100644
--- a/src/ESPAsyncWebServer.h
+++ b/src/ESPAsyncWebServer.h
@@ -43,6 +43,8 @@
   #error Platform not supported
 #endif
 
+#include "literals.h"
+
 #define ASYNCWEBSERVER_VERSION          "3.0.6"
 #define ASYNCWEBSERVER_VERSION_MAJOR    3
 #define ASYNCWEBSERVER_VERSION_MINOR    0
@@ -151,7 +153,7 @@ class AsyncWebHeader {
 
     const String& name() const { return _name; }
     const String& value() const { return _value; }
-    String toString() const { return _name + F(": ") + _value + F("\r\n"); }
+    String toString() const { return _name + (char)0x3a + (char)0x20 /*": "*/ + _value + T_rn; }
 };
 
 /*
@@ -509,10 +511,13 @@ class AsyncWebServerResponse {
     size_t _ackedLength;
     size_t _writtenLength;
     WebResponseState _state;
-    const char* _responseCodeToString(int code);
 
   public:
+#ifndef ESP8266
+    static const char* responseCodeToString(int code);
+#else
     static const __FlashStringHelper* responseCodeToString(int code);
+#endif
 
   public:
     AsyncWebServerResponse();
diff --git a/src/WebAuthentication.cpp b/src/WebAuthentication.cpp
index abd74b8..14a7729 100644
--- a/src/WebAuthentication.cpp
+++ b/src/WebAuthentication.cpp
@@ -25,6 +25,7 @@
 #else
   #include "md5.h"
 #endif
+#include "literals.h"
 
 // Basic Auth hash = base64("username:password")
 
@@ -133,16 +134,16 @@ String generateDigestHash(const char* username, const char* password, const char
 }
 
 String requestDigestAuthentication(const char* realm) {
-  String header = F("realm=\"");
+  String header(T_realm__);
   if (realm == NULL)
-    header.concat(F("asyncesp"));
+    header.concat(T_asyncesp);
   else
     header.concat(realm);
-  header.concat(F("\", qop=\"auth\", nonce=\""));
+  header.concat(T_auth_nonce);
   header.concat(genRandomMD5());
-  header.concat(F("\", opaque=\""));
+  header.concat(T__opaque);
   header.concat(genRandomMD5());
-  header += '"';
+  header += (char)0x22; // '"'
   return header;
 }
 
@@ -173,7 +174,8 @@ bool checkDigestAuthentication(const char* header, const __FlashStringHelper* me
   String myNc;
   String myCnonce;
 
-  myHeader += F(", ");
+  myHeader += (char)0x2c; // ','
+  myHeader += (char)0x20; // ' '
   do {
     String avLine(myHeader.substring(0, nextBreak));
     avLine.trim();
@@ -191,42 +193,42 @@ bool checkDigestAuthentication(const char* header, const __FlashStringHelper* me
       avLine = avLine.substring(1, avLine.length() - 1);
     }
 
-    if (varName.equals(F("username"))) {
+    if (varName.equals(T_username)) {
       if (!avLine.equals(username)) {
         // os_printf("AUTH FAIL: username\n");
         return false;
       }
       myUsername = avLine;
-    } else if (varName.equals(F("realm"))) {
+    } else if (varName.equals(T_realm)) {
       if (realm != NULL && !avLine.equals(realm)) {
         // os_printf("AUTH FAIL: realm\n");
         return false;
       }
       myRealm = avLine;
-    } else if (varName.equals(F("nonce"))) {
+    } else if (varName.equals(T_nonce)) {
       if (nonce != NULL && !avLine.equals(nonce)) {
         // os_printf("AUTH FAIL: nonce\n");
         return false;
       }
       myNonce = avLine;
-    } else if (varName.equals(F("opaque"))) {
+    } else if (varName.equals(T_opaque)) {
       if (opaque != NULL && !avLine.equals(opaque)) {
         // os_printf("AUTH FAIL: opaque\n");
         return false;
       }
-    } else if (varName.equals(F("uri"))) {
+    } else if (varName.equals(T_uri)) {
       if (uri != NULL && !avLine.equals(uri)) {
         // os_printf("AUTH FAIL: uri\n");
         return false;
       }
       myUri = avLine;
-    } else if (varName.equals(F("response"))) {
+    } else if (varName.equals(T_response)) {
       myResponse = avLine;
-    } else if (varName.equals(F("qop"))) {
+    } else if (varName.equals(T_qop)) {
       myQop = avLine;
-    } else if (varName.equals(F("nc"))) {
+    } else if (varName.equals(T_nc)) {
       myNc = avLine;
-    } else if (varName.equals(F("cnonce"))) {
+    } else if (varName.equals(T_cnonce)) {
       myCnonce = avLine;
     }
   } while (nextBreak > 0);
diff --git a/src/WebHandlers.cpp b/src/WebHandlers.cpp
index d740d86..41399b8 100644
--- a/src/WebHandlers.cpp
+++ b/src/WebHandlers.cpp
@@ -222,22 +222,22 @@ void AsyncStaticWebHandler::handleRequest(AsyncWebServerRequest* request) {
     } else {
       etag = String(request->_tempFile.size());
     }
-    if (_last_modified.length() && _last_modified == request->header(F("If-Modified-Since"))) {
+    if (_last_modified.length() && _last_modified == request->header(T_IMS)) {
       request->_tempFile.close();
       request->send(304); // Not modified
-    } else if (_cache_control.length() && request->hasHeader(F("If-None-Match")) && request->header(F("If-None-Match")).equals(etag)) {
+    } else if (_cache_control.length() && request->hasHeader(T_INM) && request->header(T_INM).equals(etag)) {
       request->_tempFile.close();
       AsyncWebServerResponse* response = new AsyncBasicResponse(304); // Not modified
-      response->addHeader(F("Cache-Control"), _cache_control);
-      response->addHeader(F("ETag"), etag);
+      response->addHeader(T_Cache_Control, _cache_control);
+      response->addHeader(T_ETag, etag);
       request->send(response);
     } else {
       AsyncWebServerResponse* response = new AsyncFileResponse(request->_tempFile, filename, String(), false, _callback);
       if (_last_modified.length())
-        response->addHeader(F("Last-Modified"), _last_modified);
+        response->addHeader(T_Last_Modified, _last_modified);
       if (_cache_control.length()) {
-        response->addHeader(F("Cache-Control"), _cache_control);
-        response->addHeader(F("ETag"), etag);
+        response->addHeader(T_Cache_Control, _cache_control);
+        response->addHeader(T_ETag, etag);
       }
       request->send(response);
     }
diff --git a/src/WebRequest.cpp b/src/WebRequest.cpp
index 2331b13..a1e758e 100644
--- a/src/WebRequest.cpp
+++ b/src/WebRequest.cpp
@@ -21,6 +21,7 @@
 #include "ESPAsyncWebServer.h"
 #include "WebAuthentication.h"
 #include "WebResponseImpl.h"
+#include "literals.h"
 
 #ifndef ESP8266
   #define os_strlen strlen
@@ -113,9 +114,9 @@ void AsyncWebServerRequest::_onData(void* buf, size_t len) {
           _parsedLength += len;
       } else {
         if (_parsedLength == 0) {
-          if (_contentType.startsWith(F("application/x-www-form-urlencoded"))) {
+          if (_contentType.startsWith(T_app_xform_urlencoded)) {
             _isPlainPost = true;
-          } else if (_contentType == F("text/plain") && __is_param_char(((char*)buf)[0])) {
+          } else if (_contentType == T_text_plain && __is_param_char(((char*)buf)[0])) {
             size_t i = 0;
             while (i < len && __is_param_char(((char*)buf)[i++]))
               ;
@@ -153,7 +154,7 @@ void AsyncWebServerRequest::_onData(void* buf, size_t len) {
 }
 
 void AsyncWebServerRequest::_removeNotInterestingHeaders() {
-  if (std::any_of(std::begin(_interestingHeaders), std::end(_interestingHeaders), [](const String& str) { return str.equalsIgnoreCase(F("ANY")); }))
+  if (std::any_of(std::begin(_interestingHeaders), std::end(_interestingHeaders), [](const String& str) { return str.equalsIgnoreCase(T_ANY); }))
     return; // nothing to do
 
   for (auto iter = std::begin(_headers); iter != std::end(_headers);) {
@@ -246,19 +247,19 @@ bool AsyncWebServerRequest::_parseReqHead() {
   String u = _temp.substring(m.length() + 1, index);
   _temp = _temp.substring(index + 1);
 
-  if (m == F("GET")) {
+  if (m == T_GET) {
     _method = HTTP_GET;
-  } else if (m == F("POST")) {
+  } else if (m == T_POST) {
     _method = HTTP_POST;
-  } else if (m == F("DELETE")) {
+  } else if (m == T_DELETE) {
     _method = HTTP_DELETE;
-  } else if (m == F("PUT")) {
+  } else if (m == T_PUT) {
     _method = HTTP_PUT;
-  } else if (m == F("PATCH")) {
+  } else if (m == T_PATCH) {
     _method = HTTP_PATCH;
-  } else if (m == F("HEAD")) {
+  } else if (m == T_HEAD) {
     _method = HTTP_HEAD;
-  } else if (m == F("OPTIONS")) {
+  } else if (m == T_OPTIONS) {
     _method = HTTP_OPTIONS;
   }
 
@@ -271,7 +272,7 @@ bool AsyncWebServerRequest::_parseReqHead() {
   _url = urlDecode(u);
   _addGetParams(g);
 
-  if (!_temp.startsWith(F("HTTP/1.0")))
+  if (!_temp.startsWith(T_HTTP_1_0))
     _version = 1;
 
   _temp = String();
@@ -304,34 +305,34 @@ bool strContains(const String& src, const String& find, bool mindcase = true) {
 bool AsyncWebServerRequest::_parseReqHeader() {
   int index = _temp.indexOf(':');
   if (index) {
-    String name = _temp.substring(0, index);
-    String value = _temp.substring(index + 2);
-    if (name.equalsIgnoreCase("Host")) {
+    String name(_temp.substring(0, index));
+    String value(_temp.substring(index + 2));
+    if (name.equalsIgnoreCase(T_Host)) {
       _host = value;
-    } else if (name.equalsIgnoreCase(F("Content-Type"))) {
+    } else if (name.equalsIgnoreCase(T_Content_Type)) {
       _contentType = value.substring(0, value.indexOf(';'));
-      if (value.startsWith(F("multipart/"))) {
+      if (value.startsWith(T_MULTIPART_)) {
         _boundary = value.substring(value.indexOf('=') + 1);
         _boundary.replace(String('"'), String());
         _isMultipart = true;
       }
-    } else if (name.equalsIgnoreCase(F("Content-Length"))) {
+    } else if (name.equalsIgnoreCase(T_Content_Length)) {
       _contentLength = atoi(value.c_str());
-    } else if (name.equalsIgnoreCase(F("Expect")) && value == F("100-continue")) {
+    } else if (name.equalsIgnoreCase(T_EXPECT) && value == T_100_CONTINUE) {
       _expectingContinue = true;
-    } else if (name.equalsIgnoreCase(F("Authorization"))) {
-      if (value.length() > 5 && value.substring(0, 5).equalsIgnoreCase(F("Basic"))) {
+    } else if (name.equalsIgnoreCase(T_AUTH)) {
+      if (value.length() > 5 && value.substring(0, 5).equalsIgnoreCase(T_BASIC)) {
         _authorization = value.substring(6);
-      } else if (value.length() > 6 && value.substring(0, 6).equalsIgnoreCase(F("Digest"))) {
+      } else if (value.length() > 6 && value.substring(0, 6).equalsIgnoreCase(T_DIGEST)) {
         _isDigest = true;
         _authorization = value.substring(7);
       }
     } else {
-      if (name.equalsIgnoreCase(F("Upgrade")) && value.equalsIgnoreCase(F("websocket"))) {
+      if (name.equalsIgnoreCase(T_UPGRADE) && value.equalsIgnoreCase(T_WS)) {
         // WebSocket request can be uniquely identified by header: [Upgrade: websocket]
         _reqconntype = RCT_WS;
       } else {
-        if (name.equalsIgnoreCase(F("Accept")) && strContains(value, F("text/event-stream"), false)) {
+        if (name.equalsIgnoreCase(T_ACCEPT) && strContains(value, F(T_text_event_stream), false)) {
           // WebEvent request can be uniquely identified by header:  [Accept: text/event-stream]
           _reqconntype = RCT_EVENT;
         }
@@ -347,9 +348,9 @@ void AsyncWebServerRequest::_parsePlainPostChar(uint8_t data) {
   if (data && (char)data != '&')
     _temp += (char)data;
   if (!data || (char)data == '&' || _parsedLength == _contentLength) {
-    String name = F("body");
-    String value = _temp;
-    if (!_temp.startsWith(String('{')) && !_temp.startsWith(String('[')) && _temp.indexOf('=') > 0) {
+    String name(T_BODY);
+    String value(_temp);
+    if (!(_temp.charAt(0) == '{') && !(_temp.charAt(0) == '[') && _temp.indexOf('=') > 0) {
       name = _temp.substring(0, _temp.indexOf('='));
       value = _temp.substring(_temp.indexOf('=') + 1);
     }
@@ -430,17 +431,17 @@ void AsyncWebServerRequest::_parseMultipartPostByte(uint8_t data, bool last) {
       _temp += (char)data;
     if ((char)data == '\n') {
       if (_temp.length()) {
-        if (_temp.length() > 12 && _temp.substring(0, 12).equalsIgnoreCase(F("Content-Type"))) {
+        if (_temp.length() > 12 && _temp.substring(0, 12).equalsIgnoreCase(T_Content_Type)) {
           _itemType = _temp.substring(14);
           _itemIsFile = true;
-        } else if (_temp.length() > 19 && _temp.substring(0, 19).equalsIgnoreCase(F("Content-Disposition"))) {
+        } else if (_temp.length() > 19 && _temp.substring(0, 19).equalsIgnoreCase(T_Content_Disposition)) {
           _temp = _temp.substring(_temp.indexOf(';') + 2);
           while (_temp.indexOf(';') > 0) {
             String name = _temp.substring(0, _temp.indexOf('='));
             String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.indexOf(';') - 1);
-            if (name == F("name")) {
+            if (name == T_name) {
               _itemName = nameVal;
-            } else if (name == F("filename")) {
+            } else if (name == T_filename) {
               _itemFilename = nameVal;
               _itemIsFile = true;
             }
@@ -448,9 +449,9 @@ void AsyncWebServerRequest::_parseMultipartPostByte(uint8_t data, bool last) {
           }
           String name = _temp.substring(0, _temp.indexOf('='));
           String nameVal = _temp.substring(_temp.indexOf('=') + 2, _temp.length() - 1);
-          if (name == F("name")) {
+          if (name == T_name) {
             _itemName = nameVal;
-          } else if (name == F("filename")) {
+          } else if (name == T_filename) {
             _itemFilename = nameVal;
             _itemIsFile = true;
           }
@@ -590,7 +591,7 @@ void AsyncWebServerRequest::_parseLine() {
       _server->_attachHandler(this);
       _removeNotInterestingHeaders();
       if (_expectingContinue) {
-        String response = F("HTTP/1.1 100 Continue\r\n\r\n");
+        String response(T_HTTP_100_CONT);
         _client->write(response.c_str(), response.length());
       }
       // check handler for authentication
@@ -711,7 +712,7 @@ AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(int code, const Str
 }
 
 AsyncWebServerResponse* AsyncWebServerRequest::beginResponse(FS& fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback) {
-  if (fs.exists(path) || (!download && fs.exists(path + F(".gz"))))
+  if (fs.exists(path) || (!download && fs.exists(path + T__gz)))
     return new AsyncFileResponse(fs, path, contentType, download, callback);
   return NULL;
 }
@@ -770,7 +771,7 @@ void AsyncWebServerRequest::send(int code, const String& contentType, PGM_P cont
 }
 
 void AsyncWebServerRequest::send(FS& fs, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback) {
-  if (fs.exists(path) || (!download && fs.exists(path + F(".gz")))) {
+  if (fs.exists(path) || (!download && fs.exists(path + T__gz))) {
     send(beginResponse(fs, path, contentType, download, callback));
   } else
     send(404);
@@ -797,7 +798,7 @@ void AsyncWebServerRequest::sendChunked(const String& contentType, AwsResponseFi
 
 void AsyncWebServerRequest::redirect(const char* url) {
   AsyncWebServerResponse* response = beginResponse(302);
-  response->addHeader(F("Location"), url);
+  response->addHeader(T_LOCATION, url);
   send(response);
 }
 
@@ -838,16 +839,16 @@ bool AsyncWebServerRequest::authenticate(const char* hash) {
 void AsyncWebServerRequest::requestAuthentication(const char* realm, bool isDigest) {
   AsyncWebServerResponse* r = beginResponse(401);
   if (!isDigest && realm == NULL) {
-    r->addHeader(F("WWW-Authenticate"), F("Basic realm=\"Login Required\""));
+    r->addHeader(T_WWW_AUTH, T_BASIC_REALM_LOGIN_REQ);
   } else if (!isDigest) {
-    String header = F("Basic realm=\"");
+    String header(T_BASIC_REALM);
     header.concat(realm);
     header += '"';
-    r->addHeader(F("WWW-Authenticate"), header);
+    r->addHeader(T_WWW_AUTH, header);
   } else {
-    String header = F("Digest ");
+    String header(T_DIGEST_);
     header.concat(requestDigestAuthentication(realm));
-    r->addHeader(F("WWW-Authenticate"), header);
+    r->addHeader(T_WWW_AUTH, header);
   }
   send(r);
 }
@@ -939,82 +940,52 @@ String AsyncWebServerRequest::urlDecode(const String& text) const {
 }
 
 #ifndef ESP8266
-const char* AsyncWebServerRequest::methodToString() const {
+const char* AsyncWebServerRequest::methodToString() const
+#else
+const __FlashStringHelper* AsyncWebServerRequest::methodToString() const
+#endif
+{
   if (_method == HTTP_ANY)
-    return "ANY";
+    return T_ANY;
   if (_method & HTTP_GET)
-    return "GET";
+    return T_GET;
   if (_method & HTTP_POST)
-    return "POST";
+    return T_POST;
   if (_method & HTTP_DELETE)
-    return "DELETE";
+    return T_DELETE;
   if (_method & HTTP_PUT)
-    return "PUT";
+    return T_PUT;
   if (_method & HTTP_PATCH)
-    return "PATCH";
+    return T_PATCH;
   if (_method & HTTP_HEAD)
-    return "HEAD";
+    return T_HEAD;
   if (_method & HTTP_OPTIONS)
-    return "OPTIONS";
-  return "UNKNOWN";
+    return T_OPTIONS;
+  return T_UNKNOWN;
 }
 
-const char* AsyncWebServerRequest::requestedConnTypeToString() const {
+#ifndef ESP8266
+const char* AsyncWebServerRequest::requestedConnTypeToString() const
+#else
+const __FlashStringHelper* AsyncWebServerRequest::requestedConnTypeToString() const
+#endif
+{
+
   switch (_reqconntype) {
     case RCT_NOT_USED:
-      return "RCT_NOT_USED";
+      return T_RCT_NOT_USED;
     case RCT_DEFAULT:
-      return "RCT_DEFAULT";
+      return T_RCT_DEFAULT;
     case RCT_HTTP:
-      return "RCT_HTTP";
+      return T_RCT_HTTP;
     case RCT_WS:
-      return "RCT_WS";
+      return T_RCT_WS;
     case RCT_EVENT:
-      return "RCT_EVENT";
+      return T_RCT_EVENT;
     default:
-      return "ERROR";
+      return T_ERROR;
   }
 }
-#endif
-
-#ifdef ESP8266
-const __FlashStringHelper* AsyncWebServerRequest::methodToString() const {
-  if (_method == HTTP_ANY)
-    return F("ANY");
-  else if (_method & HTTP_GET)
-    return F("GET");
-  else if (_method & HTTP_POST)
-    return F("POST");
-  else if (_method & HTTP_DELETE)
-    return F("DELETE");
-  else if (_method & HTTP_PUT)
-    return F("PUT");
-  else if (_method & HTTP_PATCH)
-    return F("PATCH");
-  else if (_method & HTTP_HEAD)
-    return F("HEAD");
-  else if (_method & HTTP_OPTIONS)
-    return F("OPTIONS");
-  return F("UNKNOWN");
-}
-
-const __FlashStringHelper* AsyncWebServerRequest::requestedConnTypeToString() const {
-  switch (_reqconntype) {
-    case RCT_NOT_USED:
-      return F("RCT_NOT_USED");
-    case RCT_DEFAULT:
-      return F("RCT_DEFAULT");
-    case RCT_HTTP:
-      return F("RCT_HTTP");
-    case RCT_WS:
-      return F("RCT_WS");
-    case RCT_EVENT:
-      return F("RCT_EVENT");
-    default:
-      return F("ERROR");
-  }
-}
-#endif
 
 bool AsyncWebServerRequest::isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2, RequestedConnectionType erct3) {
   bool res = false;
diff --git a/src/WebResponses.cpp b/src/WebResponses.cpp
index 1fd41fa..c21a971 100644
--- a/src/WebResponses.cpp
+++ b/src/WebResponses.cpp
@@ -33,95 +33,98 @@ void* memchr(void* ptr, int ch, size_t count) {
 
 /*
  * Abstract Response
- * */
-const char* AsyncWebServerResponse::_responseCodeToString(int code) {
-  return reinterpret_cast<const char*>(responseCodeToString(code));
-}
+ *
+ */
 
-const __FlashStringHelper* AsyncWebServerResponse::responseCodeToString(int code) {
+#ifndef ESP8266
+const char* AsyncWebServerResponse::responseCodeToString(int code)
+#else
+const __FlashStringHelper* AsyncWebServerResponse::responseCodeToString(int code)
+#endif
+{
   switch (code) {
     case 100:
-      return F("Continue");
+      return T_HTTP_CODE_100;
     case 101:
-      return F("Switching Protocols");
+      return T_HTTP_CODE_101;
     case 200:
-      return F("OK");
+      return T_HTTP_CODE_200;
     case 201:
-      return F("Created");
+      return T_HTTP_CODE_201;
     case 202:
-      return F("Accepted");
+      return T_HTTP_CODE_202;
     case 203:
-      return F("Non-Authoritative Information");
+      return T_HTTP_CODE_203;
     case 204:
-      return F("No Content");
+      return T_HTTP_CODE_204;
     case 205:
-      return F("Reset Content");
+      return T_HTTP_CODE_205;
     case 206:
-      return F("Partial Content");
+      return T_HTTP_CODE_206;
     case 300:
-      return F("Multiple Choices");
+      return T_HTTP_CODE_300;
     case 301:
-      return F("Moved Permanently");
+      return T_HTTP_CODE_301;
     case 302:
-      return F("Found");
+      return T_HTTP_CODE_302;
     case 303:
-      return F("See Other");
+      return T_HTTP_CODE_303;
     case 304:
-      return F("Not Modified");
+      return T_HTTP_CODE_304;
     case 305:
-      return F("Use Proxy");
+      return T_HTTP_CODE_305;
     case 307:
-      return F("Temporary Redirect");
+      return T_HTTP_CODE_307;
     case 400:
-      return F("Bad Request");
+      return T_HTTP_CODE_400;
     case 401:
-      return F("Unauthorized");
+      return T_HTTP_CODE_401;
     case 402:
-      return F("Payment Required");
+      return T_HTTP_CODE_402;
     case 403:
-      return F("Forbidden");
+      return T_HTTP_CODE_403;
     case 404:
-      return F("Not Found");
+      return T_HTTP_CODE_404;
     case 405:
-      return F("Method Not Allowed");
+      return T_HTTP_CODE_405;
     case 406:
-      return F("Not Acceptable");
+      return T_HTTP_CODE_406;
     case 407:
-      return F("Proxy Authentication Required");
+      return T_HTTP_CODE_407;
     case 408:
-      return F("Request Time-out");
+      return T_HTTP_CODE_408;
     case 409:
-      return F("Conflict");
+      return T_HTTP_CODE_409;
     case 410:
-      return F("Gone");
+      return T_HTTP_CODE_410;
     case 411:
-      return F("Length Required");
+      return T_HTTP_CODE_411;
     case 412:
-      return F("Precondition Failed");
+      return T_HTTP_CODE_412;
     case 413:
-      return F("Request Entity Too Large");
+      return T_HTTP_CODE_413;
     case 414:
-      return F("Request-URI Too Large");
+      return T_HTTP_CODE_414;
     case 415:
-      return F("Unsupported Media Type");
+      return T_HTTP_CODE_415;
     case 416:
-      return F("Requested range not satisfiable");
+      return T_HTTP_CODE_416;
     case 417:
-      return F("Expectation Failed");
+      return T_HTTP_CODE_417;
     case 500:
-      return F("Internal Server Error");
+      return T_HTTP_CODE_500;
     case 501:
-      return F("Not Implemented");
+      return T_HTTP_CODE_501;
     case 502:
-      return F("Bad Gateway");
+      return T_HTTP_CODE_502;
     case 503:
-      return F("Service Unavailable");
+      return T_HTTP_CODE_503;
     case 504:
-      return F("Gateway Time-out");
+      return T_HTTP_CODE_504;
     case 505:
-      return F("HTTP Version not supported");
+      return T_HTTP_CODE_505;
     default:
-      return F("");
+      return T_HTTP_CODE_ANY;
   }
 }
 
@@ -155,15 +158,19 @@ void AsyncWebServerResponse::addHeader(const String& name, const String& value)
 
 String AsyncWebServerResponse::_assembleHead(uint8_t version) {
   if (version) {
-    addHeader(F("Accept-Ranges"), F("none"));
+    addHeader(T_Accept_Ranges, T_none);
     if (_chunked)
-      addHeader(F("Transfer-Encoding"), F("chunked"));
+      addHeader(Transfer_Encoding, T_chunked);
   }
-  String out = String();
+  String out;
   int bufSize = 300;
   char buf[bufSize];
 
-  snprintf_P(buf, bufSize, PSTR("HTTP/1.%d %d %s\r\n"), version, _code, _responseCodeToString(_code));
+#ifndef ESP8266
+  snprintf(buf, bufSize, "HTTP/1.%d %d %s\r\n", version, _code, responseCodeToString(_code));
+#else
+  snprintf_P(buf, bufSize, PSTR("HTTP/1.%d %d %s\r\n"), version, _code, String(responseCodeToString(_code)).c_str());
+#endif
   out.concat(buf);
 
   if (_sendContentLength) {
@@ -181,7 +188,7 @@ String AsyncWebServerResponse::_assembleHead(uint8_t version) {
   }
   _headers.clear();
 
-  out.concat(F("\r\n"));
+  out.concat(T_rn);
   _headLength = out.length();
   return out;
 }
@@ -211,9 +218,9 @@ AsyncBasicResponse::AsyncBasicResponse(int code, const String& contentType, cons
   if (_content.length()) {
     _contentLength = _content.length();
     if (!_contentType.length())
-      _contentType = F("text/plain");
+      _contentType = T_text_plain;
   }
-  addHeader(F("Connection"), F("close"));
+  addHeader(T_Connection, T_close);
 }
 
 void AsyncBasicResponse::_respond(AsyncWebServerRequest* request) {
@@ -291,7 +298,7 @@ AsyncAbstractResponse::AsyncAbstractResponse(AwsTemplateProcessor callback) : _c
 }
 
 void AsyncAbstractResponse::_respond(AsyncWebServerRequest* request) {
-  addHeader(F("Connection"), F("close"));
+  addHeader(T_Connection, T_close);
   _head = _assembleHead(request->version());
   _state = RESPONSE_HEADERS;
   _ack(request, 0, 0);
@@ -514,48 +521,48 @@ AsyncFileResponse::~AsyncFileResponse() {
 }
 
 void AsyncFileResponse::_setContentType(const String& path) {
-#if HAVE_EXTERN_GET_CONTENT_TYPE_FUNCTION
+#if HAVE_EXTERN_GET_Content_Type_FUNCTION
   extern const __FlashStringHelper* getContentType(const String& path);
   _contentType = getContentType(path);
 #else
-  if (path.endsWith(F(".html")))
-    _contentType = F("text/html");
-  else if (path.endsWith(F(".htm")))
-    _contentType = F("text/html");
-  else if (path.endsWith(F(".css")))
-    _contentType = F("text/css");
-  else if (path.endsWith(F(".json")))
-    _contentType = F("application/json");
-  else if (path.endsWith(F(".js")))
-    _contentType = F("application/javascript");
-  else if (path.endsWith(F(".png")))
-    _contentType = F("image/png");
-  else if (path.endsWith(F(".gif")))
-    _contentType = F("image/gif");
-  else if (path.endsWith(F(".jpg")))
-    _contentType = F("image/jpeg");
-  else if (path.endsWith(F(".ico")))
-    _contentType = F("image/x-icon");
-  else if (path.endsWith(F(".svg")))
-    _contentType = F("image/svg+xml");
-  else if (path.endsWith(F(".eot")))
-    _contentType = F("font/eot");
-  else if (path.endsWith(F(".woff")))
-    _contentType = F("font/woff");
-  else if (path.endsWith(F(".woff2")))
-    _contentType = F("font/woff2");
-  else if (path.endsWith(F(".ttf")))
-    _contentType = F("font/ttf");
-  else if (path.endsWith(F(".xml")))
-    _contentType = F("text/xml");
-  else if (path.endsWith(F(".pdf")))
-    _contentType = F("application/pdf");
-  else if (path.endsWith(F(".zip")))
-    _contentType = F("application/zip");
-  else if (path.endsWith(F(".gz")))
-    _contentType = F("application/x-gzip");
+  if (path.endsWith(T__html))
+    _contentType = T_text_html;
+  else if (path.endsWith(T__htm))
+    _contentType = T_text_html;
+  else if (path.endsWith(T__css))
+    _contentType = T_text_css;
+  else if (path.endsWith(T__json))
+    _contentType = T_application_json;
+  else if (path.endsWith(T__js))
+    _contentType = T_application_javascript;
+  else if (path.endsWith(T__png))
+    _contentType = T_image_png;
+  else if (path.endsWith(T__gif))
+    _contentType = T_image_gif;
+  else if (path.endsWith(T__jpg))
+    _contentType = T_image_jpeg;
+  else if (path.endsWith(T__ico))
+    _contentType = T_image_x_icon;
+  else if (path.endsWith(T__svg))
+    _contentType = T_image_svg_xml;
+  else if (path.endsWith(T__eot))
+    _contentType = T_font_eot;
+  else if (path.endsWith(T__woff))
+    _contentType = T_font_woff;
+  else if (path.endsWith(T__woff2))
+    _contentType = T_font_woff2;
+  else if (path.endsWith(T__ttf))
+    _contentType = T_font_ttf;
+  else if (path.endsWith(T__xml))
+    _contentType = T_text_xml;
+  else if (path.endsWith(T__pdf))
+    _contentType = T_application_pdf;
+  else if (path.endsWith(T__zip))
+    _contentType = T_application_zip;
+  else if (path.endsWith(T__gz))
+    _contentType = T_application_x_gzip;
   else
-    _contentType = F("text/plain");
+    _contentType = T_text_plain;
 #endif
 }
 
@@ -563,9 +570,9 @@ AsyncFileResponse::AsyncFileResponse(FS& fs, const String& path, const String& c
   _code = 200;
   _path = path;
 
-  if (!download && !fs.exists(_path) && fs.exists(_path + F(".gz"))) {
-    _path = _path + F(".gz");
-    addHeader(F("Content-Encoding"), F("gzip"));
+  if (!download && !fs.exists(_path) && fs.exists(_path + T__gz)) {
+    _path = _path + T__gz;
+    addHeader(T_Content_Encoding, T_gzip);
     _callback = nullptr; // Unable to process zipped templates
     _sendContentLength = true;
     _chunked = false;
@@ -590,15 +597,15 @@ AsyncFileResponse::AsyncFileResponse(FS& fs, const String& path, const String& c
     // set filename and force rendering
     snprintf_P(buf, sizeof(buf), PSTR("inline"));
   }
-  addHeader(F("Content-Disposition"), buf);
+  addHeader(T_Content_Disposition, buf);
 }
 
 AsyncFileResponse::AsyncFileResponse(File content, const String& path, const String& contentType, bool download, AwsTemplateProcessor callback) : AsyncAbstractResponse(callback) {
   _code = 200;
   _path = path;
 
-  if (!download && String(content.name()).endsWith(F(".gz")) && !path.endsWith(F(".gz"))) {
-    addHeader(F("Content-Encoding"), F("gzip"));
+  if (!download && String(content.name()).endsWith(T__gz) && !path.endsWith(T__gz)) {
+    addHeader(T_Content_Encoding, T_gzip);
     _callback = nullptr; // Unable to process gzipped templates
     _sendContentLength = true;
     _chunked = false;
@@ -621,7 +628,7 @@ AsyncFileResponse::AsyncFileResponse(File content, const String& path, const Str
   } else {
     snprintf_P(buf, sizeof(buf), PSTR("inline"));
   }
-  addHeader(F("Content-Disposition"), buf);
+  addHeader(T_Content_Disposition, buf);
 }
 
 size_t AsyncFileResponse::_fillBuffer(uint8_t* data, size_t len) {
diff --git a/src/WebServer.cpp b/src/WebServer.cpp
index 9d78e02..bc48b46 100644
--- a/src/WebServer.cpp
+++ b/src/WebServer.cpp
@@ -145,7 +145,7 @@ void AsyncWebServer::_attachHandler(AsyncWebServerRequest* request) {
     }
   }
 
-  request->addInterestingHeader(F("ANY"));
+  request->addInterestingHeader(T_ANY);
   request->setHandler(_catchAllHandler);
 }
 
diff --git a/src/literals.h b/src/literals.h
new file mode 100644
index 0000000..50bd03a
--- /dev/null
+++ b/src/literals.h
@@ -0,0 +1,338 @@
+#pragma once
+
+
+#ifndef ESP8622
+static constexpr const char* T_100_CONTINUE     = "100-continue";
+static constexpr const char* T_ACCEPT           = "Accept";
+static constexpr const char* T_Accept_Ranges    = "Accept-Ranges";
+static constexpr const char* T_app_xform_urlencoded = "application/x-www-form-urlencoded";
+static constexpr const char* T_AUTH             = "Authorization";
+static constexpr const char* T_BASIC            = "Basic";
+static constexpr const char* T_BASIC_REALM      = "Basic realm=\"";
+static constexpr const char* T_BASIC_REALM_LOGIN_REQ = "Basic realm=\"Login Required\"";
+static constexpr const char* T_BODY             = "body";
+static constexpr const char* T_Cache_Control    = "Cache-Control";
+static constexpr const char* T_chunked          = "chunked";
+static constexpr const char* T_close            = "close";
+static constexpr const char* T_Connection       = "Connection";
+static constexpr const char* T_Content_Disposition     = "Content-Disposition";
+static constexpr const char* T_Content_Encoding = "Content-Encoding";
+static constexpr const char* T_Content_Length   = "Content-Length";
+static constexpr const char* T_Content_Type     = "Content-Type";
+static constexpr const char* T_Cookie           = "Cookie";
+static constexpr const char* T_DIGEST           = "Digest";
+static constexpr const char* T_DIGEST_          = "Digest ";
+static constexpr const char* T_ETag             = "ETag";
+static constexpr const char* T_EXPECT           = "Expect";
+static constexpr const char* T_HTTP_1_0         = "HTTP/1.0";
+static constexpr const char* T_HTTP_100_CONT    = "HTTP/1.1 100 Continue\r\n\r\n";
+static constexpr const char* T_IMS              = "If-Modified-Since";
+static constexpr const char* T_INM              = "If-None-Match";
+static constexpr const char* T_keep_alive       = "keep-alive";
+static constexpr const char* T_Last_Event_ID    = "Last-Event-ID";
+static constexpr const char* T_Last_Modified    = "Last-Modified";
+static constexpr const char* T_LOCATION         = "Location";
+static constexpr const char* T_MULTIPART_       = "multipart/";
+static constexpr const char* T_no_cache         = "no-cache";
+static constexpr const char* T_none             = "none";
+static constexpr const char* T_UPGRADE          = "Upgrade";
+static constexpr const char* T_WS               = "websocket";
+static constexpr const char* T_WWW_AUTH         = "WWW-Authenticate";
+static constexpr const char* Transfer_Encoding  = "Transfer-Encoding";
+
+// HTTP Methods
+static constexpr const char* T_ANY      = "ANY";
+static constexpr const char* T_GET      = "GET";
+static constexpr const char* T_POST     = "POST";
+static constexpr const char* T_PUT      = "PUT";
+static constexpr const char* T_DELETE   = "DELETE";
+static constexpr const char* T_PATCH    = "PATCH";
+static constexpr const char* T_HEAD     = "HEAD";
+static constexpr const char* T_OPTIONS  = "OPTIONS";
+static constexpr const char* T_UNKNOWN  = "UNKNOWN";
+
+// Req content types
+static constexpr const char* T_RCT_NOT_USED = "RCT_NOT_USED";
+static constexpr const char* T_RCT_DEFAULT  = "RCT_DEFAULT";
+static constexpr const char* T_RCT_HTTP     = "RCT_HTTP";
+static constexpr const char* T_RCT_WS       = "RCT_WS";
+static constexpr const char* T_RCT_EVENT    = "RCT_EVENT";
+static constexpr const char* T_ERROR        = "ERROR";
+
+// extentions & MIME-Types
+static constexpr const char* T__css  = ".css";
+static constexpr const char* T__eot  = ".eot";
+static constexpr const char* T__gif  = ".gif";
+static constexpr const char* T__gz   = ".gz";
+static constexpr const char* T__htm  = ".htm";
+static constexpr const char* T__html = ".html";
+static constexpr const char* T__ico  = ".ico";
+static constexpr const char* T__jpg  = ".jpg";
+static constexpr const char* T__js   = ".js";
+static constexpr const char* T__json = ".json";
+static constexpr const char* T__pdf  = ".pdf";
+static constexpr const char* T__png  = ".png";
+static constexpr const char* T__svg  = ".svg";
+static constexpr const char* T__ttf  = ".ttf";
+static constexpr const char* T__woff = ".woff";
+static constexpr const char* T__woff2    = ".woff2";
+static constexpr const char* T__xml  = ".xml";
+static constexpr const char* T__zip  = ".zip";
+static constexpr const char* T_application_javascript   = "application/javascript";
+static constexpr const char* T_application_json         = "application/json";
+static constexpr const char* T_application_pdf          = "application/pdf";
+static constexpr const char* T_application_x_gzip       = "application/x-gzip";
+static constexpr const char* T_application_zip          = "application/zip";
+static constexpr const char* T_font_eot                 = "font/eot";
+static constexpr const char* T_font_ttf                 = "font/ttf";
+static constexpr const char* T_font_woff                = "font/woff";
+static constexpr const char* T_font_woff2               = "font/woff2";
+static constexpr const char* T_image_gif                = "image/gif";
+static constexpr const char* T_image_jpeg               = "image/jpeg";
+static constexpr const char* T_image_png                = "image/png";
+static constexpr const char* T_image_svg_xml            = "image/svg+xml";
+static constexpr const char* T_image_x_icon             = "image/x-icon";
+static constexpr const char* T_text_css                 = "text/css";
+static constexpr const char* T_text_event_stream        = "text/event-stream";
+static constexpr const char* T_text_html                = "text/html";
+static constexpr const char* T_text_plain               = "text/plain";
+static constexpr const char* T_text_xml                 = "text/xml";
+
+// Responce codes
+static constexpr const char* T_HTTP_CODE_100 = "Continue";
+static constexpr const char* T_HTTP_CODE_101 = "Switching Protocols";
+static constexpr const char* T_HTTP_CODE_200 = "OK";
+static constexpr const char* T_HTTP_CODE_201 = "Created";
+static constexpr const char* T_HTTP_CODE_202 = "Accepted";
+static constexpr const char* T_HTTP_CODE_203 = "Non-Authoritative Information";
+static constexpr const char* T_HTTP_CODE_204 = "No Content";
+static constexpr const char* T_HTTP_CODE_205 = "Reset Content";
+static constexpr const char* T_HTTP_CODE_206 = "Partial Content";
+static constexpr const char* T_HTTP_CODE_300 = "Multiple Choices";
+static constexpr const char* T_HTTP_CODE_301 = "Moved Permanently";
+static constexpr const char* T_HTTP_CODE_302 = "Found";
+static constexpr const char* T_HTTP_CODE_303 = "See Other";
+static constexpr const char* T_HTTP_CODE_304 = "Not Modified";
+static constexpr const char* T_HTTP_CODE_305 = "Use Proxy";
+static constexpr const char* T_HTTP_CODE_307 = "Temporary Redirect";
+static constexpr const char* T_HTTP_CODE_400 = "Bad Request";
+static constexpr const char* T_HTTP_CODE_401 = "Unauthorized";
+static constexpr const char* T_HTTP_CODE_402 = "Payment Required";
+static constexpr const char* T_HTTP_CODE_403 = "Forbidden";
+static constexpr const char* T_HTTP_CODE_404 = "Not Found";
+static constexpr const char* T_HTTP_CODE_405 = "Method Not Allowed";
+static constexpr const char* T_HTTP_CODE_406 = "Not Acceptable";
+static constexpr const char* T_HTTP_CODE_407 = "Proxy Authentication Required";
+static constexpr const char* T_HTTP_CODE_408 = "Request Time-out";
+static constexpr const char* T_HTTP_CODE_409 = "Conflict";
+static constexpr const char* T_HTTP_CODE_410 = "Gone";
+static constexpr const char* T_HTTP_CODE_411 = "Length Required";
+static constexpr const char* T_HTTP_CODE_412 = "Precondition Failed";
+static constexpr const char* T_HTTP_CODE_413 = "Request Entity Too Large";
+static constexpr const char* T_HTTP_CODE_414 = "Request-URI Too Large";
+static constexpr const char* T_HTTP_CODE_415 = "Unsupported Media Type";
+static constexpr const char* T_HTTP_CODE_416 = "Requested range not satisfiable";
+static constexpr const char* T_HTTP_CODE_417 = "Expectation Failed";
+static constexpr const char* T_HTTP_CODE_500 = "Internal Server Error";
+static constexpr const char* T_HTTP_CODE_501 = "Not Implemented";
+static constexpr const char* T_HTTP_CODE_502 = "Bad Gateway";
+static constexpr const char* T_HTTP_CODE_503 = "Service Unavailable";
+static constexpr const char* T_HTTP_CODE_504 = "Gateway Time-out";
+static constexpr const char* T_HTTP_CODE_505 = "HTTP Version not supported";
+static constexpr const char* T_HTTP_CODE_ANY = "Unknown code";
+
+// other
+static constexpr const char* T__opaque  = "\", opaque=\"";
+static constexpr const char* T_13       = "13";
+static constexpr const char* T_asyncesp = "asyncesp";
+static constexpr const char* T_auth_nonce = "\", qop=\"auth\", nonce=\"";
+static constexpr const char* T_cnonce   = "cnonce";
+static constexpr const char* T_data_    = "data: ";
+static constexpr const char* T_event_   = "event: ";
+static constexpr const char* T_filename = "filename";
+static constexpr const char* T_gzip     = "gzip";
+static constexpr const char* T_Host     = "Host";
+static constexpr const char* T_id__     = "id: ";
+static constexpr const char* T_name     = "name";
+static constexpr const char* T_nc       = "nc";
+static constexpr const char* T_nonce    = "nonce";
+static constexpr const char* T_opaque   = "opaque";
+static constexpr const char* T_qop      = "qop";
+static constexpr const char* T_realm    = "realm";
+static constexpr const char* T_realm__  = "realm=\"";
+static constexpr const char* T_response = "response";
+static constexpr const char* T_retry_   = "retry: ";
+static constexpr const char* T_rn       = "\r\n";
+static constexpr const char* T_rnrn     = "\r\n\r\n";
+static constexpr const char* T_uri      = "uri";
+static constexpr const char* T_username = "username";
+
+
+#else   // ESP8622
+
+static const char T_100_CONTINUE[] PROGMEM = "100-continue";
+static const char T_ACCEPT[] PROGMEM = "Accept";
+static const char T_Accept_Ranges[] PROGMEM = "Accept-Ranges";
+static const char T_app_xform_urlencoded[] PROGMEM = "application/x-www-form-urlencoded";
+static const char T_AUTH[] PROGMEM = "Authorization";
+static const char T_BASIC[] PROGMEM = "Basic";
+static const char T_BASIC_REALM[] PROGMEM = "Basic realm=\"";
+static const char T_BASIC_REALM_LOGIN_REQ[] PROGMEM = "Basic realm=\"Login Required\"";
+static const char T_BODY[] PROGMEM = "body";
+static const char T_Cache_Control[] PROGMEM = "Cache-Control";
+static const char T_chunked[] PROGMEM = "chunked";
+static const char T_close[] PROGMEM = "close";
+static const char T_Connection[] PROGMEM = "Connection";
+static const char T_Content_Disposition[] PROGMEM = "Content-Disposition";
+static const char T_Content_Encoding[] PROGMEM = "Content-Encoding";
+static const char T_Content_Length[] PROGMEM = "Content-Length";
+static const char T_Content_Type[] PROGMEM = "Content-Type";
+static const char T_Cookie[] PROGMEM = "Cookie";
+static const char T_DIGEST[] PROGMEM = "Digest";
+static const char T_DIGEST_[] PROGMEM = "Digest ";
+static const char T_ETag[] PROGMEM = "ETag";
+static const char T_EXPECT[] PROGMEM = "Expect";
+static const char T_HTTP_1_0[] PROGMEM = "HTTP/1.0";
+static const char T_HTTP_100_CONT[] PROGMEM = "HTTP/1.1 100 Continue\r\n\r\n";
+static const char T_IMS[] PROGMEM = "If-Modified-Since";
+static const char T_INM[] PROGMEM = "If-None-Match";
+static const char T_keep_alive[] PROGMEM = "keep-alive";
+static const char T_Last_Event_ID[] PROGMEM = "Last-Event-ID";
+static const char T_Last_Modified[] PROGMEM = "Last-Modified";
+static const char T_LOCATION[] PROGMEM = "Location";
+static const char T_MULTIPART_[] PROGMEM = "multipart/";
+static const char T_no_cache[] PROGMEM = "no-cache";
+static const char T_none[] PROGMEM = "none";
+static const char T_UPGRADE[] PROGMEM = "Upgrade";
+static const char T_WS[] PROGMEM = "websocket";
+static const char T_WWW_AUTH[] PROGMEM = "WWW-Authenticate";
+static const char Transfer_Encoding[] PROGMEM = "Transfer-Encoding";
+
+// HTTP Methods
+static const char T_ANY[] PROGMEM = "ANY";
+static const char T_GET[] PROGMEM = "GET";
+static const char T_POST[] PROGMEM = "POST";
+static const char T_PUT[] PROGMEM = "PUT";
+static const char T_DELETE[] PROGMEM = "DELETE";
+static const char T_PATCH[] PROGMEM = "PATCH";
+static const char T_HEAD[] PROGMEM = "HEAD";
+static const char T_OPTIONS[] PROGMEM = "OPTIONS";
+static const char T_UNKNOWN[] PROGMEM = "UNKNOWN";
+
+// Req content types
+static const char T_RCT_NOT_USED[] PROGMEM = "RCT_NOT_USED";
+static const char T_RCT_DEFAULT[] PROGMEM = "RCT_DEFAULT";
+static const char T_RCT_HTTP[] PROGMEM = "RCT_HTTP";
+static const char T_RCT_WS[] PROGMEM = "RCT_WS";
+static const char T_RCT_EVENT[] PROGMEM = "RCT_EVENT";
+static const char T_ERROR[] PROGMEM = "ERROR";
+
+// extentions & MIME-Types
+static const char T__css[] PROGMEM = ".css";
+static const char T__eot[] PROGMEM = ".eot";
+static const char T__gif[] PROGMEM = ".gif";
+static const char T__gz[] PROGMEM = ".gz";
+static const char T__htm[] PROGMEM = ".htm";
+static const char T__html[] PROGMEM = ".html";
+static const char T__ico[] PROGMEM = ".ico";
+static const char T__jpg[] PROGMEM = ".jpg";
+static const char T__js[] PROGMEM = ".js";
+static const char T__json[] PROGMEM = ".json";
+static const char T__pdf[] PROGMEM = ".pdf";
+static const char T__png[] PROGMEM = ".png";
+static const char T__svg[] PROGMEM = ".svg";
+static const char T__ttf[] PROGMEM = ".ttf";
+static const char T__woff[] PROGMEM = ".woff";
+static const char T__woff2[] PROGMEM = ".woff2";
+static const char T__xml[] PROGMEM = ".xml";
+static const char T__zip[] PROGMEM = ".zip";
+static const char T_application_javascript[] PROGMEM = "application/javascript";
+static const char T_application_json[] PROGMEM = "application/json";
+static const char T_application_pdf[] PROGMEM = "application/pdf";
+static const char T_application_x_gzip[] PROGMEM = "application/x-gzip";
+static const char T_application_zip[] PROGMEM = "application/zip";
+static const char T_font_eot[] PROGMEM = "font/eot";
+static const char T_font_ttf[] PROGMEM = "font/ttf";
+static const char T_font_woff[] PROGMEM = "font/woff";
+static const char T_font_woff2[] PROGMEM = "font/woff2";
+static const char T_image_gif[] PROGMEM = "image/gif";
+static const char T_image_jpeg[] PROGMEM = "image/jpeg";
+static const char T_image_png[] PROGMEM = "image/png";
+static const char T_image_svg_xml[] PROGMEM = "image/svg+xml";
+static const char T_image_x_icon[] PROGMEM = "image/x-icon";
+static const char T_text_css[] PROGMEM = "text/css";
+static const char T_text_event_stream[] PROGMEM = "text/event-stream";
+static const char T_text_html[] PROGMEM = "text/html";
+static const char T_text_plain[] PROGMEM = "text/plain";
+static const char T_text_xml[] PROGMEM = "text/xml";
+
+// Responce codes
+static const char T_HTTP_CODE_100[] PROGMEM = "Continue";
+static const char T_HTTP_CODE_101[] PROGMEM = "Switching Protocols";
+static const char T_HTTP_CODE_200[] PROGMEM = "OK";
+static const char T_HTTP_CODE_201[] PROGMEM = "Created";
+static const char T_HTTP_CODE_202[] PROGMEM = "Accepted";
+static const char T_HTTP_CODE_203[] PROGMEM = "Non-Authoritative Information";
+static const char T_HTTP_CODE_204[] PROGMEM = "No Content";
+static const char T_HTTP_CODE_205[] PROGMEM = "Reset Content";
+static const char T_HTTP_CODE_206[] PROGMEM = "Partial Content";
+static const char T_HTTP_CODE_300[] PROGMEM = "Multiple Choices";
+static const char T_HTTP_CODE_301[] PROGMEM = "Moved Permanently";
+static const char T_HTTP_CODE_302[] PROGMEM = "Found";
+static const char T_HTTP_CODE_303[] PROGMEM = "See Other";
+static const char T_HTTP_CODE_304[] PROGMEM = "Not Modified";
+static const char T_HTTP_CODE_305[] PROGMEM = "Use Proxy";
+static const char T_HTTP_CODE_307[] PROGMEM = "Temporary Redirect";
+static const char T_HTTP_CODE_400[] PROGMEM = "Bad Request";
+static const char T_HTTP_CODE_401[] PROGMEM = "Unauthorized";
+static const char T_HTTP_CODE_402[] PROGMEM = "Payment Required";
+static const char T_HTTP_CODE_403[] PROGMEM = "Forbidden";
+static const char T_HTTP_CODE_404[] PROGMEM = "Not Found";
+static const char T_HTTP_CODE_405[] PROGMEM = "Method Not Allowed";
+static const char T_HTTP_CODE_406[] PROGMEM = "Not Acceptable";
+static const char T_HTTP_CODE_407[] PROGMEM = "Proxy Authentication Required";
+static const char T_HTTP_CODE_408[] PROGMEM = "Request Time-out";
+static const char T_HTTP_CODE_409[] PROGMEM = "Conflict";
+static const char T_HTTP_CODE_410[] PROGMEM = "Gone";
+static const char T_HTTP_CODE_411[] PROGMEM = "Length Required";
+static const char T_HTTP_CODE_412[] PROGMEM = "Precondition Failed";
+static const char T_HTTP_CODE_413[] PROGMEM = "Request Entity Too Large";
+static const char T_HTTP_CODE_414[] PROGMEM = "Request-URI Too Large";
+static const char T_HTTP_CODE_415[] PROGMEM = "Unsupported Media Type";
+static const char T_HTTP_CODE_416[] PROGMEM = "Requested range not satisfiable";
+static const char T_HTTP_CODE_417[] PROGMEM = "Expectation Failed";
+static const char T_HTTP_CODE_500[] PROGMEM = "Internal Server Error";
+static const char T_HTTP_CODE_501[] PROGMEM = "Not Implemented";
+static const char T_HTTP_CODE_502[] PROGMEM = "Bad Gateway";
+static const char T_HTTP_CODE_503[] PROGMEM = "Service Unavailable";
+static const char T_HTTP_CODE_504[] PROGMEM = "Gateway Time-out";
+static const char T_HTTP_CODE_505[] PROGMEM = "HTTP Version not supported";
+static const char T_HTTP_CODE_ANY[] PROGMEM = "Unknown code";
+
+// other
+static const char T__opaque[] PROGMEM = "\", opaque=\"";
+static const char T_13[] PROGMEM = "13";
+static const char T_asyncesp[] PROGMEM = "asyncesp";
+static const char T_auth_nonce[] PROGMEM = "\", qop=\"auth\", nonce=\"";
+static const char T_cnonce[] PROGMEM = "cnonce";
+static const char T_data_[] PROGMEM = "data: ";
+static const char T_event_[] PROGMEM = "event: ";
+static const char T_filename[] PROGMEM = "filename";
+static const char T_gzip[] PROGMEM = "gzip";
+static const char T_Host[] PROGMEM = "Host";
+static const char T_id__[] PROGMEM = "id: ";
+static const char T_name[] PROGMEM = "name";
+static const char T_nc[] PROGMEM = "nc";
+static const char T_nonce[] PROGMEM = "nonce";
+static const char T_opaque[] PROGMEM = "opaque";
+static const char T_qop[] PROGMEM = "qop";
+static const char T_realm[] PROGMEM = "realm";
+static const char T_realm__[] PROGMEM = "realm=\"";
+static const char T_response[] PROGMEM = "response";
+static const char T_retry_[] PROGMEM = "retry: ";
+static const char T_rn[] PROGMEM = "\r\n";
+static const char T_rnrn[] PROGMEM = "\r\n\r\n";
+static const char T_uri[] PROGMEM = "uri";
+static const char T_username[] PROGMEM = "username";
+
+#endif  // ESP8622