+
+ {{markdown $markdownFile.Body}}
+
+
+
+
+ Caddy 2 is beta software. It is ready for production, but some things will change between releases; check the release notes before upgrading.
+
+ ]
+```
+
+- **<to>** is the target location. Becomes the response's Location header.
+- **<code>** is the HTTP status code to use for the redirect. Can be:
+ - A positive integer in the 3xx range
+ - `temporary` for a temporary redirect (302; default)
+ - `permanent` for a permanent redirect (301)
+ - `html` to use an HTML document to perform the redirect (useful for redirecting browsers but not API clients)
+
+
+
+## Examples
+
+Redirect all requests to `https://example.com`:
+
+```
+redir https://example.com
+```
+
+Same, but preserve the existing URI:
+
+```
+redir https://example.com{uri}
+```
+
+Same, but permanent:
+
+```
+redir https://example.com{uri} permanent
+```
\ No newline at end of file
diff --git a/src/docs/markdown/caddyfile/directives/request_header.md b/src/docs/markdown/caddyfile/directives/request_header.md
new file mode 100644
index 00000000..4956e501
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/request_header.md
@@ -0,0 +1,28 @@
+---
+title: request_header (Caddyfile directive)
+---
+
+# request_header
+
+Manipulates HTTP header fields on the request. It can set, add, and delete header values, or perform replacements using regular expressions.
+
+
+## Syntax
+
+```
+request_header [] [[+|-] [|] []]
+```
+
+- **<field>** is the name of the header field. By default, will overwrite any existing field of the same name. Prefix with `+` to add the field instead of replace, or prefix with `-` to remove the field.
+- **<value>** is the header field value, if adding or setting a field.
+- **<find>** is the substring or regular expression to search for.
+- **<replace>** is the replacement value; required if performing a search-and-replace.
+
+
+## Examples
+
+Remove the Referer header from the request:
+
+```
+request_header -Referer
+```
diff --git a/src/docs/markdown/caddyfile/directives/respond.md b/src/docs/markdown/caddyfile/directives/respond.md
new file mode 100644
index 00000000..3d92f09b
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/respond.md
@@ -0,0 +1,47 @@
+---
+title: respond (Caddyfile directive)
+---
+
+# respond
+
+Writes a hard-coded/static response to the client.
+
+
+## Syntax
+
+```
+respond [] | [] {
+ body
+ close
+}
+```
+
+- **<status>** is the HTTP status code to write. Default 200.
+- **<body>** is the response body to write.
+- **body** is an alternate way to provide a body; convenient if it is multiple lines.
+- **close** will close the client's connection to the server after writing the response.
+
+To clarify, the first non-matcher argument can be either a 3-digit status code or a response body string. If it is a body, the next argument can be the status code.
+
+
+## Examples
+
+Write a 200 status with an empty body to all health checks:
+
+```
+respond /health-check 200
+```
+
+Write a simple response body to all requests:
+
+```
+respond "Hello, world!"
+```
+
+Write an error response and close the connection:
+
+```
+respond /secret/* "Access denied" 403 {
+ close
+}
+```
diff --git a/src/docs/markdown/caddyfile/directives/reverse_proxy.md b/src/docs/markdown/caddyfile/directives/reverse_proxy.md
new file mode 100644
index 00000000..6b076240
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/reverse_proxy.md
@@ -0,0 +1,165 @@
+---
+title: reverse_proxy (Caddyfile directive)
+---
+
+# reverse_proxy
+
+Proxies requests to one or more backends with configurable transport, load balancing, health checking, header manipulation, and buffering options.
+
+
+## Syntax
+
+```
+reverse_proxy [] [] {
+ # backends
+ to
+ ...
+
+ # load balancing
+ lb_policy []
+ lb_try_duration
+ lb_try_interval
+
+ # active health checking
+ health_path
+ health_port
+ health_interval
+ health_timeout
+ health_status
+ health_body
+
+ # passive health checking
+ fail_duration
+ max_fails
+ unhealthy_status
+ unhealthy_latency
+ unhealthy_request_count
+
+ # streaming
+ flush_interval
+
+ # header manipulation
+ header_up [+|-] [ []]
+ header_down [+|-] [ []]
+
+ # round trip
+ transport {
+ ...
+ }
+}
+```
+
+- **<upstreams...>** is a list of upstreams (backends) to which to proxy.
+- **to** is an alternate way to specify the list of upstreams, one (or more) per line.
+
+**Load balancing** is used whenever more than one upstream is defined.
+
+- **lb_policy** is the name of the load balancing policy, along with any options. Default: `random`. Can be:
+ - `first` - choose first available upstream
+ - `header` - map request header to sticky upstream
+ - `ip_hash` - map client IP to sticky upstream
+ - `least_conn` - choose upstream with fewest number of current requests
+ - `random` - randomly choose an upstream
+ - `random_choose ` - selects two or more upstreams randomly, then chooses one with least load (`n` is usually 2)
+ - `round_robin` - iterate each upstream in turn
+ - `uri_hash` - map URI to sticky upstream
+
+- **lb_try_duration** is a [duration value](/docs/conventions#durations) that defines how long to try selecting available backends for each request if the next available host is down. By default, this retry is disabled. Clients will wait for up to this long while the load balancer tries to find an available upstream host.
+- **lb_try_interval** is a [duration value](/docs/conventions#durations) that defines how long to wait between selecting the next host from the pool. Default is `250ms`. Only relevant when a request to an upstream host fails. Be aware that setting this to 0 with a non-zero `lb_try_duration` can cause the CPU to spin if all backends are down and latency is very low.
+
+**Active health checks** perform health checking in the background on a timer:
+
+- **health_path** is the URI path for active health checks.
+- **health_port** is the port to use for active health checks, if different from the upstream's port.
+- **health_interval** is a [duration value](/docs/conventions#durations) that defines how often to perform active health checks.
+- **health_timeout** is a [duration value](/docs/conventions#durations) that defines how long to wait for a reply before marking the backend as down.
+- **health_status** is the HTTP status code to expect from a healthy backend. Can be a 3-digit status code or a status code class ending in `xx`, for example: `200` (default) or `2xx`.
+- **health_body** is a substring or regular expression to match on the response body of an active health check. If the backend does not return a matching body, it will be marked as down.
+
+**Passive health checks** happen inline with actual proxied requests:
+
+- **fail_duration** is a [duration value](/docs/conventions#durations) that defines how long to remember a failed request. A duration > 0 enables passive health checking.
+- **max_fails** is the maximum number of failed requests within fail_timeout that are needed before considering a backend to be down; must be >= 1; default is 1.
+- **unhealthy_status** counts a request as failed if the response comes back with one of these status codes. Can be a 3-digit status code or a status code class ending in `xx`, for example: `404` or `5xx`.
+- **unhealthy_latency** is a [duration value](/docs/conventions#durations) that counts a request as failed if it takes this long to get a response.
+- **unhealthy_request_count** is the permissible number of simultaneous requests to a backend before marking it as down.
+
+The proxy **buffers responses** by default for wire efficiency:
+
+- **flush_interval** is a [duration value](/docs/conventions#durations) that defines how often Caddy should flush the buffered response body to the client. Set to -1 to disable buffering.
+
+It can also **manipulate headers** between itself and the backend:
+
+- **header_up** Sets, adds, removes, or performs a replacement in a request header going upstream to the backend.
+- **header_down** Sets, adds, removes, or performs a replacement in a response header coming downstream from the backend.
+
+Caddy's proxy **transport** is pluggable:
+
+- **transport** defines how to communicate with the backend. Default is `http`.
+
+The `http` and `http_ntlm` transports can look like this:
+
+```
+transport http {
+ read_buffer
+ write_buffer
+ dial_timeout
+ tls
+ tls_client_auth
+ tls_insecure_skip_verify
+ tls_timeout
+ tls_trusted_ca_certs
+ keepalive [off|]
+ keepalive_idle_conns
+}
+```
+
+The `http_ntlm` transport is identical to the `http` transport, but the HTTP version is always 1.1, and Keep-Alive is always disabled.
+
+- **read_buffer** is the size of the read buffer in bytes.
+- **write_buffer** is the size of the write buffer in bytes.
+- **dial_timeout** is how long to wait when connecting to the upstream socket.
+- **tls** uses HTTPS with the backend.
+- **tls_client_auth** specifies a certificate and key file to present for TLS client authentication with the backend.
+- **tls_insecure_skip_verify** turns off security. _Do not use in production._
+- **tls_timeout** is a [duration value](/docs/conventions#durations) that specifies how long to wait for the TLS handshake to complete.
+- **tls_trusted_ca_certs** is a list of PEM files that specify CA public keys to trust when connecting to the backend.
+- **keepalive** is either `off` or a [duration value](/docs/conventions#durations) that specifies how long to keep connections open.
+- **keepalive_idle_conns** defines the maximum number of connections to keep alive.
+
+The `fastcgi` transport can look like this:
+
+```
+transport fastcgi {
+ root
+ split
+ env
+}
+```
+
+- **root** is the root of the site. Default: `{http.vars.root}` or current working directory.
+- **split** is where to split the path to get PATH_INFO at the end of the URI.
+- **env** sets custom environment variables.
+
+
+## Examples
+
+Reverse proxy all requests to a local backend:
+
+```
+reverse_proxy localhost:9005
+```
+
+Load-balance all requests between 3 backends:
+
+```
+reverse_proxy node1:80 node2:80 node3:80
+```
+
+Same, but only requests within `/api`, and with header affinity:
+
+```
+reverse_proxy /api/* node1:80 node2:80 node3:80 {
+ lb_policy header X-My-Header
+}
+```
diff --git a/src/docs/markdown/caddyfile/directives/rewrite.md b/src/docs/markdown/caddyfile/directives/rewrite.md
new file mode 100644
index 00000000..3989f5c6
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/rewrite.md
@@ -0,0 +1,55 @@
+---
+title: rewrite (Caddyfile directive)
+---
+
+# rewrite
+
+Rewrites the request internally. A rewrite changes some or all of the request URI.
+
+The `rewrite` directive implies the intent to accept the request, but with modifications. It is mutually exclusive to other `rewrite` directives in the same block, so it is safe to define rewrites that would otherwise cascade into each other; only the first matching rewrite will be executed.
+
+
+## Syntax
+
+```
+rewrite []
+```
+
+- **** is the URI to set on the request. Only designated parts will be replaced. The URI path is any substring that comes before `?`. If `?` is omitted, then the whole token is considered to be the path.
+
+
+## Examples
+
+Rewrite all requests to `foo.html`, leaving any query string unchanged:
+
+```
+rewrite * /foo.html
+```
+
+Replace the query string on API requests with `a=b`, leaving the path unchanged:
+
+```
+rewrite /api/* ?a=b
+```
+
+Preserve the existing query string and add a key-value pair:
+
+```
+rewrite /api/* ?{query}&a=b
+```
+
+Change both the path and query string, preserving the original query string while adding the original path as the `p` parameter:
+
+```
+rewrite * /index.php?{query}&p={path}
+```
+
+
+## Similar directives
+
+There are other directives that perform rewrites, but imply a different intent or do the rewrite without a complete replacement of the URI:
+
+- [`strip_prefix`](/docs/caddyfile/directives/strip_prefix) strips a prefix from the request path.
+- [`strip_suffix`](/docs/caddyfile/directives/strip_suffix) strips a suffix from the request path.
+- [`uri_replace`](/docs/caddyfile/directives/uri_replace) performs a substring replacement on the request path.
+- [`try_files`](/docs/caddyfile/directives/try_files) rewrites the request based on the existence of files.
\ No newline at end of file
diff --git a/src/docs/markdown/caddyfile/directives/root.md b/src/docs/markdown/caddyfile/directives/root.md
new file mode 100644
index 00000000..e6f1cc4f
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/root.md
@@ -0,0 +1,44 @@
+---
+title: root (Caddyfile directive)
+---
+
+# root
+
+Sets the root path of the site, used by various matchers and directives that access the file system. If unset, the default site root is the current working directory.
+
+Specifically, this directive sets the `{http.vars.root}` placeholder.
+
+
+## Syntax
+
+```
+root []
+```
+
+- **<path>** is the path to use for the site root.
+
+Note that a matcher token is usually required since the first argument is a path, which could look like a path matcher.
+
+## Examples
+
+Set the site root to `/home/user/public_html` for all requests:
+
+```
+root * /home/user/public_html
+```
+
+(A [wildcard matcher](/docs/caddyfile/concepts#wildcard-matcher) is required in this case because the first argument is ambiguous with a [path matcher](/docs/caddyfile/concepts#path-matcher).)
+
+Set the site root to `public_html` (relative to current working directory) for all requests:
+
+```
+root public_html
+```
+
+(No matcher token is required here because our site root is a relative path, so it does not start with a forward slash and thus is not ambiguous.)
+
+Set the site root only for requests in `/foo`:
+
+```
+root /foo/* /home/user/public_html/foo
+```
diff --git a/src/docs/markdown/caddyfile/directives/route.md b/src/docs/markdown/caddyfile/directives/route.md
new file mode 100644
index 00000000..d26507a8
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/route.md
@@ -0,0 +1,76 @@
+---
+title: route (Caddyfile directive)
+---
+
+# route
+
+Evaluates a group of directives literally and as a single unit.
+
+Directives contained in a route block will not be reordered internally. Only HTTP handler directives (directives which add handlers or middleware to the chain) can be used in a route block.
+
+This directive is a special case in that its subdirectives are also regular directives.
+
+
+## Syntax
+
+```
+route [] {
+
+}
+```
+
+- **** is a list of directives or directive blocks, one per line, just like outside of a route block; except these directives will not be reordered. Only HTTP handler directives can be used.
+
+
+
+## Utility
+
+The `route` directive is helpful in certain advanced use cases or edge cases to take absolute control over parts of the HTTP handler chain.
+
+Because the order of HTTP middleware evaluation is significant, the Caddyfile will normally reorder directives after parsing to make the Caddyfile easier to use; you don't have to worry about what order you type things.
+
+While the built-in order is compatible with most sites, sometimes you need to take manual control over the order, either for the whole site or just a part of it. That's what the `route` directive is for.
+
+To illustrate, consider the case of two terminating handlers: `redir` and `file_server`. Both write the response to the client and do not call the next handler in the chain, so only one of these will be executed for a certain request. Which comes first? Normally, `redir` is executed before `file_server` because usually you would want to issue a redirect only in specific cases and serve files in the general case.
+
+However, there may be occasions where the second directive (`redir`) has a more specific matcher than the second (`file_server`). In other words, you want to redirect in the general case, and serve only a specific file.
+
+So you might try a Caddyfile like this (but this will not work as expected!):
+
+```
+example.com
+
+file_server /specific.html
+redir https://anothersite.com{uri}
+```
+
+The problem is that, internally, `redir` comes before `file_server`, but in this case the matcher for `redir` is a superset of the matcher for `file_server` (`*` is a superset of `/specific.html`).
+
+Fortunately, the solution is easy: just wrap those two directives in a `route` block:
+
+```
+example.com
+
+route {
+ file_server /specific.html
+ redir https://anothersite.com{uri}
+}
+```
+
+
+
+And now `file_server` will be chained in before `redir` because the order is taken literally.
+
+
+## Examples
+
+Strip `api/` prefix from request path just before proxying all API requests to a backend:
+
+```
+route /api/* {
+ strip_prefix api/
+ reverse_proxy localhost:9000
+}
+```
diff --git a/src/docs/markdown/caddyfile/directives/strip_prefix.md b/src/docs/markdown/caddyfile/directives/strip_prefix.md
new file mode 100644
index 00000000..1d4aaf37
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/strip_prefix.md
@@ -0,0 +1,31 @@
+---
+title: strip_prefix (Caddyfile directive)
+---
+
+# strip_prefix
+
+Strips a given prefix from the request URI's path. If a matched request does not have the given path prefix, this directive is a no-op.
+
+
+## Syntax
+
+```
+strip_prefix []
+```
+
+- **<prefix>** is the prefix to strip from the request path. This value may omit the leading forward slash `/` and it will be assumed.
+
+
+## Examples
+
+Strip `api/` from the beginning of all request paths:
+
+```
+strip_prefix api/
+```
+
+An alternate way to describe the same thing, using a matcher:
+
+```
+strip_prefix /api/* /api
+```
\ No newline at end of file
diff --git a/src/docs/markdown/caddyfile/directives/strip_suffix.md b/src/docs/markdown/caddyfile/directives/strip_suffix.md
new file mode 100644
index 00000000..72b7693d
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/strip_suffix.md
@@ -0,0 +1,25 @@
+---
+title: strip_suffix (Caddyfile directive)
+---
+
+# strip_suffix
+
+Strips a given suffix from the request URI's path. If a matched request does not have the given path suffix, this directive is a no-op.
+
+
+## Syntax
+
+```
+strip_suffix []
+```
+
+- **<suffix>** is the suffix to strip from the request path.
+
+
+## Examples
+
+Strip `.html` from the end of all request paths:
+
+```
+strip_suffix .html
+```
diff --git a/src/docs/markdown/caddyfile/directives/templates.md b/src/docs/markdown/caddyfile/directives/templates.md
new file mode 100644
index 00000000..70499d8f
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/templates.md
@@ -0,0 +1,32 @@
+---
+title: templates (Caddyfile directive)
+---
+
+# templates
+
+Executes the response body as a [template](/docs/json/apps/http/servers/errors/routes/handle/templates/) document. Templates provide functional primitives for making simple dynamic pages. Features include HTTP subrequests, HTML file includes, Markdown rendering, JSON parsing, basic data structures, randomness, time, and more.
+
+
+## Syntax
+
+```
+templates [] {
+ mime
+ between
+ root
+}
+```
+
+- **mime** are the MIME types the templates middleware will act on; any responses that do not have a qualifying Content-Type will not be evaluated as templates. Default: `text/html text/plain`.
+- **between** are the opening and closing delimiters for template actions. Default: `{{printf "{{ }}"}}`. You can change them if they interfere with the rest of your document.
+- **root** is the site root, when using functions that access the file system.
+
+
+## Examples
+
+Enable templates on all requests:
+
+```
+templates
+```
+
diff --git a/src/docs/markdown/caddyfile/directives/tls.md b/src/docs/markdown/caddyfile/directives/tls.md
new file mode 100644
index 00000000..e0db1a96
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/tls.md
@@ -0,0 +1,68 @@
+---
+title: tls (Caddyfile directive)
+---
+
+# tls
+
+Configures TLS for the site.
+
+**Caddy's default TLS settings are secure. Only change these settings if you have a good reason and understand the implications.** The most common use of this directive will be to specify an ACME account email address, change the ACME CA endpoint, or to provide your own certificates.
+
+Compatibility note: Due to its sensitive nature as a security protocol, deliberate adjustments to TLS defaults may be made in new minor or patch releases. Old or broken TLS versions, ciphers, features, etc. may be removed at any time. If your deployment is extremely sensitive to changes, you should explicitly specify those values which must remain constant, and be vigilant about upgrades. In almost every case, we recommend using the default settings.
+
+
+## Syntax
+
+```
+tls |[ ] {
+ protocols []
+ ciphers
+ curves
+ alpn
+ load
+ ca
+}
+```
+
+- **<email>** is the email address to use for the ACME account managing the site's certificates.
+- **<cert_file>** and **<key_file>** are the paths to the certificate and private key PEM files. Specifying just one is invalid; specifying both will disable automatic HTTPS.
+- **protocols** specifies the minimum and maximum protocol versions. Default min: `tls1.2`. Default max: `tls1.3`
+- **ciphers** specifies the list of cipher suites in descending preference order. Note that cipher suites are not customizable with TLS 1.3. Supported values are:
+ - TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
+ - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
+ - TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
+ - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
+ - TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256
+ - TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
+ - TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA
+ - TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256
+ - TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA
+ - TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA
+ - TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256
+ - TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA
+ - TLS_RSA_WITH_AES_128_GCM_SHA256
+ - TLS_RSA_WITH_AES_256_GCM_SHA384
+ - TLS_RSA_WITH_AES_256_CBC_SHA
+ - TLS_RSA_WITH_AES_128_CBC_SHA256
+ - TLS_RSA_WITH_AES_128_CBC_SHA
+ - TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA
+ - TLS_RSA_WITH_3DES_EDE_CBC_SHA
+- **curves** specifies the list of EC curves to support. Supported values are:
+ - x25519
+ - p256
+ - p384
+ - p521
+- **alpn** is the list of values to advertise in the ALPN extension of the TLS handshake.
+- **load** specifies a list of folders from which to load PEM files that are certificate+key bundles.
+- **ca** changes the ACME CA endpoint. This is most often used to use [Let's Encrypt's staging endpoint](https://letsencrypt.org/docs/staging-environment/) or an internal ACME server. (To change this value for the whole Caddyfile, use the `acme_ca` [global option](/docs/caddyfile/options) instead.)
+
+
+
+## Examples
+
+Use a custom certificate and key:
+
+```
+tls cert.pem key.pem
+```
+
diff --git a/src/docs/markdown/caddyfile/directives/try_files.md b/src/docs/markdown/caddyfile/directives/try_files.md
new file mode 100644
index 00000000..b23d0aeb
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/try_files.md
@@ -0,0 +1,51 @@
+---
+title: try_files (Caddyfile directive)
+---
+
+# try_files
+
+Rewrites the request URI path to the first of the listed files which exists in the site root. If no files match, no rewrite is performed.
+
+
+## Syntax
+
+```
+try_files
+```
+
+- **** is the list of files to try. The URI will be rewritten to the first one that exists. To match directories, append a trailing forward slash `/` to the path. All file paths are relative to the site [root](/docs/caddyfile/directives/root). Each argument may also contain a query string, in which case the query string will also be changed if it matches that particular file.
+
+
+## Expanded form
+
+The `try_files` directive is basically a shortcut for:
+
+```
+@try_files {
+ file {
+ try_files
+ }
+}
+rewrite @try_files {http.matchers.file.relative}
+```
+
+
+## Examples
+
+If the request does not match any static files, rewrite to an index/router file:
+
+```
+try_files {path} /index.php
+```
+
+Same, but adding the original path to the query string:
+
+```
+try_files {path} /index.php?{query}&p={path}
+```
+
+Same, but also match directories:
+
+```
+try_files {path} {path}/ /index.php?{query}&p={path}
+```
diff --git a/src/docs/markdown/caddyfile/directives/uri_replace.md b/src/docs/markdown/caddyfile/directives/uri_replace.md
new file mode 100644
index 00000000..139b6010
--- /dev/null
+++ b/src/docs/markdown/caddyfile/directives/uri_replace.md
@@ -0,0 +1,27 @@
+---
+title: uri_replace (Caddyfile directive)
+---
+
+# uri_replace
+
+Performs a substring or regular expression replacement in the request URI.
+
+
+## Syntax
+
+```
+uri_replace [] []
+```
+
+- **<find>** is the substring or regular expression to search for.
+- **<replace>** is the replacement value.
+- **<limit>** is an optional limit to the number of replacements.
+
+
+## Examples
+
+Replace "/docs/" with "/v1/docs/" in any request URI:
+
+```
+uri_replace * /docs/ /v1/docs/
+```
diff --git a/src/docs/markdown/caddyfile/options.md b/src/docs/markdown/caddyfile/options.md
new file mode 100644
index 00000000..98ed50d8
--- /dev/null
+++ b/src/docs/markdown/caddyfile/options.md
@@ -0,0 +1,43 @@
+---
+title: Global options (Caddyfile)
+---
+
+# Global options
+
+The Caddyfile has a way for you to specify options that apply globally. Some options act as default values, while others customize the behavior of the Caddyfile [adapter](/docs/config-adapters).
+
+The very top of your Caddyfile can be a **global options block**. This is a block that has no keys:
+
+```
+{
+ ...
+}
+```
+
+There can only be one at most, and it must be the first block of the Caddyfile.
+
+Possible options are:
+
+```
+{
+ http_port
+ https_port
+ order first|last|[before|after ]
+ storage {
+
+ }
+ experimental_http3
+ acme_ca
+ email
+ admin
+}
+```
+
+- **http_port** is the port for the server to use for HTTP. For internal use only; does not change the HTTP port for clients. Default: 80
+- **https_port** is the port for the server to use for HTTPS. For internal use only; does not change the HTTPS port for clients. Default: 443
+- **order** sets or changes the standard order of HTTP handler directive(s). Can set directives to be `first` or `last`, or `before` or `after` another directive.
+- **storage** configures Caddy's storage mechanism. Default: `file_system`
+- **experimental_http3** enables experimental draft HTTP/3 support. Note that HTTP/3 is not a finished spec and client support is extremely limited. This option will go away in the future. _This option is not subject to compatibility promises._
+- **acme_ca** specifies the URL to the ACME CA's directory. It is strongly recommended to set this to Let's Encrypt's [staging endpoint](https://letsencrypt.org/docs/staging-environment/) for testing or development. Default: Let's Encrypt's production endpoint.
+- **email** is your email address. Mainly used when creating an ACME account with your CA, and is highly recommended in case there are problems with your certificates.
+- **admin** customizes the admin API endpoint.
diff --git a/src/docs/markdown/caddyfile/spec.md b/src/docs/markdown/caddyfile/spec.md
new file mode 100644
index 00000000..aae85ff9
--- /dev/null
+++ b/src/docs/markdown/caddyfile/spec.md
@@ -0,0 +1,203 @@
+---
+title: Caddyfile Spec
+---
+
+TODO: this page is unfinished
+
+
+
+# Caddyfile Specification
+
+This page describes the syntax of the Caddyfile. If it is your first time writing a Caddyfile, try the Caddyfile primer tutorial instead. This page is not beginner-friendly; it is technical and kind of boring.
+
+Although this article is verbose, the Caddyfile is designed to be easily readable and writable by humans. You will find that it is easy to remember, not cumbersome, and flows off the fingers.
+
+The term "Caddyfile" often refers to a file, but more generally means a blob of Caddy configuration text. A Caddyfile can be used to configure any Caddy server type: HTTP, DNS, etc. The basic structure and syntax of the Caddyfile is the same for all server types, but semantics change. Because of this variability, this document treats the Caddyfile only as the generic configuration syntax as it applies to all server types. Caddyfile documentation for specific types may be found within their respective docs. For instance, the HTTP server documents the semantics of its Caddyfile.
+
+#### Topics
+
+1. [File format & encoding](#)
+2. [Lexical syntax](#)
+3. [Structure](#)
+4. [Labels](#)
+5. [Directives](#)
+6. [Environment variables](#)
+7. [Import](#)
+8. [Reusable snippets](#)
+9. [Examples](#)
+
+
+## File Format & Encoding
+
+The Caddyfile is plain Unicode text encoded with UTF-8. Each code point is distinct; specifically, lowercase and uppercase characters are different. A leading byte order mark (0xFEFF), if present, will be ignored.
+
+
+
+## Lexical Syntax
+
+A token is a sequence of whitespace-delimited characters in the Caddyfile. A token that starts with quotes " is read literally (including whitespace) until the next instance of quotes " that is not escaped. Quote literals may be escaped with a backslash like so: \". Only quotes are escapable. “Smart quotes” are not valid as quotes.
+
+Lines are delimited with the \n (newline) character only. Carriage return \r is discarded unless quoted. Blank, unquoted lines are allowed and ignored.
+
+Comments are discarded by the lexer. Comments begin with an unquoted hash # and continue to the end of the line. Comments may start a line or appear in the middle of a line as part of an unquoted token. For the purposes of this document, commented and blank lines are no longer considered.
+
+Tokens are then evaluated by the parser for structure.
+
+## Structure
+
+A Caddyfile has no global scope or inheritence between separate blocks. The most global unit of the Caddyfile is an entry. An entry consists of a list of labels and a definition associated with those labels. A label is a string identifier, and a definition is a body (one or more lines) of tokens grouped together in a block:
+
+list of labels
+definition (block)
+
+A Caddyfile with only one entry may consist simply of the label line(s) followed by the definition on the next line(s), as shown above. However, a Caddyfile with more than one entry must enclose each definition in curly braces { }. The opening curly brace { must be at the end of the label line, and the closing curly brace } must be the only token on its line:
+
+list of labels {
+definition (block)
+}
+list of labels {
+definition (block)
+}
+
+Consistent tab indentation is encouraged within blocks enclosed by curly braces.
+
+
+The first line of a Caddyfile is always a label line. Comment lines, empty lines, and import lines are the exceptions.
+
+
+Labels
+
+Labels are the only tokens that appear outside of blocks (with one exception being the import directive). A label line may have just one label:
+
+label
+
+or several labels, separated by spaces:
+
+label1 label2 ...
+
+If many labels are to head a block, the labels may be suffixed with a comma. A comma-suffixed label may be followed by a newline, in which case the next line will be considered part of the same line:
+
+label1,
+label2
+
+Mixing of these patterns is valid (but discouraged), as long as the last label of the line has a comma if the next line is to continue the list of labels:
+
+label1 label2,
+label3, label4,
+label5
+
+A definition with multiple labels is replicated across each label as if they had been defined separately but with the same definition.
+
+
+Directives
+
+The body of the definition follows label lines. The first token of each line in a definition body is a directive. Every token after the directive on the same line is an argument. Arguments are optional:
+
+directive1
+directive2 arg1 arg2
+directive3 arg3
+
+Commas are not acceptable delimiters for arguments; they will be treated as part of the argument value. Arguments are delimited solely by same-line whitespace.
+
+
+Directives may span multiple lines by opening a block. Blocks are enclosed by curly braces { }. The opening curly brace { must be at the end of the directive's first line, and the closing curly brace } must be the only token on its line:
+
+directive {
+...
+}
+
+Within a directive block, the first token of each line may be considered a subdirective or property, depending on how it is used (other terms may be applied). And as before, they can have arguments:
+
+directive arg1 {
+subdir arg2 arg3
+...
+}
+
+Subdirectives cannot open new blocks. In other words, nested directive blocks are not supported. If a directive block is empty, the curly braces should be omitted entirely.
+
+
+Environment Variables
+
+Any token (label, directive, argument, etc.) may contain or consist solely of an environment variable, which takes the Unix form or Windows form, enclosed in curly braces { } without extra whitespace:
+
+label_{$ENV_VAR_1}
+directive {%ENV_VAR_2%}
+
+Either form works on any OS. A single environment variable does not expand out into multiple tokens, arguments, or values.
+
+
+Import
+
+The import directive is a special case, because it can appear outside a definition block. The consequence of this is that no label can take on the value of "import".
+
+
+Where an import line is, that line will be replaced with the contents of the imported file, unmodified. See the import docs for more information.
+
+
+Reusable Snippets
+
+You can define snippets to be reused later in your Caddyfile by defining a block with a single-token label surrounded by parentheses:
+
+(mysnippet) {
+...
+}
+
+Then you can invoke the snippet with the import directive:
+
+
+import mysnippet
+
+
Examples
+
+A very simple Caddyfile with only one entry:
+label1
+
+directive1 argument1
+directive2
+
+
+
+Appending the prior example with another entry introduces the need for curly braces:
+label1 {
+directive1 arg1
+directive2
+}
+label2, label3 {
+directive3 arg2
+directive4 arg3 arg4
+}
+
+
+
+
+Some people prefer to always use braces even if there's just one entry; this is fine, but unnecessary:
+label1 {
+directive1 arg1
+directive2
+}
+
+
+
+Example in which a directive opens a block:
+label1
+
+directive arg1 {
+subdir arg2 arg3
+}
+directive arg4
+
+
+
+Similarly, but in an indented definition body, and with a comment:
+label1 {
+directive1 arg1
+directive2 arg2 {
+subdir1 arg3 arg4
+subdir2
+# nested blocks not supported
+}
+directive3
+}
+
diff --git a/src/docs/markdown/command-line.md b/src/docs/markdown/command-line.md
new file mode 100644
index 00000000..743f95a1
--- /dev/null
+++ b/src/docs/markdown/command-line.md
@@ -0,0 +1,278 @@
+---
+title: "Command Line"
+---
+
+# Command Line
+
+Caddy has a standard unix-like command line interface. Basic usage is:
+
+```
+caddy []
+```
+
+The `` indicate parameters that get replaced by your input.
+
+The`[brackets]` indicate optional parameters.
+
+The ellipses `...` indicates a continuation, i.e. one or more parameters.
+
+**Quick start: `caddy help`**
+
+---
+
+- **[caddy adapt](#caddy-adapt)**
+ Adapts a config document to native JSON
+
+- **[caddy environ](#caddy-environ)**
+ Prints the environment
+
+- **[caddy file-server](#caddy-file-server)**
+ A simple but production-ready file server
+
+- **[caddy hash-password](#caddy-hash-password)**
+ Hashes a password and outputs base64
+
+- **[caddy help](#caddy-help)**
+ View help for caddy commands
+
+- **[caddy list-modules](#caddy-list-modules)**
+ Lists the installed Caddy modules
+
+- **[caddy reload](#caddy-reload)**
+ Changes the config of the running Caddy process
+
+- **[caddy reverse-proxy](#caddy-reverse-proxy)**
+ A simple but production-ready reverse proxy
+
+- **[caddy run](#caddy-run)**
+ Starts the Caddy process in the foreground
+
+- **[caddy start](#caddy-start)**
+ Starts the Caddy process in the background
+
+- **[caddy stop](#caddy-stop)**
+ Stops the running Caddy process
+
+- **[caddy validate](#caddy-validate)**
+ Tests whether a config file is valid
+
+- **[caddy version](#caddy-version)**
+ Prints the version
+
+
+
+## Subcommands
+
+
+### `caddy adapt`
+
+caddy adapt
+ --config <path>
+ [--adapter <name>]
+ [--pretty]
+ [--validate]
+
+Adapts a configuration to Caddy's native JSON config structure and writes the output to stdout, along with any warnings to stderr.
+
+`--config` is the path to the config file.
+
+`--adapter` specifies the config adapter to use; default is `caddyfile`.
+
+`--pretty` will format the output with indentation for human readability.
+
+`--validate` will load and provision the adapted configuration to check for validity (but it will not actually start running the config).
+
+Note that a config which is successfully adapted may still fail validation. For an example of this, use this Caddyfile:
+
+```
+localhost
+
+tls cert_notexist.pem key_notexist.pem
+```
+
+Try adapting it:
+
+caddy adapt --config Caddyfile
+
+It succeeds without error. Then try:
+
+caddy adapt --config Caddyfile --validate
+adapt: validation: loading app modules: module name 'tls': provision tls: loading certificates: open cert_notexist.pem: no such file or directory
+
+
+Even though that Caddyfile can be adapted to JSON without errors, the actual certificate and/or key files do not exist, so validation fails because that error arises during the provisioning phase. Thus, validation is a stronger error check than adaptation is.
+
+#### Example
+
+To adapt a Caddyfile to JSON that you can easily read and tweak manually:
+
+caddy adapt --config /path/to/Caddyfile --pretty
+
+
+
+
+### `caddy environ`
+
+caddy environ
+
+Prints the environment as seen by caddy, then exits. Can be useful when debugging init systems or process manager units like systemd.
+
+
+
+
+### `caddy file-server`
+
+caddy file-server
+ [--root <path>]
+ [--listen <addr>]
+ [--domain <example.com>]
+ [--browse]
+
+Spins up a simple but production-ready static file server.
+
+`--root` specifies the root file path. Default is the current working directory.
+
+`--listen` accepts a listener address. Default is `:2015`, unless `--domain` specifies a name that qualifies for HTTPS, then `:443` will be the default.
+
+`--domain` will only serve files through that domain name, and Caddy will attempt to serve it over HTTPS if it qualifies for a certificate (i.e. is a public domain name), so make sure its DNS is configured properly first. If the name qualifies for a certificate, the default port will be changed to 443.
+
+`--browse` will enable directory listings if a directory without an index file is requested.
+
+This command disables the admin API, making it easier to run multiple instances on a local development machine.
+
+
+
+### `caddy hash-password`
+
+caddy hash-password
+ --plaintext <password>
+ [--algorithm <name>]
+ [--salt <string>]
+
+Hashes a password and writes the output to stdout in base64 encoding.
+
+`--plaintext` is the plaintext form of the password.
+
+`--algorithm` may be bcrypt or scrypt. Default is bcrypt.
+
+`--salt` is used only if the algorithm requires an external salt (like scrypt).
+
+
+
+
+### `caddy help`
+
+caddy help [<command>]
+
+Prints CLI help text, optionally for a specific subcommand.
+
+
+
+### `caddy list-modules`
+
+caddy list-modules
+ [--versions]
+
+Prints the Caddy modules that are installed, optionally with version information from their associated Go modules.
+
+NOTE: Due to [a bug in Go](https://github.com/golang/go/issues/29228), version information is only available if Caddy is built as a dependency and not as the main module. TODO: Link to docs that explain how to build Caddy with version info
+
+
+
+### `caddy reload`
+
+caddy reload
+ [--config <path>]
+ [--adapter <name>]
+ [--address <interface>]
+
+Gives the running Caddy instance a new configuration. This has the same effect as POSTing a document to the [/load endpoint](/docs/api#post-load), but this command is convenient for simple workflows revolving around config files.
+
+`--config` is the config file to apply. If not specified, it will try a file called `Caddyfile` in the current working directory and, if it exists, it will adapt it using the `caddyfile` config adapter; otherwise, it is an error if there is no config file to load.
+
+`--adapter` specifies a config adapter to use, if any.
+
+`--address` needs to be used if the admin endpoint is not listening on the default address and if it is different from the address in the provided config file.
+
+
+
+### `caddy reverse-proxy`
+
+caddy reverse-proxy
+ --from <addr>
+ --to <addr>
+
+Spins up a simple but production-ready reverse proxy.
+
+`--from` is the address to proxy from.
+
+`--to` is the address to proxy to.
+
+Both from and to parameters can be URLs, as scheme, domain name, and URI rewrite information will be inferred from the provided URL. Or they can be a simple network address and not a complete URL.
+
+This command disables the admin API, making it easier to run multiple instances on a local development machine.
+
+
+### `caddy run`
+
+caddy run
+ [--config <path>]
+ [--adapter <name>]
+ [--environ]
+ [--resume]
+
+Runs Caddy and blocks indefinitely; i.e. "daemon" mode.
+
+`--config` specifies an initial config file to immediately load and use. If no config is specified, Caddy will run with a blank configuration and use default settings for the [admin API endpoints](/docs/api), which can be used to feed it new configuration. As a special case, if the current working directory has a file called "Caddyfile" and the `caddyfile` config adapter is plugged in (default), then that file will be loaded and used to configure Caddy, even without any command line flags.
+
+`--adapter` is the name of the config adapter to use when loading the initial config, if any. This flag is not necessary if the `--config` filename starts with "Caddyfile" which assumes the `caddyfile` adapter. Otherwise, this flag is required if the provided config file is not in Caddy's native JSON format. Any warnings will be printed to the log, but beware that any adaptation without errors will immediately be used, even if there are warnings. If you want to review the results of the adaptation first, use the [`caddy adapt`](#caddy-adapt) subcommand.
+
+`--environ` prints out the environment before starting. This is the same as the `caddy environ` command, but does not exit after printing.
+
+`--resume` uses the last loaded configuration. This flag is useful primarily in [API](/docs/api)-heavy deployments, and overrides `--config` if a saved config exists.
+
+
+### `caddy start`
+
+caddy start
+ [--config <path>]
+ [--adapter <name>]
+
+Same as `caddy run`, but in the background. This command only blocks until the background process is running successfully (or fails to run), then returns.
+
+Use of this command is discouraged with system services or on Windows. On Windows, the child process will remain attached to the terminal, so closing the window will forcefully stop Caddy, which is not obvious.
+
+Once started, you can use [`caddy stop`](#caddy-stop) or [the /stop API endpoint](/docs/api#post-stop) to exit the background process.
+
+
+
+### `caddy stop`
+
+caddy stop [--address <interface>]caddy validate
+ [--config <path>]
+ [--adapter <name>]caddy versioncaddy run --config caddy.yaml --adapter yamlcurl localhost:2019/load \
+ -X POST \
+ -H "Content-Type: application/yaml" \
+ --data-binary @caddy.yamlcaddy adapt --config caddy.yaml --adapter yamlcaddycaddy runcurl localhost:2019/config/curl localhost:2019/load \
+ -X POST \
+ -H "Content-Type: application/json" \
+ -d @caddy.json
+curl localhost:2019/config/curl localhost:2015
+Hello, world!caddy adaptcaddy adapt --config /path/to/Caddyfilecaddy runcaddy run \
+ --config /path/to/Caddyfile \
+ --adapter caddyfilecaddy startcaddy stopcaddy reloadsudo mv caddy /usr/bin/caddy versiongroupadd --system caddyuseradd --system \
+ --gid caddy \
+ --create-home \
+ --home-dir /var/lib/caddy \
+ --shell /usr/sbin/nologin \
+ --comment "Caddy web server" \
+ caddysudo systemctl daemon-reload
+sudo systemctl enable caddy
+sudo systemctl start caddysystemctl status caddyjournalctl -u caddysudo systemctl reload caddysudo systemctl stop caddygit clone -b v2 "https://github.com/caddyserver/caddy.git"cd caddy/cmd/caddy/
+go buildcaddy startcurl localhost:2019/load \
+ -X POST \
+ -H "Content-Type: application/json" \
+ -d @- << EOF
+ {
+ "apps": {
+ "http": {
+ "servers": {
+ "hello": {
+ "listen": [":2015"],
+ "routes": [
+ {
+ "handle": [{
+ "handler": "static_response",
+ "body": "Hello, world!"
+ }]
+ }
+ ]
+ }
+ }
+ }
+ }
+ }
+EOFcurl localhost:2019/load \
+ -X POST \
+ -H "Content-Type: application/json" \
+ -d @caddy.json
+curl localhost:2015
+Hello, world!curl localhost:2016
+Goodbye, world!caddy stopcaddy startcurl localhost:2015
+Hello, world!curl localhost:2019/load \
+ -X POST \
+ -H "Content-Type: text/caddyfile" \
+ --data-binary @Caddyfile
+caddy reloadcurl localhost:2016
+Goodbye, world!caddy stopcaddy file-servercaddy file-server --browsecaddy file-server --listen :80caddy file-server --root ~/mysitecaddy runcurl "https://cloudflare-dns.com/dns-query?name=example.com&type=A" \
+ -H "accept: application/dns-json"caddy runcaddy file-server --domain example.comcaddy reverse-proxy --from example.com --to localhost:9000caddy reverse-proxy --to 127.0.0.1:9000caddy reverse-proxy --from :2016 --to 127.0.0.1:9000caddy run
+ 
+
+ {{include "/includes/header-nav.html"}}
+
+ Documentation
+
+
+
\ No newline at end of file
diff --git a/src/includes/head.html b/src/includes/head.html
new file mode 100644
index 00000000..f2245bb8
--- /dev/null
+++ b/src/includes/head.html
@@ -0,0 +1,5 @@
+
+
+
+
+
\ No newline at end of file
diff --git a/src/includes/header-nav.html b/src/includes/header-nav.html
new file mode 100644
index 00000000..5a8664db
--- /dev/null
+++ b/src/includes/header-nav.html
@@ -0,0 +1,9 @@
+
+
\ No newline at end of file
diff --git a/src/includes/v1-banner.html b/src/includes/v1-banner.html
new file mode 100644
index 00000000..b1b66ee4
--- /dev/null
+++ b/src/includes/v1-banner.html
@@ -0,0 +1 @@
+This page is about Caddy 2, which is currently in beta. Click here for the old Caddy 1 site. Thank you for your patience as we transition!
\ No newline at end of file
diff --git a/src/index.html b/src/index.html
new file mode 100644
index 00000000..af5c6503
--- /dev/null
+++ b/src/index.html
@@ -0,0 +1,1019 @@
+
+
+
+
+ {{include "/includes/v1-banner.html"}}
+
+
+
+
+
+
+
+
+
+
+ {{include "/includes/header-nav.html"}}
+
+ The Ultimate Server
++ Caddy 2 is a powerful, enterprise-ready, open source web server with automatic HTTPS written in Go +
+ +
+ Download 2.0 Beta
+
+ then learn how to get started +
+ Download v1.0 stable + +
+ Caddy is licensed with the Apache 2.0 open source license. +
+ + then learn how to get started +
+ Download v1.0 stable + +
+ Caddy is licensed with the Apache 2.0 open source license. +
+
+
+ 
+
+
+
+ Fewer moving parts
++ Caddy simplifies your infrastructure. It takes care of TLS certificate renewals, OCSP stapling, static file serving, reverse proxying, Kubernetes ingress, and more. +
++ Its modular architecture means you can do more with a single, static binary that compiles for any platform. +
++ Caddy runs great in containers because it has no dependencies—not even libc. Run Caddy practically anywhere. +
+ +
+
+
+
+ 
+
+
+
+ Best-in-class security
++ Caddy is the only web server to use HTTPS automatically and by default. +
++ Caddy obtains and renew TLS certificates for your sites automatically. It even staples OCSP responses. Its novel certificate management features are the most mature and reliable in its class. +
++ Written in Go, Caddy offers greater memory safety than servers written in C. A hardened TLS stack powered by the Go standard library serves a significant portion of all Internet traffic. +
+ + +
+
+
+
+ 
+
+
+
+ Backed by Ardan
++ Ardan Labs is the trusted partner of the Caddy Web Server open source project, providing enterprise-grade support to our clients. +
++ Together, we consult and train, as well as develop, install, and maintain Caddy and its plugins to ensure your infrastructure runs smoothly and efficiently. Contact us to get started! +
+ +
+
+
+
+ 
+
+
+
+ File server and proxy
++ Caddy is both a flexible, efficient static file server and a powerful, scalable reverse proxy. +
++ Use it to serve your static site with compression, template evaluation, Markdown rendering, and more. +
++ Or use it as a dynamic reverse proxy to any number of backends, complete with active and passive health checks, load balancing, circuit breaking, caching, and more. +
+ +
+
+
+
+ 1-Liners
++ These commands are production-ready. When given a domain name, Caddy will use HTTPS by default, which provisions and renews certificates for you.* +
+* Requires domain's public A/AAAA DNS records pointed at your machine.
+
+
+ Quick, local file server
+ $ caddy file-server
+
+
+
+ Public file server over HTTPS
+ $ caddy file-server --domain example.com
+
+
+
+ HTTPS reverse proxy
+ $ caddy reverse-proxy --from example.com --to localhost:9000
+
+
+
+ Run server with Caddyfile in working directory (if present)
+ $ caddy run
+
+
+
+
+
+ The Caddyfile
++ A config file that's human-readable and easy to write by hand. Perfect for most common and manual configurations. +
+
+
+ Local file server with template evaluation
+ localhost
+
+templates
+file_server
+
+
+
+ HTTPS reverse proxy with custom load balancing and active health checks
+ example.com # Your site's domain name
+
+# Load balance between three backends with custom health checks
+reverse_proxy 10.0.0.1:9000 10.0.0.2:9000 10.0.0.3:9000 {
+ lb_policy random_choose 2
+ health_path /ok
+ health_interval 10s
+}
+
+
+
+ HTTPS site with clean URLs, reverse proxying, compression, and templates
+ example.com
+
+# Templates give static sites some dynamic features
+templates
+
+# Compress responses according to Accept-Encoding headers
+encode gzip zstd
+
+# Make HTML file extension optional
+try_files {path}.html {path}
+
+# Send API requests to backend
+reverse_proxy /api/* localhost:9005
+
+# Serve everything else from the file system
+file_server
+
+
+
+
+ Download
+ Caddyfile Docs
+
+
+
+ Caddy is dynamically configurable with a RESTful JSON API. Config updates are graceful, even on Windows.
+
+
+
+ Config API
+
+ Caddy is dynamically configurable with a RESTful JSON API. Config updates are graceful, even on Windows.
+
+ Using JSON gives you absolute control over the edge of your compute platform, and is perfect for dynamic and automated deployments.
+
+
+
+ Set a new configuration
+ POST /config/
+
+{
+ "apps": {
+ "http": {
+ "servers": {
+ "example": {
+ "listen": ["127.0.0.1:2080"],
+ "routes": [{
+ "@id": "demo",
+ "handle": [{
+ "handler": "file_server",
+ "browse": {}
+ }]
+ }]
+ }
+ }
+ }
+ }
+}
+
+
+
+ Export current configuration
+ GET /config/
+
+
+
+ Change only a specific part of the config
+ PUT /id/demo/handle/0
+
+{"handler": "templates"}
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {{include "/includes/footer.html"}}
+
+
+
diff --git a/src/resources/css/chroma.css b/src/resources/css/chroma.css
new file mode 100644
index 00000000..b3c2c52a
--- /dev/null
+++ b/src/resources/css/chroma.css
@@ -0,0 +1,155 @@
+/*
+ Derived from https://gist.github.com/nicolashery/5765395
+ Adjusted to be high-contrast
+*/
+
+
+/*
+ Solarized Light (High Contrast)
+ Derived from http://ethanschoonover.com/solarized
+*/
+.chroma { background-color: #f0f9fb; color: #586e75 }
+.chroma .c { color: #93a1a1 } /* Comment */
+.chroma .err { color: #586e75 } /* Error */
+.chroma .g { color: #586e75 } /* Generic */
+.chroma .k { color: #577b00 } /* Keyword */
+.chroma .l { color: #586e75 } /* Literal */
+.chroma .n { color: #586e75 } /* Name */
+.chroma .o { color: #577b00 } /* Operator */
+.chroma .x { color: #d03d00 } /* Other */
+.chroma .p { color: #586e75 } /* Punctuation */
+.chroma .cm { color: #93a1a1 } /* Comment.Multiline */
+.chroma .cp { color: #577b00 } /* Comment.Preproc */
+.chroma .c1 { color: #93a1a1 } /* Comment.Single */
+.chroma .cs { color: #577b00 } /* Comment.Special */
+.chroma .gd { color: #008076 } /* Generic.Deleted */
+.chroma .ge { color: #586e75; font-style: italic } /* Generic.Emph */
+.chroma .gr { color: #dc322f } /* Generic.Error */
+.chroma .gh { color: #d03d00 } /* Generic.Heading */
+.chroma .gi { color: #577b00 } /* Generic.Inserted */
+.chroma .go { color: #586e75 } /* Generic.Output */
+.chroma .gp { color: #586e75 } /* Generic.Prompt */
+.chroma .gs { color: #586e75; font-weight: bold } /* Generic.Strong */
+.chroma .gu { color: #d03d00 } /* Generic.Subheading */
+.chroma .gt { color: #586e75 } /* Generic.Traceback */
+.chroma .kc { color: #d03d00 } /* Keyword.Constant */
+.chroma .kd { color: #0673bf } /* Keyword.Declaration */
+.chroma .kn { color: #577b00 } /* Keyword.Namespace */
+.chroma .kp { color: #577b00 } /* Keyword.Pseudo */
+.chroma .kr { color: #0673bf } /* Keyword.Reserved */
+.chroma .kt { color: #dc322f } /* Keyword.Type */
+.chroma .ld { color: #586e75 } /* Literal.Date */
+.chroma .m { color: #008076 } /* Literal.Number */
+.chroma .s { color: #008076 } /* Literal.String */
+.chroma .na { color: #586e75 } /* Name.Attribute */
+.chroma .nb { color: #B58900 } /* Name.Builtin */
+.chroma .nc { color: #0673bf } /* Name.Class */
+.chroma .no { color: #d03d00 } /* Name.Constant */
+.chroma .nd { color: #0673bf } /* Name.Decorator */
+.chroma .ni { color: #d03d00 } /* Name.Entity */
+.chroma .ne { color: #d03d00 } /* Name.Exception */
+.chroma .nf { color: #0673bf } /* Name.Function */
+.chroma .nl { color: #586e75 } /* Name.Label */
+.chroma .nn { color: #586e75 } /* Name.Namespace */
+.chroma .nx { color: #586e75 } /* Name.Other */
+.chroma .py { color: #586e75 } /* Name.Property */
+.chroma .nt { color: #0673bf } /* Name.Tag */
+.chroma .nv { color: #0673bf } /* Name.Variable */
+.chroma .ow { color: #577b00 } /* Operator.Word */
+.chroma .w { color: #586e75 } /* Text.Whitespace */
+.chroma .mf { color: #008076 } /* Literal.Number.Float */
+.chroma .mh { color: #008076 } /* Literal.Number.Hex */
+.chroma .mi { color: #008076 } /* Literal.Number.Integer */
+.chroma .mo { color: #008076 } /* Literal.Number.Oct */
+.chroma .sb { color: #93a1a1 } /* Literal.String.Backtick */
+.chroma .sc { color: #008076 } /* Literal.String.Char */
+.chroma .sd { color: #586e75 } /* Literal.String.Doc */
+.chroma .s2 { color: #008076 } /* Literal.String.Double */
+.chroma .se { color: #d03d00 } /* Literal.String.Escape */
+.chroma .sh { color: #586e75 } /* Literal.String.Heredoc */
+.chroma .si { color: #008076 } /* Literal.String.Interpol */
+.chroma .sx { color: #008076 } /* Literal.String.Other */
+.chroma .sr { color: #dc322f } /* Literal.String.Regex */
+.chroma .s1 { color: #008076 } /* Literal.String.Single */
+.chroma .ss { color: #008076 } /* Literal.String.Symbol */
+.chroma .bp { color: #0673bf } /* Name.Builtin.Pseudo */
+.chroma .vc { color: #0673bf } /* Name.Variable.Class */
+.chroma .vg { color: #0673bf } /* Name.Variable.Global */
+.chroma .vi { color: #0673bf } /* Name.Variable.Instance */
+.chroma .il { color: #008076 } /* Literal.Number.Integer.Long */
+
+@media (prefers-color-scheme: dark) {
+ /*
+ Solarized Dark (High Contrast)
+ Derived from http://ethanschoonover.com/solarized
+ */
+ .chroma { background-color: #002b36; color: #93a1a1 }
+ .chroma .c { color: #586e75 } /* Comment */
+ .chroma .err { color: #93a1a1 } /* Error */
+ .chroma .g { color: #93a1a1 } /* Generic */
+ .chroma .k { color: #76a507 } /* Keyword */
+ .chroma .l { color: #93a1a1 } /* Literal */
+ .chroma .n { color: #93a1a1 } /* Name */
+ .chroma .o { color: #76a507 } /* Operator */
+ .chroma .x { color: #ec662e } /* Other */
+ .chroma .p { color: #93a1a1 } /* Punctuation */
+ .chroma .cm { color: #586e75 } /* Comment.Multiline */
+ .chroma .cp { color: #76a507 } /* Comment.Preproc */
+ .chroma .c1 { color: #586e75 } /* Comment.Single */
+ .chroma .cs { color: #76a507 } /* Comment.Special */
+ .chroma .gd { color: #09a598 } /* Generic.Deleted */
+ .chroma .ge { color: #93a1a1; font-style: italic } /* Generic.Emph */
+ .chroma .gr { color: #dc322f } /* Generic.Error */
+ .chroma .gh { color: #ec662e } /* Generic.Heading */
+ .chroma .gi { color: #76a507 } /* Generic.Inserted */
+ .chroma .go { color: #93a1a1 } /* Generic.Output */
+ .chroma .gp { color: #93a1a1 } /* Generic.Prompt */
+ .chroma .gs { color: #93a1a1; font-weight: bold } /* Generic.Strong */
+ .chroma .gu { color: #ec662e } /* Generic.Subheading */
+ .chroma .gt { color: #93a1a1 } /* Generic.Traceback */
+ .chroma .kc { color: #ec662e } /* Keyword.Constant */
+ .chroma .kd { color: #0090f5 } /* Keyword.Declaration */
+ .chroma .kn { color: #76a507 } /* Keyword.Namespace */
+ .chroma .kp { color: #76a507 } /* Keyword.Pseudo */
+ .chroma .kr { color: #0090f5 } /* Keyword.Reserved */
+ .chroma .kt { color: #dc322f } /* Keyword.Type */
+ .chroma .ld { color: #93a1a1 } /* Literal.Date */
+ .chroma .m { color: #09a598 } /* Literal.Number */
+ .chroma .s { color: #09a598 } /* Literal.String */
+ .chroma .na { color: #93a1a1 } /* Name.Attribute */
+ .chroma .nb { color: #B58900 } /* Name.Builtin */
+ .chroma .nc { color: #0090f5 } /* Name.Class */
+ .chroma .no { color: #ec662e } /* Name.Constant */
+ .chroma .nd { color: #0090f5 } /* Name.Decorator */
+ .chroma .ni { color: #ec662e } /* Name.Entity */
+ .chroma .ne { color: #ec662e } /* Name.Exception */
+ .chroma .nf { color: #0090f5 } /* Name.Function */
+ .chroma .nl { color: #93a1a1 } /* Name.Label */
+ .chroma .nn { color: #93a1a1 } /* Name.Namespace */
+ .chroma .nx { color: #93a1a1 } /* Name.Other */
+ .chroma .py { color: #93a1a1 } /* Name.Property */
+ .chroma .nt { color: #0090f5 } /* Name.Tag */
+ .chroma .nv { color: #0090f5 } /* Name.Variable */
+ .chroma .ow { color: #76a507 } /* Operator.Word */
+ .chroma .w { color: #93a1a1 } /* Text.Whitespace */
+ .chroma .mf { color: #09a598 } /* Literal.Number.Float */
+ .chroma .mh { color: #09a598 } /* Literal.Number.Hex */
+ .chroma .mi { color: #09a598 } /* Literal.Number.Integer */
+ .chroma .mo { color: #09a598 } /* Literal.Number.Oct */
+ .chroma .sb { color: #586e75 } /* Literal.String.Backtick */
+ .chroma .sc { color: #09a598 } /* Literal.String.Char */
+ .chroma .sd { color: #93a1a1 } /* Literal.String.Doc */
+ .chroma .s2 { color: #09a598 } /* Literal.String.Double */
+ .chroma .se { color: #ec662e } /* Literal.String.Escape */
+ .chroma .sh { color: #93a1a1 } /* Literal.String.Heredoc */
+ .chroma .si { color: #09a598 } /* Literal.String.Interpol */
+ .chroma .sx { color: #09a598 } /* Literal.String.Other */
+ .chroma .sr { color: #dc322f } /* Literal.String.Regex */
+ .chroma .s1 { color: #09a598 } /* Literal.String.Single */
+ .chroma .ss { color: #09a598 } /* Literal.String.Symbol */
+ .chroma .bp { color: #0090f5 } /* Name.Builtin.Pseudo */
+ .chroma .vc { color: #0090f5 } /* Name.Variable.Class */
+ .chroma .vg { color: #0090f5 } /* Name.Variable.Global */
+ .chroma .vi { color: #0090f5 } /* Name.Variable.Instance */
+ .chroma .il { color: #09a598 } /* Literal.Number.Integer.Long */
+}
diff --git a/src/resources/css/common.css b/src/resources/css/common.css
new file mode 100644
index 00000000..cbd7467b
--- /dev/null
+++ b/src/resources/css/common.css
@@ -0,0 +1,373 @@
+* {
+ margin: 0;
+ padding: 0;
+ box-sizing: border-box;
+}
+
+body {
+ font-family: Maven Pro, sans-serif;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+ tab-size: 4;
+ -moz-tab-size: 4;
+}
+
+#v1-banner {
+ display: block;
+ background: #5ea9a2;
+ color: #fff;
+ text-align: center;
+ padding: 15px 25px;
+ font-size: 18px;
+ text-decoration: none;
+}
+
+#v1-banner:hover {
+ background: #4e968f;
+}
+
+.wrapper {
+ max-width: 1400px;
+ margin-left: auto;
+ margin-right: auto;
+ padding-left: 40px;
+ padding-right: 40px;
+}
+
+.text-center {
+ text-align: center;
+}
+
+a {
+ color: #0694f1;
+ text-decoration: none;
+}
+
+a:hover {
+ color: #ff3f2c;
+}
+
+header {
+ display: flex;
+ justify-content: space-between;
+ padding: 25px 0;
+}
+
+#logo {
+ height: 40px;
+}
+
+header nav {
+ text-align: right;
+ line-height: 40px;
+}
+
+header nav a {
+ display: inline-block;
+ padding-left: 10px;
+ padding-right: 10px;
+ text-decoration: none;
+ color: inherit;
+}
+
+header nav a:hover {
+ color: #ff3f2c;
+}
+
+header nav a.current {
+ font-weight: bold;
+}
+
+header nav .button {
+ margin: 0 0 0 10px;
+ padding-top: 2px;
+ padding-bottom: 2px;
+}
+
+.button {
+ border-radius: 2em;
+ padding: 10px 20px;
+ margin: 15px 30px 15px 0;
+ height: auto;
+ transition: all .2s;
+ text-decoration: none;
+ display: inline-block;
+}
+
+.button:hover {
+ transform: scale(1.05);
+}
+
+.button:active {
+ transform: translateY(2px);
+}
+
+.button.red {
+ background-color: #d9552b;
+ color: white;
+}
+
+.button.red:hover {
+ background-color: #fd511a;
+}
+
+.button.blue {
+ background-color: #009ae6;
+ color: white;
+}
+
+.button.blue:hover {
+ background-color: #00aaff;
+}
+
+.button.gray {
+ background-color: #4c6a79;
+ color: white;
+}
+
+.button.gray:hover {
+ background-color: #4f8098;
+}
+
+.button.big {
+ font-size: 125%;
+ text-transform: uppercase;
+ font-weight: bold;
+ padding: 20px 50px;
+ margin-right: 20px;
+}
+
+p .button {
+ font-size: 18px;
+ padding: 12px 30px;
+}
+
+article a:hover {
+ text-decoration: underline;
+}
+
+
+footer {
+ display: flex;
+ justify-content: space-between;
+ margin-top: 100px;
+ border-top: 1px solid #CCC;
+ padding-top: 50px;
+ padding-bottom: 100px;
+ line-height: 125%;
+}
+
+footer > div {
+ width: 50%;
+}
+
+#footer-logo {
+ float: left;
+ max-width: 175px;
+ margin-right: 35px;
+ vertical-align: middle;
+ margin-top: -4px;
+}
+
+.copyright {
+ text-align: right;
+ font-size: 14px;
+ color: #999;
+}
+
+@media (max-width: 900px) {
+ footer {
+ flex-direction: column;
+ margin-top: 0;
+ padding: 20px 0;
+ }
+
+ footer > div {
+ width: initial;
+ text-align: center;
+ margin: 10px 0;
+ }
+
+ #footer-logo {
+ float: none;
+ display: block;
+ margin: 0 auto 25px;
+ }
+
+ .copyright {
+ text-align: center;
+ }
+}
+
+
+/* font resources */
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 100;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-Thin-BETA.woff2") format("woff2"),
+ url("/resources/fonts/Inter-Thin-BETA.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 100;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-ThinItalic-BETA.woff2") format("woff2"),
+ url("/resources/fonts/Inter-ThinItalic-BETA.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 200;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-ExtraLight-BETA.woff2") format("woff2"),
+ url("/resources/fonts/Inter-ExtraLight-BETA.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 200;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-ExtraLightItalic-BETA.woff2") format("woff2"),
+ url("/resources/fonts/Inter-ExtraLightItalic-BETA.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 300;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-Light-BETA.woff2") format("woff2"),
+ url("/resources/fonts/Inter-Light-BETA.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 300;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-LightItalic-BETA.woff2") format("woff2"),
+ url("/resources/fonts/Inter-LightItalic-BETA.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 400;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-Regular.woff2") format("woff2"),
+ url("/resources/fonts/Inter-Regular.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 400;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-Italic.woff2") format("woff2"),
+ url("/resources/fonts/Inter-Italic.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 500;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-Medium.woff2") format("woff2"),
+ url("/resources/fonts/Inter-Medium.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 500;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-MediumItalic.woff2") format("woff2"),
+ url("/resources/fonts/Inter-MediumItalic.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 600;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-SemiBold.woff2") format("woff2"),
+ url("/resources/fonts/Inter-SemiBold.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 600;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-SemiBoldItalic.woff2") format("woff2"),
+ url("/resources/fonts/Inter-SemiBoldItalic.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 700;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-Bold.woff2") format("woff2"),
+ url("/resources/fonts/Inter-Bold.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 700;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-BoldItalic.woff2") format("woff2"),
+ url("/resources/fonts/Inter-BoldItalic.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 800;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-ExtraBold.woff2") format("woff2"),
+ url("/resources/fonts/Inter-ExtraBold.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 800;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-ExtraBoldItalic.woff2") format("woff2"),
+ url("/resources/fonts/Inter-ExtraBoldItalic.woff") format("woff");
+}
+
+
+@font-face {
+ font-family: 'Inter';
+ font-style: normal;
+ font-weight: 900;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-Black.woff2") format("woff2"),
+ url("/resources/fonts/Inter-Black.woff") format("woff");
+}
+
+@font-face {
+ font-family: 'Inter';
+ font-style: italic;
+ font-weight: 900;
+ font-display: swap;
+ src: url("/resources/fonts/Inter-BlackItalic.woff2") format("woff2"),
+ url("/resources/fonts/Inter-BlackItalic.woff") format("woff");
+}
diff --git a/src/resources/css/docs-json.css b/src/resources/css/docs-json.css
new file mode 100644
index 00000000..f44b62e9
--- /dev/null
+++ b/src/resources/css/docs-json.css
@@ -0,0 +1,28 @@
+pre > code.json {
+ background-color: #f0f9f8;
+}
+
+#renderbox {
+ border-radius: 0;
+ font-size: 20px;
+ line-height: 1.6em;
+}
+
+.toggle-obj {
+ padding: 0 .5em;
+ visibility: hidden;
+}
+
+.group:hover > .toggle-obj {
+ visibility: visible;
+}
+
+.collapsed {
+ display: none;
+}
+
+@media (prefers-color-scheme: dark) {
+ pre > code.json {
+ background-color: #07212b;
+ }
+}
\ No newline at end of file
diff --git a/src/resources/css/docs.css b/src/resources/css/docs.css
new file mode 100644
index 00000000..22c36352
--- /dev/null
+++ b/src/resources/css/docs.css
@@ -0,0 +1,735 @@
+header {
+ border-bottom: 1px solid #f0f6f7;
+ padding: 10px 20px;
+}
+
+#logo-container {
+ display: flex;
+ align-items: center;
+ line-height: 0;
+}
+
+#logo {
+ height: 25px;
+ line-height: 0;
+}
+
+#logo-docs {
+ font-family: Montserrat, sans-serif;
+ text-transform: uppercase;
+ color: #196165;
+ margin-left: 10px;
+ font-size: 12px;
+}
+
+header nav {
+ font-size: 16px;
+ line-height: 2em;
+}
+
+header nav .button {
+ padding-top: 4px;
+ padding-bottom: 4px;
+}
+
+.breadcrumbs {
+ color: #196165;
+ border-bottom: 1px solid #f0f6f7;
+ font-size: 16px;
+ padding: 10px 20px;
+ font-weight: bold;
+ line-height: 1.75em;
+}
+
+.breadcrumbs a {
+ font-weight: normal;
+ text-decoration: none;
+}
+
+.breadcrumb-siblings-title {
+ padding: 10px;
+ font-weight: bold;
+}
+
+.breadcrumb-siblings a {
+ display: block;
+ padding: 0 10px;
+ text-decoration: none;
+}
+
+.breadcrumb-siblings a+a {
+ padding-top: 10px;
+}
+
+.breadcrumb-siblings a:last-child {
+ padding-bottom: 10px;
+}
+
+#top-breadcrumb {
+ font-weight: bold;
+}
+
+#top-breadcrumb:not(:hover) {
+ color: #196165;
+}
+
+main {
+ display: flex;
+}
+
+main > .sidebar,
+article aside {
+ width: 20%;
+}
+
+main > .sidebar {
+ flex-shrink: 0;
+ padding: 20px 0;
+ border: 0px solid #f0f6f7;
+}
+
+main nav {
+ border-right-width: 1px;
+ position: relative;
+ font-size: 18px;
+}
+
+main nav ul {
+ list-style-type: none;
+}
+
+main nav li {
+ position: relative;
+}
+
+main nav li a {
+ padding: 8px 22px;
+}
+
+main nav li a {
+ display: block;
+ text-decoration: none;
+ color: inherit;
+}
+
+main nav li a:hover {
+ background-color: #f8fcff;
+ color: #196165;
+}
+
+main nav li a:before {
+ content: '\203A';
+ font-weight: bold;
+ font-size: 20px;
+ line-height: 1rem;
+ position: absolute;
+ opacity: 0;
+ left: 5px;
+ transition: left .15s, opacity .15s;
+}
+
+main nav li a:hover:before {
+ opacity: 1;
+ left: 10px;
+}
+
+main nav li li a:hover:before {
+ left: 1.25em;
+}
+
+main nav li a.current {
+ background-color: #f0f6f7;
+}
+
+main nav li.heading {
+ font-weight: bold;
+ font-size: 120%;
+ padding: 10px 20px 5px;
+}
+
+main nav li.heading:not(:first-child) {
+ margin-top: 20px;
+}
+
+main nav li li a {
+ padding-top: 6px;
+ padding-bottom: 4px;
+ padding-left: 2.5em;
+ font-size: 90%;
+}
+
+.article-container {
+ flex-grow: 1;
+ min-width: 0;
+}
+
+article,
+.content {
+ margin: 0 auto;
+ max-width: 950px;
+}
+
+article {
+ padding: 40px;
+ font-size: 20px;
+ word-wrap: break-word;
+}
+
+article p,
+article pre > code,
+article pre.chroma,
+article ul,
+article ol {
+ margin-bottom: 1em;
+}
+
+article ul,
+article ol,
+#hovercard ul,
+#hovercard ol {
+ margin-left: 2.5em;
+}
+
+article p,
+article li {
+ line-height: 1.5em;
+}
+
+h1 {
+ font-size: 80px;
+ color: #196165;
+ margin-bottom: 25px;
+}
+
+h2 {
+ font-size: 46px;
+ padding-bottom: 15px;
+ border-bottom: 4px solid #a6d0da;
+ margin: 100px 0 40px;
+}
+
+h3 {
+ font-size: 34px;
+ margin: 50px 0 20px;
+}
+
+h4 {
+ font-size: 24px;
+ margin: 25px 0 15px;
+}
+
+h5 {
+ font-size: 22px;
+ margin: 2em 0 1em;
+}
+
+code,
+pre.chroma {
+ font-family: 'PT Mono', 'Source Code Pro', monospace;
+ padding: 3px 6px;
+ border-radius: 5px;
+ font-size: 90%;
+ line-height: 1.4em;
+}
+
+code {
+ background-color: #f0f9fb;
+}
+
+code.cmd {
+ background-color: #333;
+ color: #eaeaea;
+}
+
+pre > code,
+pre.chroma,
+.group {
+ display: block;
+ white-space: pre;
+}
+
+pre > code,
+pre.chroma {
+ padding: 1em;
+ border-radius: 10px;
+ overflow: auto;
+}
+
+pre > code.cmd {
+ border-radius: 5px;
+ tab-size: 2;
+}
+
+code.cmd.bash,
+code.cmd .bash {
+ font-weight: bold;
+}
+
+code.cmd.bash::before,
+code.cmd .bash::before {
+ content: '$';
+ margin-right: .5rem;
+}
+
+dt:hover .inline-link {
+ visibility: visible;
+}
+
+dd {
+ margin-left: 1em;
+}
+
+#field-list-header {
+ display: none;
+}
+
+.field-name {
+ display: block;
+ font-family: 'Source Code Pro', monospace;
+ margin: 0;
+ font-weight: bold;
+ margin-bottom: .5em;
+}
+
+.inline-link {
+ text-decoration: none;
+ position: absolute;
+ margin-left: -1.4em;
+ margin-top: -.1em;
+ padding-right: .2em;
+ padding-left: .2em;
+ visibility: hidden;
+}
+
+.inline-link:hover {
+ text-decoration: none;
+}
+
+hr {
+ border: none;
+ border-top: 5px solid #186165;
+ margin: 2em 0;
+}
+
+article img {
+ max-width: 100%;
+}
+
+iframe {
+ margin: 1em 0 2em;
+}
+
+main > .sidebar:not(:last-child) {
+ border-right-width: 1px;
+}
+
+
+
+
+.json {
+ line-height: 1.5em;
+}
+.json .qu { color: #5c91bf; }
+.json .key { color: #1c83dc; font-weight: bold; }
+.json .str { color: #2f8598; }
+.json .num { color: #038a3f; }
+.json .bool { color: #9b5e14; }
+.json .key a:not(:hover) { color: inherit; }
+.json a {
+ text-decoration: none;
+ font-weight: bold;
+}
+.json .has-popup { border-bottom: 1px dashed #1c82dc; }
+.json .has-popup.module { border-bottom: none; }
+
+
+#hovercard {
+ max-width: 450px;
+ border-radius: 10px;
+ filter: drop-shadow(0 5px 5px rgba(0, 0, 0, .25));
+ position: absolute;
+ font-size: 16px;
+ transition: transform .25s ease-in-out, opacity .25s ease-in-out;
+}
+
+#hovercard:not(.popup) {
+ opacity: 0;
+ display: none;
+ transform: translateY(0);
+}
+
+.popup {
+ display: block;
+ opacity: 1;
+ transform: translateY(-10px);
+}
+
+.arrow-box {
+ position: relative;
+ background: white;
+}
+
+.arrow-box:after {
+ bottom: 100%;
+ left: 50%;
+ border: solid transparent;
+ content: " ";
+ height: 0;
+ width: 0;
+ position: absolute;
+ pointer-events: none;
+ border-color: rgba(255, 255, 255, 0);
+ border-bottom-color: white;
+ border-width: 10px;
+ margin-left: -10px;
+}
+
+#hovercard p {
+ padding: 1em;
+ line-height: 1.4em;
+}
+
+#hovercard p+p {
+ padding-top: 0;
+}
+
+#hovercard li {
+ margin: .25em;
+}
+
+#hovercard pre > code {
+ border-radius: 0;
+}
+
+#hovercard li {
+ padding-top: 0;
+ padding-bottom: 0;
+}
+
+#hovercard .module-link {
+ display: block;
+ text-decoration: none;
+ font-size: 18px;
+ line-height: 1em;
+ font-weight: bold;
+ padding: .5em 1em;
+}
+
+#hovercard .module-link:hover {
+ background: #f5f5f5;
+}
+
+#hovercard .module-link:last-child {
+ border-bottom-left-radius: 10px;
+ border-bottom-right-radius: 10px;
+}
+
+#hovercard .module-link-description {
+ font-size: 14px;
+ color: #555;
+ margin-left: .5em;
+ font-weight: normal;
+}
+
+#hovercard-namespace-box,
+#hovercard-inline-link {
+ border: 0px solid #f0f6f7;
+}
+
+#hovercard-namespace-box {
+ border-bottom-width: 1px;
+}
+
+#hovercard-inline-link {
+ border-top-width: 1px;
+}
+
+#hovercard-inline-link a {
+ display: block;
+ padding: 8px 10px;
+ text-decoration: none;
+ font-size: 85%;
+ font-weight: bold;
+ text-align: center;
+}
+
+#hovercard-namespace {
+ font-weight: bold;
+}
+
+.explain {
+ font-style: italic;
+ color: #777;
+}
+
+.beta-warning {
+ font-size: 14px;
+ padding: 10px;
+ border-bottom: 1px solid orange;
+ background: #fff5e2;
+ line-height: 1.4em;
+}
+
+article aside {
+ position: absolute;
+ right: 0;
+ font-size: 16px;
+ color: #146673;
+ line-height: 1.4em;
+ padding: 10px 3.5% 10px 20px;
+ border: 0px solid #dff9ff;
+ border-top-width: 1px;
+ border-left-width: 1px;
+ background: -webkit-radial-gradient(top left, #d6f0f3, transparent 65%);
+ background: -moz-radial-gradient(top left, #d6f0f3, transparent 65%);
+ background: radial-gradient(top left, #d6f0f3, transparent 65%);
+}
+
+article aside.complete::before,
+article aside.tip::before {
+ text-transform: uppercase;
+ display: block;
+ line-height: 1em;
+ font-weight: 900;
+}
+
+article aside.complete::before {
+ content: 'complete';
+ font-size: 14px;
+ letter-spacing: 2px;
+ color: #3ea78a;
+ margin-bottom: 10px;
+}
+
+article aside.tip::before {
+ content: 'tip';
+ color: #d0efef;
+ position: absolute;
+ top: -30px;
+ font-size: 35px;
+}
+
+article aside.warning {
+ border-top-color: #ffd6a4;
+ color: #bd6800;
+ background: -webkit-radial-gradient(top left, #ffd6a4, transparent 65%);
+ background: -moz-radial-gradient(top left, #ffd6a4, transparent 65%);
+ background: radial-gradient(top left, #ffd6a4, transparent 65%);
+}
+
+article aside.warning::before {
+ content: 'warning';
+ color: #ffd6a4;
+ position: absolute;
+ top: -30px;
+ font-size: 35px;
+}
+
+table {
+ table-layout: fixed;
+ border-collapse: collapse;
+ font-size: 16px;
+ margin: 25px 0;
+}
+
+th, td {
+ border-bottom: 1px solid #ddd;
+ padding: 10px;
+ line-height: 1.4em;
+ vertical-align: top;
+ word-wrap: break-word;
+}
+
+th {
+ text-align: left;
+ background: #eee;
+}
+
+td code {
+ font-size: 14px;
+ word-wrap: break-word;
+}
+
+@media (max-width: 1400px) {
+ article aside {
+ font-size: 14px;
+ }
+
+ table {
+ font-size: 14px;
+ }
+
+ h1 {
+ font-size: 60px;
+ }
+
+ h2 {
+ font-size: 38px;
+ margin-top: 65px;
+ }
+
+ h3 {
+ font-size: 28px;
+ margin-top: 40px;
+ }
+}
+
+@media (max-width: 1000px) {
+ main > .sidebar:last-child,
+ article aside {
+ display: none;
+ }
+
+ main > .sidebar {
+ width: 30%;
+ padding: 10px 0;
+ }
+
+ article {
+ padding: 20px;
+ }
+}
+
+@media (max-width: 1000px) and (min-width: 600px) {
+ main nav li a {
+ padding: 8px 12px;
+ }
+
+ main nav li li a {
+ padding-left: 1.5em;
+ }
+
+ main nav li a:before {
+ font-size: 18px;
+ left: -5px;
+ }
+
+ main nav li a:hover:before {
+ left: 2px;
+ }
+
+ main nav li li a:hover:before {
+ left: .5em;
+ }
+}
+
+
+@media (max-width: 600px) {
+ #logo-docs {
+ display: none;
+ }
+
+ main {
+ flex-direction: column-reverse;
+ }
+
+ main > .sidebar {
+ width: 100%;
+ border-width: 0;
+ border-top-width: 2px;
+ }
+}
+
+
+
+@media (prefers-color-scheme: dark) {
+ body {
+ background-color: #060e17;
+ color: #bdd6f7;
+ }
+
+ header,
+ main > .sidebar,
+ footer {
+ border-color: #061b35;
+ }
+
+ #logo {
+ /* TODO: Add some color */
+ filter: invert(1) opacity(.35);
+ }
+
+ #logo-docs {
+ color: #5aa3dc;
+ }
+
+ .breadcrumbs {
+ color: #5aa3dc;
+ }
+
+ main nav ul li a:hover {
+ background-color: #13243a;
+ color: #5aa3dc;
+ }
+
+ main nav ul li a.current {
+ background-color: #061b35;
+ }
+
+ .breadcrumbs,
+ main nav {
+ border-color: #061b35;
+ }
+
+ h1 {
+ color: #5aa3dc;
+ }
+
+ code {
+ background-color: #122844;
+ }
+
+ code.cmd {
+ background-color: #000;
+ color: #ccc;
+ }
+
+ #hovercard,
+ .arrow-box {
+ background-color: #0a192b;
+ }
+
+ .arrow-box:after {
+ border-bottom-color: #0a192b;
+ }
+
+ #hovercard .module-link:hover {
+ background: #0f2c50;
+ }
+
+ #hovercard .module-link-description {
+ color: rgb(167, 167, 167);
+ }
+
+ #hovercard-namespace-box,
+ #hovercard-inline-link {
+ border-color: #0a2b53;
+ }
+
+
+ .beta-warning {
+ background-color: #462e00;
+ color: #ffa500;
+ }
+
+ article aside {
+ background: -webkit-radial-gradient(top left, #00515a, transparent 65%);
+ background: -moz-radial-gradient(top left, #00515a, transparent 65%);
+ background: radial-gradient(top left, #00515a, transparent 65%);
+ color: #37c3a9;
+ border-color: #08575a;
+ }
+
+ article aside.tip:before {
+ color: #185f5b;
+ }
+
+ th {
+ background-color: #142638;
+ }
+
+ th,
+ td {
+ border-bottom-color: #233444;
+ }
+}
diff --git a/src/resources/css/home.css b/src/resources/css/home.css
new file mode 100644
index 00000000..cc135995
--- /dev/null
+++ b/src/resources/css/home.css
@@ -0,0 +1,350 @@
+body {
+ font-family: 'Inter', sans-serif;
+}
+
+.hero {
+ background-image: url('/resources/images/bg-teal.jpg');
+ background-repeat: no-repeat;
+ background-size: cover;
+ padding-bottom: 100px;
+}
+
+h1 {
+ text-transform: uppercase;
+ font-size: 70px;
+ font-family: Montserrat, sans-serif;
+ text-align: center;
+ margin: 70px 0 20px;
+}
+
+h2 {
+ font-size: 28px;
+ font-weight: normal;
+ text-align: center;
+ max-width: 60rem;
+ margin: 0 auto 50px;
+ line-height: 1.5em;
+}
+
+h3 {
+ font-family: Montserrat, sans-serif;
+ font-weight: 400;
+ font-size: 55px;
+}
+
+p {
+ font-size: 20px;
+ max-width: 600px;
+ margin-top: 20px;
+ line-height: 1.5em;
+}
+
+.download-container {
+ text-align: center;
+ margin-top: 50px;
+}
+
+.download-container .button.big {
+ margin-bottom: 15px;
+}
+
+section {
+ padding: 100px 0;
+}
+
+section.alternate:nth-child(even) {
+ background-color: #f5f8f9;
+}
+
+section.alternate:nth-child(odd) .side-by-side {
+ flex-direction: row-reverse;
+}
+
+.side-by-side {
+ width: 100%;
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+}
+
+.side-by-side > * {
+ width: 48%;
+}
+
+.side-by-side img {
+ max-height: 400px;
+}
+
+.code-caption {
+ font-size: 24px;
+ font-weight: bold;
+ margin: 75px auto 20px;
+}
+
+code {
+ font-family: 'PT Mono', monospace;
+}
+
+code.block {
+ display: block;
+ background: #2f2f2f;
+ color: #eee;
+ font-size: 20px;
+ padding-top: 30px;
+ padding-bottom: 30px;
+ line-height: 1.25em;
+ white-space: pre-wrap;
+}
+
+.actions {
+ padding-top: 100px;
+}
+
+code.caddyfile {
+ background-color: #dbebf3;
+ color: black;
+}
+
+.cf-key {
+ color: #d22500;
+ font-weight: bold;
+}
+
+.cf-comment {
+ color: #7291a0;
+}
+
+.cf-dir {
+ color: #006c96;
+ font-weight: bold;
+}
+
+.cf-arg {
+ color: #008000;
+}
+
+.cf-subdir {
+ color: #835234;
+}
+
+code.rest {
+ background-color: #f0f5f4; /*#073d59;*/
+ color: #253a28;
+}
+
+.footnote {
+ font-size: 18px;
+ text-align: center;
+}
+
+iframe.github-stars {
+ margin-left: 20px;
+ vertical-align: middle;
+}
+
+
+@media (max-width: 1100px) {
+ .side-by-side,
+ section.alternate:nth-child(odd) .side-by-side {
+ flex-direction: column;
+ }
+ section.alternate:nth-child(odd) .side-by-side > img {
+ flex-direction: column-reverse;
+ margin-bottom: 50px;
+ }
+
+ .side-by-side-content {
+ margin-bottom: 50px;
+ }
+
+ .side-by-side > * {
+ width: initial;
+ }
+
+ p {
+ max-width: 900px;
+ }
+}
+
+@media (max-width: 900px) {
+ header {
+ flex-direction: column;
+ }
+
+ #logo-container {
+ text-align: center;
+ }
+
+ header nav {
+ text-align: center;
+ }
+
+ h1 {
+ font-size: 50px;
+ word-wrap: break-word;
+ }
+
+ h2 {
+ font-size: 24px;
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* TODO: */
+/* TAKEN FROM features.css */
+
+.features-start {
+ background: linear-gradient(0deg, #13a8f5 0%, #18b125 100%);
+ color: white;
+ padding: 35px 0;
+}
+
+
+.main-features {
+ display: flex;
+ justify-content: space-between;
+ flex-wrap: wrap;
+ padding-top: 2rem;
+}
+
+.main-feature {
+ text-align: center;
+ padding: 0 2rem;
+ margin: 3rem 0;
+ width: 25%;
+}
+
+.main-feature img {
+ height: 130px;
+ margin-bottom: 15px;
+}
+
+.main-feature .title {
+ font-size: 24px;
+ font-weight: bold;
+ margin-bottom: 15px;
+}
+
+.main-feature p {
+ text-align: left;
+ font-size: 16px;
+ margin: 0;
+}
+
+.feature-points {
+ display: flex;
+ justify-content: space-around;
+ flex-wrap: wrap;
+ font-size: 28px;
+}
+
+.feature-point {
+ width: 33.333%;
+ min-width: 300px;
+ padding: 1rem 3rem;
+}
+
+#features-title {
+ width: 80%;
+ max-width: 700px;
+ display: block;
+ margin: 50px auto 0;
+ position: relative;
+ top: 40px;
+}
+
+.features-area h3 {
+ border-bottom: 3px solid #2BABED;
+}
+
+.features-area h4 {
+ text-align: center;
+ padding-top: 80px;
+ padding-bottom: 40px;
+ font-family: Montserrat, sans-serif;
+ font-size: 40px;
+}
+
+.features-area h5 {
+ font-size: 18px;
+ text-transform: uppercase;
+ letter-spacing: 1px;
+}
+
+.section-heading {
+ font-style: italic;
+ font-size: 20px;
+ line-height: 2rem;
+ color: #000;
+ max-width: 550px;
+ text-align: center;
+ margin: 2rem auto 0;
+}
+
+.features {
+ display: flex;
+ flex-wrap: wrap;
+}
+
+.feature {
+ width: 33.333%;
+ padding: 25px;
+}
+
+.feature p {
+ margin-top: 5px;
+ color: #333;
+ font-size: 18px;
+}
+
+@media (max-width: 900px) {
+ .main-feature {
+ width: 50%;
+ margin: 3rem 0;
+ padding: 0 1rem;
+ }
+
+ .feature {
+ width: 50%;
+ }
+}
+
+@media (max-width: 700px) {
+ .pitch {
+ width: 100%;
+ border-right: none;
+ }
+
+ .feature-highlight {
+ padding: 1rem;
+ }
+}
+
+@media (max-width: 500px) {
+ .main-feature {
+ width: 100%;
+ }
+
+ .feature {
+ width: 100%;
+ }
+}
\ No newline at end of file
diff --git a/src/resources/images/ardan-labs.svg b/src/resources/images/ardan-labs.svg
new file mode 100644
index 00000000..c47ccc40
--- /dev/null
+++ b/src/resources/images/ardan-labs.svg
@@ -0,0 +1,84 @@
+
+
+
diff --git a/src/resources/images/bg-teal.jpg b/src/resources/images/bg-teal.jpg
new file mode 100644
index 00000000..9d9ad240
Binary files /dev/null and b/src/resources/images/bg-teal.jpg differ
diff --git a/src/resources/images/box.svg b/src/resources/images/box.svg
new file mode 100644
index 00000000..9cbd9d2b
--- /dev/null
+++ b/src/resources/images/box.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/caddy-circle-lock.svg b/src/resources/images/caddy-circle-lock.svg
new file mode 100644
index 00000000..d9b8a67c
--- /dev/null
+++ b/src/resources/images/caddy-circle-lock.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/caddy-logo.svg b/src/resources/images/caddy-logo.svg
new file mode 100644
index 00000000..499d1f5d
--- /dev/null
+++ b/src/resources/images/caddy-logo.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/caddy-wordmark.svg b/src/resources/images/caddy-wordmark.svg
new file mode 100644
index 00000000..4efab339
--- /dev/null
+++ b/src/resources/images/caddy-wordmark.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/caddyfile-visual.png b/src/resources/images/caddyfile-visual.png
new file mode 100644
index 00000000..f73fb343
Binary files /dev/null and b/src/resources/images/caddyfile-visual.png differ
diff --git a/src/resources/images/favicon.png b/src/resources/images/favicon.png
new file mode 100644
index 00000000..a2581efc
Binary files /dev/null and b/src/resources/images/favicon.png differ
diff --git a/src/resources/images/features.svg b/src/resources/images/features.svg
new file mode 100644
index 00000000..5d199028
--- /dev/null
+++ b/src/resources/images/features.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/moving-parts.svg b/src/resources/images/moving-parts.svg
new file mode 100644
index 00000000..f7e338cd
--- /dev/null
+++ b/src/resources/images/moving-parts.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/padlock.svg b/src/resources/images/padlock.svg
new file mode 100644
index 00000000..4cd15104
--- /dev/null
+++ b/src/resources/images/padlock.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/plug.svg b/src/resources/images/plug.svg
new file mode 100644
index 00000000..59c12bc5
--- /dev/null
+++ b/src/resources/images/plug.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/proxy-file-server.svg b/src/resources/images/proxy-file-server.svg
new file mode 100644
index 00000000..74097c3d
--- /dev/null
+++ b/src/resources/images/proxy-file-server.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/images/stack.svg b/src/resources/images/stack.svg
new file mode 100644
index 00000000..b1859faf
--- /dev/null
+++ b/src/resources/images/stack.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/src/resources/js/docs-json.js b/src/resources/js/docs-json.js
new file mode 100644
index 00000000..988f6d80
--- /dev/null
+++ b/src/resources/js/docs-json.js
@@ -0,0 +1,359 @@
+// TODO: sanitize all HTML renderings, especially markdown: https://github.com/cure53/DOMPurify
+
+function markdown(input) {
+ if (!input) {
+ return "";
+ }
+ return marked(input);
+}
+
+
+$(function() {
+ var $renderbox = $('#renderbox');
+ var $hovercard = $('#hovercard');
+
+ var pageDocs = {}, pageData = {};
+
+ const jsonDocsPathPrefix = "/docs/json/";
+ var configPath = window.location.pathname.substr(jsonDocsPathPrefix.length-1); // keep trailing slash
+
+ // set the page title with something useful
+ var parts = configPath.split("/");
+ if (parts.length > 1) {
+ if (!parts[0]) {
+ parts.shift();
+ }
+ if (!parts[parts.length-1]) {
+ parts.pop();
+ }
+ var titlePrefix = parts.slice(-2).join("/");
+ if (parts.length > 4) {
+ titlePrefix = parts.slice(0, 2).join("/")+"/.../"+titlePrefix;
+ }
+ if (titlePrefix) {
+ document.title = titlePrefix + " - " + document.title;
+ }
+ }
+
+ var hoverTimeout;
+ $hovercard.hover(function() {
+ clearTimeout(hoverTimeout);
+ }, function() {
+ clearTimeout(hoverTimeout);
+ $hovercard.removeClass('popup');
+ });
+
+ $('body').on({
+ mouseenter: function() {
+ // don't allow hoverbox to close anymore, we're re-opening it
+ clearTimeout(hoverTimeout);
+
+ var pos = $(this).position();
+
+ // there is a gap between the hoverbox and the link that originated it;
+ // there may be a different link in this gap; if the hover box is visible,
+ // then we should ignore the hover on this link to allow cursor to visit
+ // the hoverbox if that is where it is going; this makes it possible to
+ // visit the hoverbox while it is over a list of links that are tightly
+ // stacked vertically; if user wants to visit hoverbox for link in this
+ // gap, they can just move the cursor slow enough to fire the timeout
+ if ($hovercard.is(':visible') && $hovercard.position().top - 10 < pos.top) {
+ return;
+ }
+
+ // fill out hovercard
+
+ var elemPath = $(this).data('path');
+ var modNamespace = $(this).data('namespace');
+
+ $('.hovercard-elem').hide();
+
+ if ($(this).hasClass('module')) {
+ // module
+ var $list =$('');
+ if (pageData.namespaces && pageData.namespaces[modNamespace]) {
+ for (var i = 0; i < pageData.namespaces[modNamespace].length; i++) {
+ var modInfo = pageData.namespaces[modNamespace][i];
+ $list.append(''+modInfo.name+''+truncate(modInfo.docs, 115)+'');
+ }
+ }
+ $('#hovercard-module-list').html($list);
+ $('#hovercard-namespace').text(modNamespace)
+ $('#hovercard-module').show();
+
+ } else if ($(this).hasClass('module-inline-key')) {
+ // inline key
+ $('#hovercard-inline-key').show();
+
+ } else if ($(this).hasClass('breadcrumb')) {
+ // breadcrumb siblings
+
+ var siblingPath = $(this).data('sibling-path');
+ var bcVal = pageData.breadcrumb[siblingPath];
+ var bcSiblings = [];
+
+ // drill down to the true underlying type
+ while (bcVal.elems) {
+ bcVal = bcVal.elems;
+ }
+
+ switch (bcVal.type) {
+ case "struct":
+ for (var j = 0; j < bcVal.struct_fields.length; j++) {
+ var sf = bcVal.struct_fields[j];
+ bcSiblings.push({name: sf.key, path: siblingPath})
+ }
+ break;
+
+ case "module":
+ case "module_map":
+ for (var j = 0; j < pageData.namespaces[bcVal.module_namespace].length; j++) {
+ var mod = pageData.namespaces[bcVal.module_namespace][j];
+ bcSiblings.push({name: mod.name, path: siblingPath})
+ }
+ }
+
+ var $siblings = $('').append('');
+ for (var j = 0; j < bcSiblings.length; j++) {
+ var sib = bcSiblings[j];
+ var sibPath = sib.path;
+ if (sibPath) {
+ sibPath += "/";
+ }
+ sibPath += sib.name+"/";
+ $siblings.append(''+sib.name+'');
+ }
+ $('#hovercard-breadcrumb-siblings').html($siblings).show();
+
+ } else if ($(this).hasClass('documented')) {
+ // docs
+ var elemDocs = truncate(pageDocs[elemPath], 500);
+ if (!elemDocs) {
+ elemDocs = '
+
+
+
+ 
+
+
+ Secure by Default
+ + Caddy is the only web server that uses HTTPS by default. A hardened TLS stack with modern protocols preserves privacy and exposes MITM attacks. +
+
+ 
+
+
+ Config API
+ + As its primary mode of configuration, Caddy's REST API makes it easy to automate and integrate with your apps. +
+
+ 
+
+
+ No Dependencies
+ + Because Caddy is written in Go, its binaries are entirely self-contained and run on every platform, including containers without libc. +
+
+ 
+
+
+ Modular Stack
+ + Take back control over your compute edge. Caddy can be extended with everything you need using plugins. +
+
+
+ ✔ Static sites
+ ✔ Dynamic sites
+ ✔ Reverse proxy
+
+
+
+ ✔ Dynamic config
+ ✔ Extensible core
+ ✔ Automagic TLS
+
+ General
++ Caddy 2 was boldly engineered to simplify your infrastructure and give you control over the edge of your compute platform. +
+ + +Architecture
+
+
+
+
+
+
+ Extensible
++ Caddy can embed any Go application as a plugin, and has first-class support for plugins of plugins. +
+
+
+ Minimal Global State
++ Global state is common in servers, but tends to be error-prone and a bottleneck, so Caddy 2 uses a novel design that limits global state. +
+
+
+ Lightweight
++ For all its features, Caddy runs lightly and efficiently with relatively low memory footprint and high throughput. +
+
+
+ Multi-core
++ When the going gets tough, Caddy gets going on more CPUs. Go's scheduler understands Go code, and goroutines are more lightweight than system threads. +
+
+
+ Static Binary
++ Caddy is a single executable file with no dependencies, not even libc. Literally just needs some metal and a kernel. Put Caddy in your PATH and run it. Done. +
+
+
+ Cross-Platform
++ Caddy runs on Windows, macOS, Linux, BSD, Android, Solaris, 32-bit, amd64, ARM, aarch64, mips64... almost anything to which Go compiles. +
+Configuration
+
+
+
+
+
+
+
+
+
+
+ JSON Structure
++ Caddy's native config format is JSON, so it is familiar and highly interoperable with exising systems and tools. +
+
+
+ REST API
++ Caddy's configuration is received through a REST endpoint as a single JSON document, making it highly programmable. +
+
+
+ Config Files Optional
++ You can use config files with Caddy's CLI, which converts them to API requests for you under the hood. +
+
+
+ Config Adapters
++ Bring your own config! Config adapters translate various config formats (Caddyfile, TOML, NGINX, etc.) into Caddy's native JSON. +
+
+
+ The Caddyfile
++ An easy, intuitive way to configure your site. It's not scripting, and not hard to memorize. Rolls off the fingers. You'll really like it. +
+
+
+ Unified Config
++ All configuration is contained within a single JSON document so there are fewer hidden factors affecting your config. +
+
+
+ Partial Updates
++ When you have just small changes to make, Caddy's API lets you update just the relevant parts of its config. +
+
+
+ Fine-Grained Control
++ Caddy's native JSON exposes the actual fields allocated in memory by the running server to give you more control. +
+
+
+ Export
++ You can export a live copy of Caddy's current configuration with a GET request to its API. +
+
+
+ Efficient Reloads
++ Config updates are finely tuned for efficiency so you can reload config dozens of times per second. +
+
+
+ Graceful Reloads
++ Config changes take effect without downtime or closing sockets—even on Windows. +
+
+
+ Config Validation
++ You can use Caddy's CLI to preview and validate configurations before applying them. +
+Basic Features
+
+
+
+
+ The Caddyfile
++ An easy, intuitive way to configure your site. It's not scripting, and not hard to memorize. Rolls off the fingers. You'll really like it. +
+
+
+ Static Files
++ By default, Caddy will serve static files in the current working directory. It's so brilliantly simple and works fast. +
+
+
+ Dynamic Sites
++ Caddy can also be used to serve dynamic sites with templates, proxying, FastCGI, and by the use of plugins. +
+
+
+ Command Line Interface
++ Customize how Caddy runs with its simple, cross-platform command line interface; especially great for quick, one-off server instances. +
+
+
+ Plugins
++ Caddy can be extended with plugins. All apps, Caddyfile directives, HTTP handlers, and other features are plugins! They're easy to write and get compiled in directly. +
+
+
+ Multi-core
++ When the going gets tough, Caddy gets going on more CPUs. Go's scheduler understands Go code, and goroutines are more lightweight than system threads. So yeah, it's fast. +
+
+
+ Embeddable
++ Writing another program or web service that could use a powerful web server or reverse proxy? Caddy can be used like a library in your Go program. +
+
+
+ Caddyfile Validation
++ Caddy can parse and verify your Caddyfile without actually running it. +
+
+
+ Process Log
++ Caddy can write a log of all its significant events, especially errors. Log to a file, stdout/stderr, or a local or remote system log! +
+
+
+ Log Rolling
++ When log files get large, Caddy will automatically rotate them to conserve disk space. +
+Security and Privacy
++ Caddy's flagship features are security and privacy. Caddy is the first and only web server to enable HTTPS automatically and by default. +
+ +TLS
+
+
+
+
+
+ TLS 1.3
++ TLS 1.3 is the newest standard for transport security, which is faster and more secure than its predecessors. +
+
+
+
+ Modern Cipher Suites
++ Caddy uses the best crypto technologies including AES-GCM, ChaCha, and ECC by default, balancing security and compatibility. You can customize which ciphers are allowed. +
+
+
+ Memory Safety
++ Caddy is the only web server in its class that is impervious to bugs like Heartbleed and buffer overflows because it is written in the memory-safe language of Go. +
+
+
+ Client Authentication
++ With TLS client auth, you can configure Caddy to allow only certain clients to connect to your service. +
+
+
+ Hardened Stack
++ Caddy is proudly written in Go, and its TLS stack is powered by the robust crypto/tls package in the Go standard library, trusted by the world's largest content distributors. +
+
+
+ PCI Compliant
++ Companies choose Caddy because its TLS configuration is PCI-compliant by default. It has even saved some companies hours before losing certification! +
+
+
+ Scalable Storage
++ TLS assets are stored on disk, but the storage mechanism can be swapped out for custom implementations so you can deploy and coordinate a fleet of Caddy instances. +
+
+
+ Key Rotation
++ Caddy is cited as the only web server to rotate TLS session ticket keys by default. This helps preserve forward secrecy, i.e. visitor privacy. +
+
+
+ Server Name Indication
++ Caddy uses the TLS extension Server Name Indication (SNI) to be able to host multiple sites on a single interface. Like most features, this just works. +
+
+
+ Redirect HTTP to HTTPS
++ Caddy's automatic HTTPS feature includes redirecting HTTP to HTTPS for you by default. +
+Certificates
+
+
+
+
+
+ Auto Obtain
++ Caddy obtains certificates for you automatically using Let's Encrypt. Any ACME-compatible CA can be used. Caddy was the first web server to implement this technology. +
+
+
+ Auto Renew
++ Never deal with certificates again! Certificates are automatically renewed in the background before they get close to expiring. +
+
+
+ Dynamic Cert Loading
++ Caddy is the only web server that can obtain certificates during a TLS handshake and use it right away. +
+
+
+ Bring Your Own
++ If you still prefer to manage certificates yourself, you can give Caddy your certificate and key files (PEM format) like you're used to. +
+
+
+ Bulk Cert Loading
++ If you manage many certificates yourself, you can give Caddy an entire folder to load certificates from. +
+
+
+ Easy Self-Signed Certs
++ For easy local development and testing, Caddy can generate and manage self-signed certificates for you without any hassle. +
+
+
+ SAN Certificates
++ Caddy fully accepts SAN certificates for times when you may be managing your own SAN certificates and wish to use those instead. +
+
+
+ Cluster Support
++ Caddy can share managed certificates stored on disk with other instances and synchronize renewals in fleet deployments. +
+
+
+ Scalable
++ Caddy's certificate management scales well up to tens of thousands of sites and tens of thousands of certificates per instance. +
+
+
+ Wildcards
++ When needed, Caddy can obtain and renew wildcard certificates for you when you have many related subdomains to serve. +
+OCSP
+
+
+
+
+
+ Stapling
++ Caddy staples OCSP responses to every qualifying certificate by default. Caddy's OCSP stapling is more robust against network failure than other web servers. +
+
+
+ Caching
++ Every OCSP response is cached on disk to preserve integrity through restarts, in case the responder goes down or the network link is being attacked. +
+
+
+ Must-Staple
++ Caddy can be configured to obtain Must-Staple certificates, which requires that certificate to always have the OCSP response stapled. +
+
+
+ Background Updates
++ Unlike other web servers, Caddy updates OCSP responses in the background, asynchronously of any requests, well before their expiration. +
+
+
+ Pre-Validated
++ An OCSP response will not be stapled unless it checks out for validity first, to make sure it's something clients will accept. +
+
+
+ Revocation Handling
++ If a managed certificate is discovered by OCSP to be revoked, Caddy will automatically try to replace the certificate. +
+ACME Protocol
+
+
+
+
+ HTTP Challenge
++ Caddy can solve the HTTP challenge to obtain certificates. You can also configure Caddy to proxy these challenges to other processes. +
+
+
+ TLS-ALPN Challenge
++ Caddy solves the TLS-ALPN challenge which happens on port 443 and does not require opening port 80 at all. +
+
+
+ Fleet Coordination
++ Caddy coordinates the obtaining and renewing of certificates in cluster configurations for both HTTP and TLS-ALPN challenges! +
+
+
+ DNS Challenge
++ Caddy solves the DNS challenge which does not involve opening any ports on the machine. There are integrations for all major DNS providers! +
+
+
+ Revocation
++ If one of your private keys becomes compromised, you can use Caddy to easily revoke the affected certificates. +
+
+
+ Customizable CA
++ Caddy is designed to be used with any ACME-compatible certificate authority, which you can customize with a single command line flag. +
+
+
+ Robust to Failures
++ Caddy is the only web server and only major ACME client that was not disrupted by CA changes and outages, or OCSP responder hiccups. +
+HTTP Server
++ Caddy's HTTP server has a wide array of modern features, high performance, and is easy to deploy. +
+ +Site Features
+
+
+
+
+
+ Directory Browsing
++ List files and folders with Caddy's attractive, practical design or according to your own custom template. +
+
+
+ Virtual Hosts
++ Serve multiple sites from the same IP address with the Caddyfile. +
+
+
+ Configurable Binding
++ You can select which network interfaces to which you bind the listener, giving you more access control over your site. +
+
+
+ Markdown
++ Let Caddy render your Markdown files as HTML on-the-fly. You can embed your Markdown in a template and parse out front matter. +
+
+
+ Templates
++ A powerful and improved alternative to Server-Side Includes, templates allow you to make semi-dynamic sites quickly and easily. +
+
+
+ Custom Error Pages
++ Show user-friendly error pages when things go wrong, or write the error details to the browser for dev environments. +
+
+
+
+
+ Logging
++ Caddy takes copious notes according to your favorite log format. Log errors and requests to a file, stdout/stderr, or a local or remote system log. +
+
+
+ Request Size Limits
++ You can limit the size of request bodies that go through Caddy to prevent abuse of your network bandwidth. +
+
+
+ Timeouts
++ Enabling timeouts can be a good idea when your server may be prone to slowloris attacks or you want to free up resources from slow networks. +
+Web Protocols
+
+
+
+
+
+ HTTP/1.1
++ Still commonly used in plaintext, development, and debug environments, Caddy has solid support for HTTP/1.1. +
+
+
+ HTTP/2
++ It's time for a faster web. Caddy uses HTTP/2 right out of the box. No thought required. HTTP/1.1 is still used when clients don't support HTTP/2. +
+
+
+ HTTP/3
++ With the IETF-standard-draft version of QUIC, sites load faster and connections aren't dropped when switching networks. +
+
+
+ WebSockets
++ Caddy supports making WebSocket connections directly to local programs' stdin/stdout streams that work a little bit like CGI. +
+
+
+ IPv6
++ Caddy supports both IPv4 and IPv6. In fact, Caddy runs full well in an IPv6 environment without extra configuration. +
+
+
+ FastCGI
++ Serve your PHP site behind Caddy securely with just one simple line of configuration. You can even specify multiple backends. +
+HTTP Spec
+
+
+
+
+
+
+ Basic Authentication
++ Protect areas of your site with HTTP basic auth. It's simple to use and secure over HTTPS for most purposes. +
+
+
+ Redirects
+
+ Caddy can issue HTTP redirects with any 3xx status code, including redirects using <meta> tags if you prefer.
+
+
+ Headers
++ Customize the response headers so that some headers are removed or others are added. +
+Reverse Proxy
+
+
+
+
+
+ Basic Proxying
++ Caddy can act as a reverse proxy for HTTP requests. You can also proxy transparently (preserve the original Host header) with one line of config. +
+
+
+ Load Balancing
++ Proxy to multiple backends using a load balancing policy of your choice: random, least connections, round robin, IP hash, or header. +
+
+
+ SSL Termination
++ Caddy is frequently used as a TLS terminator because of its powerful TLS features. +
+
+
+ WebSocket Proxy
++ Caddy's proxy middleware is capable of proxying websocket connections to backends as well. +
+
+
+ Health Checks
++ Caddy marks backends in trouble as unhealthy, and you can configure health check paths, intervals, and timeouts for optimal performance. +
+
+
+ Retries
++ When a request to a backend fails to connect, Caddy will try the request with other backends until one that is online accepts the connection. +
+
+
+
+ Header Controls
++ By default, most headers will be carried through, but you can control which headers flow upstream and downstream. +
+
+
+ Dynamic Backends
++ Proxy to arbitrary backends based on request parameters such as parts of the domain name or header values. +
+Amenities
+
+
+
+
+ Clean URIs
++ Elegantly serve files without needing the extension present in the URL. These look nicer to visitors and are easy to configure. +
+
+
+ Rewrites
++ Caddy has powerful request URI rewriting capabilities that support regular expressions, conditionals, and dynamic values. +
+
+
+ Response Status Codes
++ Send a certain status code for certain requests. +
+
+
+ Compression
++ Compress content on-the-fly using gzip, Zstandard, or brotli. +
+
+
+
+
+ There are no docs for this property.
'; + return; + } + $('#hovercard-docs').html(markdown(elemDocs)).show(); + $('#hovercard-inline-link').html('View docs below ↓').show(); + } + + // show hoverbox for this link + var height = $(this).height(); + var linkWidth = $(this).width(); + var boxWidth = $hovercard.width(); + $hovercard.css({ + 'top': pos.top + height*1.5 + 10, // '+10' counters 'translateY(-10px)' + 'left': pos.left + (linkWidth/2) - (boxWidth/2) + }).addClass('popup'); + }, + mouseleave: function() { + // don't hide the hoverbox right away; user might need a + // few milliseconds to get the cursor over the hovercard + hoverTimeout = setTimeout(function() { + $hovercard.removeClass('popup'); + }, 200); + } + }, '.has-popup'); + + var pathComponents = configPath.split('/'); + + // load the docs for this path + $.get("/api/docs/config"+configPath, function(json) { + pageData = json; + if (pageData.structure.doc) { + // for most types, just render their docs + $('#top-doc').html(markdown(pageData.structure.doc)); + } else if (pageData.structure.elems) { + // for maps or arrays, fall through to the underlying type + $('#top-doc').html(markdown(pageData.structure.elems.doc)); + } + $('#top-doc').append(makeSubmoduleList("", pageData.structure)); + + console.log("DATA:", pageData); + renderData(pageData.structure, 0, "", $('')); + console.log("DOCS:", pageDocs); + + if ($('#field-list').html().trim()) { + $('#field-list-header').show(); + } + + // establish the breadcrumb + var $bc = $('.breadcrumbs'); + $('JSON Config Structure ›').appendTo($bc); + for (var i = 1; i < pathComponents.length-1; i++) { + var bcPath = pathComponents.slice(0, i+1).join('/'); + var bcSiblingPath = pathComponents.slice(1, i).join('/'); + + // prefixing with is a hack so jQuery treats this as a HTML DOM object + $(' › '+pathComponents[i]+'').appendTo($bc); + } + }); + + function renderData(data, nesting, path, $group) { + switch (data.type) { + case "struct": + $group.append('{▾'); + nesting++; + + var $fieldGroup = $(''); + renderModuleInlineKey(data, nesting, $fieldGroup); + $group.append($fieldGroup); + + if (data.struct_fields) { + // TODO: Not sure if sorting the struct fields is a good idea... + // data.struct_fields.sort(function(a, b) { + // if (a.key > b.key) return 1; + // if (b.key > a.key) return -1; + // return 0; + // }); + for (var i = 0; i < data.struct_fields.length; i++) { + var field = data.struct_fields[i]; + var fieldPath = path+"/"+field.key; + var cleanFieldPath = fieldPath.slice(1); // trim leading slash + + // store the docs for this path + let linkClass = "documented"; + if (field.doc) { + pageDocs[fieldPath] = field.doc; + linkClass += " has-popup"; + } + + // render the docs to the page + var fieldDoc = markdown(field.doc) || 'There are no docs for this property.
'; + fieldDoc += makeSubmoduleList(fieldPath, field.value); + appendToFieldDocs(cleanFieldPath, fieldDoc); + + // render the field to the JSON box + var $fieldGroup = $(''); + indent(nesting, $fieldGroup); + $fieldGroup.append('"'+field.key+'": '); + renderData(field.value, nesting, fieldPath, $fieldGroup); + if (i < data.struct_fields.length-1) { + $fieldGroup.append(','); + } + $group.append($fieldGroup); + } + } + nesting--; + indent(nesting, $group); + $group.append('}'); + break; + + case "bool": + $group.append('false'); // TODO: default value? + break; + + case "int": + case "uint": + case "float": + case "complex": + $group.append('0'); // TODO: default value? + break; + + case "string": + $group.append('""'); // TODO: default value? + break; + + case "array": + $group.append('['); + if (data.elems.type == "module_map") { + $group.append('{•••}'); + } else { + renderData(data.elems, nesting, path, $group); + } + $group.append(']'); + break; + + case "map": + $group.append('{\n') + nesting++; + renderModuleInlineKey(data, nesting, $group); + indent(nesting, $group); + renderData(data.map_keys, nesting, path, $group); + $group.append(': '); + renderData(data.elems, nesting, path, $group); + $group.append('\n'); + nesting--; + indent(nesting, $group); + $group.append('}'); + break; + + case "module": + // TODO: + $group.append('{•••}'); + break; + + case "module_map": + // TODO: + $group.append('{•••}'); + break; + } + + $renderbox.append($group); + } + + function renderModuleInlineKey(data, nesting, $group) { + if (!data.module_inline_key) { + return + } + var moduleName = pathComponents[pathComponents.length-2]; + indent(nesting, $group); + $group.append('"'+data.module_inline_key+'": "'+moduleName+'"'); + if (data.struct_fields && data.struct_fields.length > 0) { + $group.append(','); + } + $group.append('\n'); + + appendToFieldDocs(data.module_inline_key, $('#hovercard-inline-key').html()); + } + + function appendToFieldDocs(cleanFieldPath, fieldDoc) { + $('#field-list').append('- ';
+ if (pageData.namespaces && pageData.namespaces[value.module_namespace]) {
+ for (var j = 0; j < pageData.namespaces[value.module_namespace].length; j++) {
+ var submod = pageData.namespaces[value.module_namespace][j];
+ submodList += '
- '+submod.name+' '; + } + } + submodList += '
Fulfilled by modules in namespace: '+value.module_namespace+'
'+submodList+''+(n?e:N(e,!0))+"\n":""+(n?e:N(e,!0))+"\n"+e+"\n"},t.html=function(e){return e},t.heading=function(e,t,n,r){return this.options.headerIds?"
\n":"
\n"},t.list=function(e,t,n){var r=t?"ol":"ul";return"<"+r+(t&&1!==n?' start="'+n+'"':"")+">\n"+e+"\n"},t.listitem=function(e){return"
"+e+"
\n"},t.table=function(e,t){return""+e+""},t.br=function(){return this.options.xhtml?"":"
"},t.del=function(e){return"
"+se(e.message+"",!0)+"";throw e}}return oe.options=oe.setOptions=function(e){return ne(oe.defaults,e),le(oe.defaults),oe},oe.getDefaults=ie,oe.defaults=ae,oe.Parser=te,oe.parser=te.parse,oe.Renderer=X,oe.TextRenderer=Q,oe.Lexer=B,oe.lexer=B.lex,oe.InlineLexer=K,oe.inlineLexer=K.output,oe.Slugger=G,oe.parse=oe}); \ No newline at end of file