Initial commit

kirby/config/aliases.php

@@ -0,0 +1,62 @@
+<?php
+
+// @codeCoverageIgnoreStart
+return [
+    // cms classes
+    'asset'      => 'Kirby\Cms\Asset',
+    'collection' => 'Kirby\Cms\Collection',
+    'dir'        => 'Kirby\Cms\Dir',
+    'field'      => 'Kirby\Cms\Field',
+    'file'       => 'Kirby\Cms\File',
+    'files'      => 'Kirby\Cms\Files',
+    'html'       => 'Kirby\Cms\Html',
+    'kirby'      => 'Kirby\Cms\App',
+    'page'       => 'Kirby\Cms\Page',
+    'pages'      => 'Kirby\Cms\Pages',
+    'pagination' => 'Kirby\Cms\Pagination',
+    'r'          => 'Kirby\Cms\R',
+    'response'   => 'Kirby\Cms\Response',
+    's'          => 'Kirby\Cms\S',
+    'site'       => 'Kirby\Cms\Site',
+    'structure'  => 'Kirby\Cms\Structure',
+    'url'        => 'Kirby\Cms\Url',
+    'user'       => 'Kirby\Cms\User',
+    'users'      => 'Kirby\Cms\Users',
+    'visitor'    => 'Kirby\Cms\Visitor',
+
+    // data handler
+    'data'      => 'Kirby\Data\Data',
+    'json'      => 'Kirby\Data\Json',
+    'yaml'      => 'Kirby\Data\Yaml',
+
+    // data classes
+    'database'  => 'Kirby\Database\Database',
+    'db'        => 'Kirby\Database\Db',
+
+    // exceptions
+    'errorpageexception' => 'Kirby\Exception\ErrorPageException',
+
+    // http classes
+    'cookie'     => 'Kirby\Http\Cookie',
+    'header'     => 'Kirby\Http\Header',
+    'remote'     => 'Kirby\Http\Remote',
+    'server'     => 'Kirby\Http\Server',
+
+    // image classes
+    'dimensions' => 'Kirby\Image\Dimensions',
+
+    // toolkit classes
+    'a'          => 'Kirby\Toolkit\A',
+    'c'          => 'Kirby\Toolkit\Config',
+    'config'     => 'Kirby\Toolkit\Config',
+    'escape'     => 'Kirby\Toolkit\Escape',
+    'f'          => 'Kirby\Toolkit\F',
+    'i18n'       => 'Kirby\Toolkit\I18n',
+    'mime'       => 'Kirby\Toolkit\Mime',
+    'obj'        => 'Kirby\Toolkit\Obj',
+    'str'        => 'Kirby\Toolkit\Str',
+    'tpl'        => 'Kirby\Toolkit\Tpl',
+    'v'          => 'Kirby\Toolkit\V',
+    'xml'        => 'Kirby\Toolkit\Xml'
+];
+// @codeCoverageIgnoreEnd

kirby/config/api/authentication.php

@@ -0,0 +1,24 @@
+<?php
+
+use Kirby\Exception\PermissionException;
+
+return function () {
+    $auth               = $this->kirby()->auth();
+    $allowImpersonation = $this->kirby()->option('api.allowImpersonation') ?? false;
+
+    // csrf token check
+    if ($auth->type($allowImpersonation) === 'session' && $auth->csrf() === false) {
+        throw new PermissionException('Unauthenticated');
+    }
+
+    // get user from session or basic auth
+    if ($user = $auth->user(null, $allowImpersonation)) {
+        if ($user->role()->permissions()->for('access', 'panel') === false) {
+            throw new PermissionException(['key' => 'access.panel']);
+        }
+
+        return $user;
+    }
+
+    throw new PermissionException('Unauthenticated');
+};

kirby/config/api/collections.php

@@ -0,0 +1,72 @@
+<?php
+
+/**
+ * Api Collection Definitions
+ */
+return [
+
+    /**
+     * Children
+     */
+    'children' => [
+        'model' => 'page',
+        'type'  => 'Kirby\Cms\Pages',
+        'view'  => 'compact'
+    ],
+
+    /**
+     * Files
+     */
+    'files' => [
+        'model' => 'file',
+        'type'  => 'Kirby\Cms\Files'
+    ],
+
+    /**
+     * Languages
+     */
+    'languages' => [
+        'model' => 'language',
+        'type'  => 'Kirby\Cms\Languages'
+    ],
+
+    /**
+     * Pages
+     */
+    'pages' => [
+        'model' => 'page',
+        'type'  => 'Kirby\Cms\Pages',
+        'view'  => 'compact'
+    ],
+
+    /**
+     * Roles
+     */
+    'roles' => [
+        'model' => 'role',
+        'type'  => 'Kirby\Cms\Roles',
+        'view'  => 'compact'
+    ],
+
+    /**
+     * Translations
+     */
+    'translations' => [
+        'model' => 'translation',
+        'type'  => 'Kirby\Cms\Translations',
+        'view'  => 'compact'
+    ],
+
+    /**
+     * Users
+     */
+    'users' => [
+        'default' => function () {
+            return $this->users();
+        },
+        'model' => 'user',
+        'type'  => 'Kirby\Cms\Users',
+        'view'  => 'compact'
+    ]
+
+];

kirby/config/api/models.php

@@ -0,0 +1,20 @@
+<?php
+
+/**
+ * Api Model Definitions
+ */
+return [
+    'File'          => include __DIR__ . '/models/File.php',
+    'FileBlueprint' => include __DIR__ . '/models/FileBlueprint.php',
+    'FileVersion'   => include __DIR__ . '/models/FileVersion.php',
+    'Language'      => include __DIR__ . '/models/Language.php',
+    'Page'          => include __DIR__ . '/models/Page.php',
+    'PageBlueprint' => include __DIR__ . '/models/PageBlueprint.php',
+    'Role'          => include __DIR__ . '/models/Role.php',
+    'Site'          => include __DIR__ . '/models/Site.php',
+    'SiteBlueprint' => include __DIR__ . '/models/SiteBlueprint.php',
+    'System'        => include __DIR__ . '/models/System.php',
+    'Translation'   => include __DIR__ . '/models/Translation.php',
+    'User'          => include __DIR__ . '/models/User.php',
+    'UserBlueprint' => include __DIR__ . '/models/UserBlueprint.php',
+];

kirby/config/api/models/File.php

@@ -0,0 +1,166 @@
+<?php
+
+use Kirby\Cms\File;
+use Kirby\Cms\Form;
+
+/**
+ * File
+ */
+return [
+    'fields' => [
+        'blueprint' => function (File $file) {
+            return $file->blueprint();
+        },
+        'content' => function (File $file) {
+            return Form::for($file)->values();
+        },
+        'dimensions' => function (File $file) {
+            return $file->dimensions()->toArray();
+        },
+        'dragText' => function (File $file) {
+            return $file->dragText();
+        },
+        'exists' => function (File $file) {
+            return $file->exists();
+        },
+        'extension' => function (File $file) {
+            return $file->extension();
+        },
+        'filename' => function (File $file) {
+            return $file->filename();
+        },
+        'id' => function (File $file) {
+            return $file->id();
+        },
+        'link' => function (File $file) {
+            return $file->panelUrl(true);
+        },
+        'mime' => function (File $file) {
+            return $file->mime();
+        },
+        'modified' => function (File $file) {
+            return $file->modified('c');
+        },
+        'name' => function (File $file) {
+            return $file->name();
+        },
+        'next' => function (File $file) {
+            return $file->next();
+        },
+        'nextWithTemplate' => function (File $file) {
+            $files = $file->templateSiblings()->sort('sort', 'asc', 'filename', 'asc');
+            $index = $files->indexOf($file);
+
+            return $files->nth($index + 1);
+        },
+        'niceSize' => function (File $file) {
+            return $file->niceSize();
+        },
+        'options' => function (File $file) {
+            return $file->panelOptions();
+        },
+        'panelIcon' => function (File $file) {
+            return $file->panelIcon();
+        },
+        'panelImage' => function (File $file) {
+            return $file->panelImage();
+        },
+        'panelUrl' => function (File $file) {
+            return $file->panelUrl(true);
+        },
+        'prev' => function (File $file) {
+            return $file->prev();
+        },
+        'prevWithTemplate' => function (File $file) {
+            $files = $file->templateSiblings()->sort('sort', 'asc', 'filename', 'asc');
+            $index = $files->indexOf($file);
+
+            return $files->nth($index - 1);
+        },
+        'parent' => function (File $file) {
+            return $file->parent();
+        },
+        'parents' => function (File $file) {
+            return $file->parents()->flip();
+        },
+        'size' => function (File $file) {
+            return $file->size();
+        },
+        'template' => function (File $file) {
+            return $file->template();
+        },
+        'thumbs' => function ($file) {
+            if ($file->isResizable() === false) {
+                return null;
+            }
+
+            return [
+                'tiny'   => $file->resize(128)->url(),
+                'small'  => $file->resize(256)->url(),
+                'medium' => $file->resize(512)->url(),
+                'large'  => $file->resize(768)->url(),
+                'huge'   => $file->resize(1024)->url(),
+            ];
+        },
+        'type' => function (File $file) {
+            return $file->type();
+        },
+        'url' => function (File $file) {
+            return $file->url(true);
+        },
+    ],
+    'type'  => 'Kirby\Cms\File',
+    'views' => [
+        'default' => [
+            'content',
+            'dimensions',
+            'exists',
+            'extension',
+            'filename',
+            'id',
+            'link',
+            'mime',
+            'modified',
+            'name',
+            'next' => 'compact',
+            'niceSize',
+            'parent' => 'compact',
+            'options',
+            'prev' => 'compact',
+            'size',
+            'template',
+            'type',
+            'url'
+        ],
+        'compact' => [
+            'filename',
+            'id',
+            'link',
+            'type',
+            'url',
+        ],
+        'panel' => [
+            'blueprint',
+            'content',
+            'dimensions',
+            'extension',
+            'filename',
+            'id',
+            'link',
+            'mime',
+            'modified',
+            'name',
+            'nextWithTemplate' => 'compact',
+            'niceSize',
+            'options',
+            'panelIcon',
+            'panelImage',
+            'parent' => 'compact',
+            'parents' => ['id', 'slug', 'title'],
+            'prevWithTemplate' => 'compact',
+            'template',
+            'type',
+            'url'
+        ]
+    ],
+];

kirby/config/api/models/FileBlueprint.php

@@ -0,0 +1,26 @@
+<?php
+
+use Kirby\Cms\FileBlueprint;
+
+/**
+ * FileBlueprint
+ */
+return [
+    'fields' => [
+        'name' => function (FileBlueprint $blueprint) {
+            return $blueprint->name();
+        },
+        'options' => function (FileBlueprint $blueprint) {
+            return $blueprint->options();
+        },
+        'tabs' => function (FileBlueprint $blueprint) {
+            return $blueprint->tabs();
+        },
+        'title' => function (FileBlueprint $blueprint) {
+            return $blueprint->title();
+        },
+    ],
+    'type' => 'Kirby\Cms\FileBlueprint',
+    'views' => [
+    ],
+];

kirby/config/api/models/FileVersion.php

@@ -0,0 +1,83 @@
+<?php
+
+use Kirby\Cms\FileVersion;
+
+/**
+ * FileVersion
+ */
+return [
+    'fields' => [
+        'dimensions' => function (FileVersion $file) {
+            return $file->dimensions()->toArray();
+        },
+        'exists' => function (FileVersion $file) {
+            return $file->exists();
+        },
+        'extension' => function (FileVersion $file) {
+            return $file->extension();
+        },
+        'filename' => function (FileVersion $file) {
+            return $file->filename();
+        },
+        'id' => function (FileVersion $file) {
+            return $file->id();
+        },
+        'mime' => function (FileVersion $file) {
+            return $file->mime();
+        },
+        'modified' => function (FileVersion $file) {
+            return $file->modified('c');
+        },
+        'name' => function (FileVersion $file) {
+            return $file->name();
+        },
+        'niceSize' => function (FileVersion $file) {
+            return $file->niceSize();
+        },
+        'size' => function (FileVersion $file) {
+            return $file->size();
+        },
+        'type' => function (FileVersion $file) {
+            return $file->type();
+        },
+        'url' => function (FileVersion $file) {
+            return $file->url(true);
+        },
+    ],
+    'type'  => 'Kirby\Cms\FileVersion',
+    'views' => [
+        'default' => [
+            'dimensions',
+            'exists',
+            'extension',
+            'filename',
+            'id',
+            'mime',
+            'modified',
+            'name',
+            'niceSize',
+            'size',
+            'type',
+            'url'
+        ],
+        'compact' => [
+            'filename',
+            'id',
+            'type',
+            'url',
+        ],
+        'panel' => [
+            'dimensions',
+            'extension',
+            'filename',
+            'id',
+            'mime',
+            'modified',
+            'name',
+            'niceSize',
+            'template',
+            'type',
+            'url'
+        ]
+    ],
+];

kirby/config/api/models/Language.php

@@ -0,0 +1,44 @@
+<?php
+
+use Kirby\Cms\Language;
+
+/**
+ * Language
+ */
+return [
+    'fields' => [
+        'code' => function (Language $language) {
+            return $language->code();
+        },
+        'default' => function (Language $language) {
+            return $language->isDefault();
+        },
+        'direction' => function (Language $language) {
+            return $language->direction();
+        },
+        'locale' => function (Language $language) {
+            return $language->locale();
+        },
+        'name' => function (Language $language) {
+            return $language->name();
+        },
+        'rules' => function (Language $language) {
+            return $language->rules();
+        },
+        'url' => function (Language $language) {
+            return $language->url();
+        },
+    ],
+    'type'  => 'Kirby\Cms\Language',
+    'views' => [
+        'default' => [
+            'code',
+            'default',
+            'direction',
+            'locale',
+            'name',
+            'rules',
+            'url'
+        ]
+    ]
+];

kirby/config/api/models/Page.php

@@ -0,0 +1,157 @@
+<?php
+
+use Kirby\Cms\Form;
+use Kirby\Cms\Page;
+
+/**
+ * Page
+ */
+return [
+    'fields' => [
+        'blueprint' => function (Page $page) {
+            return $page->blueprint();
+        },
+        'blueprints' => function (Page $page) {
+            return $page->blueprints();
+        },
+        'children' => function (Page $page) {
+            return $page->children();
+        },
+        'content' => function (Page $page) {
+            return Form::for($page)->values();
+        },
+        'drafts' => function (Page $page) {
+            return $page->drafts();
+        },
+        'errors' => function (Page $page) {
+            return $page->errors();
+        },
+        'files' => function (Page $page) {
+            return $page->files()->sort('sort', 'asc', 'filename', 'asc');
+        },
+        'hasChildren' => function (Page $page) {
+            return $page->hasChildren();
+        },
+        'hasDrafts' => function (Page $page) {
+            return $page->hasDrafts();
+        },
+        'hasFiles' => function (Page $page) {
+            return $page->hasFiles();
+        },
+        'id' => function (Page $page) {
+            return $page->id();
+        },
+        'isSortable' => function (Page $page) {
+            return $page->isSortable();
+        },
+        'next' => function (Page $page) {
+            return $page
+                ->nextAll()
+                ->filter('intendedTemplate', $page->intendedTemplate())
+                ->filter('status', $page->status())
+                ->filter('isReadable', true)
+                ->first();
+        },
+        'num' => function (Page $page) {
+            return $page->num();
+        },
+        'options' => function (Page $page) {
+            return $page->panelOptions(['preview']);
+        },
+        'panelIcon' => function (Page $page) {
+            return $page->panelIcon();
+        },
+        'panelImage' => function (Page $page) {
+            return $page->panelImage();
+        },
+        'parent' => function (Page $page) {
+            return $page->parent();
+        },
+        'parents' => function (Page $page) {
+            return $page->parents()->flip();
+        },
+        'prev' => function (Page $page) {
+            return $page
+                ->prevAll()
+                ->filter('intendedTemplate', $page->intendedTemplate())
+                ->filter('status', $page->status())
+                ->filter('isReadable', true)
+                ->last();
+        },
+        'previewUrl' => function (Page $page) {
+            return $page->previewUrl();
+        },
+        'siblings' => function (Page $page) {
+            if ($page->isDraft() === true) {
+                return $page->parentModel()->children()->not($page);
+            } else {
+                return $page->siblings();
+            }
+        },
+        'slug' => function (Page $page) {
+            return $page->slug();
+        },
+        'status' => function (Page $page) {
+            return $page->status();
+        },
+        'template' => function (Page $page) {
+            return $page->intendedTemplate()->name();
+        },
+        'title' => function (Page $page) {
+            return $page->title()->value();
+        },
+        'url' => function (Page $page) {
+            return $page->url();
+        },
+    ],
+    'type' => 'Kirby\Cms\Page',
+    'views' => [
+        'compact' => [
+            'id',
+            'title',
+            'url',
+            'num'
+        ],
+        'default' => [
+            'content',
+            'id',
+            'status',
+            'num',
+            'options',
+            'parent' => 'compact',
+            'slug',
+            'template',
+            'title',
+            'url'
+        ],
+        'panel' => [
+            'id',
+            'blueprint',
+            'content',
+            'status',
+            'options',
+            'next'    => ['id', 'slug', 'title'],
+            'parents' => ['id', 'slug', 'title'],
+            'prev'    => ['id', 'slug', 'title'],
+            'previewUrl',
+            'slug',
+            'title',
+            'url'
+        ],
+        'selector' => [
+            'id',
+            'title',
+            'parent' => [
+                'id',
+                'title'
+            ],
+            'children' => [
+                'hasChildren',
+                'id',
+                'panelIcon',
+                'panelImage',
+                'title',
+            ],
+        ]
+    ],
+];

kirby/config/api/models/PageBlueprint.php

@@ -0,0 +1,35 @@
+<?php
+
+use Kirby\Cms\PageBlueprint;
+
+/**
+ * PageBlueprint
+ */
+return [
+    'fields' => [
+        'name' => function (PageBlueprint $blueprint) {
+            return $blueprint->name();
+        },
+        'num' => function (PageBlueprint $blueprint) {
+            return $blueprint->num();
+        },
+        'options' => function (PageBlueprint $blueprint) {
+            return $blueprint->options();
+        },
+        'preview' => function (PageBlueprint $blueprint) {
+            return $blueprint->preview();
+        },
+        'status' => function (PageBlueprint $blueprint) {
+            return $blueprint->status();
+        },
+        'tabs' => function (PageBlueprint $blueprint) {
+            return $blueprint->tabs();
+        },
+        'title' => function (PageBlueprint $blueprint) {
+            return $blueprint->title();
+        },
+    ],
+    'type' => 'Kirby\Cms\PageBlueprint',
+    'views' => [
+    ],
+];

kirby/config/api/models/Role.php

@@ -0,0 +1,31 @@
+<?php
+
+use Kirby\Cms\Role;
+
+/**
+ * Role
+ */
+return [
+    'fields' => [
+        'description' => function (Role $role) {
+            return $role->description();
+        },
+        'name' => function (Role $role) {
+            return $role->name();
+        },
+        'permissions' => function (Role $role) {
+            return $role->permissions()->toArray();
+        },
+        'title' => function (Role $role) {
+            return $role->title();
+        },
+    ],
+    'type'  => 'Kirby\Cms\Role',
+    'views' => [
+        'compact' => [
+            'description',
+            'name',
+            'title'
+        ]
+    ]
+];

kirby/config/api/models/Site.php

@@ -0,0 +1,72 @@
+<?php
+
+use Kirby\Cms\Form;
+use Kirby\Cms\Site;
+
+/**
+ * Site
+ */
+return [
+    'default' => function () {
+        return $this->site();
+    },
+    'fields' => [
+        'blueprint' => function (Site $site) {
+            return $site->blueprint();
+        },
+        'children' => function (Site $site) {
+            return $site->children();
+        },
+        'content' => function (Site $site) {
+            return Form::for($site)->values();
+        },
+        'drafts' => function (Site $site) {
+            return $site->drafts();
+        },
+        'files' => function (Site $site) {
+            return $site->files()->sort('sort', 'asc', 'filename', 'asc');
+        },
+        'options' => function (Site $site) {
+            return $site->permissions()->toArray();
+        },
+        'previewUrl' => function (Site $site) {
+            return $site->previewUrl();
+        },
+        'title' => function (Site $site) {
+            return $site->title()->value();
+        },
+        'url' => function (Site $site) {
+            return $site->url();
+        },
+    ],
+    'type' => 'Kirby\Cms\Site',
+    'views' => [
+        'compact' => [
+            'title',
+            'url'
+        ],
+        'default' => [
+            'content',
+            'options',
+            'title',
+            'url'
+        ],
+        'panel' => [
+            'title',
+            'blueprint',
+            'content',
+            'options',
+            'previewUrl',
+            'url'
+        ],
+        'selector' => [
+            'title',
+            'children' => [
+                'id',
+                'title',
+                'panelIcon',
+                'hasChildren'
+            ],
+        ]
+    ]
+];

kirby/config/api/models/SiteBlueprint.php

@@ -0,0 +1,26 @@
+<?php
+
+use Kirby\Cms\SiteBlueprint;
+
+/**
+ * SiteBlueprint
+ */
+return [
+    'fields' => [
+        'name' => function (SiteBlueprint $blueprint) {
+            return $blueprint->name();
+        },
+        'options' => function (SiteBlueprint $blueprint) {
+            return $blueprint->options();
+        },
+        'tabs' => function (SiteBlueprint $blueprint) {
+            return $blueprint->tabs();
+        },
+        'title' => function (SiteBlueprint $blueprint) {
+            return $blueprint->title();
+        },
+    ],
+    'type' => 'Kirby\Cms\SiteBlueprint',
+    'views' => [
+    ],
+];

kirby/config/api/models/System.php

@@ -0,0 +1,136 @@
+<?php
+
+use Kirby\Cms\System;
+use Kirby\Toolkit\Str;
+
+/**
+ * System
+ */
+return [
+    'fields' => [
+        'ascii' => function () {
+            return Str::$ascii;
+        },
+        'authStatus' => function () {
+            return $this->kirby()->auth()->status()->toArray();
+        },
+        'defaultLanguage' => function () {
+            return $this->kirby()->panelLanguage();
+        },
+        'isOk' => function (System $system) {
+            return $system->isOk();
+        },
+        'isInstallable' => function (System $system) {
+            return $system->isInstallable();
+        },
+        'isInstalled' => function (System $system) {
+            return $system->isInstalled();
+        },
+        'isLocal' => function (System $system) {
+            return $system->isLocal();
+        },
+        'multilang' => function () {
+            return $this->kirby()->option('languages', false) !== false;
+        },
+        'languages' => function () {
+            return $this->kirby()->languages();
+        },
+        'license' => function (System $system) {
+            return $system->license();
+        },
+        'locales' => function () {
+            $locales = [];
+            $translations = $this->kirby()->translations();
+            foreach ($translations as $translation) {
+                $locales[$translation->code()] = $translation->locale();
+            }
+            return $locales;
+        },
+        'loginMethods' => function (System $system) {
+            return array_keys($system->loginMethods());
+        },
+        'requirements' => function (System $system) {
+            return $system->toArray();
+        },
+        'site' => function () {
+            try {
+                return $this->site()->blueprint()->title();
+            } catch (Throwable $e) {
+                return $this->site()->title()->value();
+            }
+        },
+        'slugs' => function () {
+            return Str::$language;
+        },
+        'title' => function () {
+            return $this->site()->title()->value();
+        },
+        'translation' => function () {
+            if ($user = $this->user()) {
+                $translationCode = $user->language();
+            } else {
+                $translationCode = $this->kirby()->panelLanguage();
+            }
+
+            if ($translation = $this->kirby()->translation($translationCode)) {
+                return $translation;
+            } else {
+                return $this->kirby()->translation('en');
+            }
+        },
+        'kirbytext' => function () {
+            return $this->kirby()->option('panel.kirbytext') ?? true;
+        },
+        'user' => function () {
+            return $this->user();
+        },
+        'version' => function () {
+            $user = $this->user();
+
+            if ($user && $user->role()->permissions()->for('access', 'settings') === true) {
+                return $this->kirby()->version();
+            } else {
+                return null;
+            }
+        }
+    ],
+    'type'   => 'Kirby\Cms\System',
+    'views'  => [
+        'login' => [
+            'authStatus',
+            'isOk',
+            'isInstallable',
+            'isInstalled',
+            'loginMethods',
+            'title',
+            'translation'
+        ],
+        'troubleshooting' => [
+            'isOk',
+            'isInstallable',
+            'isInstalled',
+            'title',
+            'translation',
+            'requirements'
+        ],
+        'panel' => [
+            'ascii',
+            'defaultLanguage',
+            'isOk',
+            'isInstalled',
+            'isLocal',
+            'kirbytext',
+            'languages',
+            'license',
+            'locales',
+            'multilang',
+            'requirements',
+            'site',
+            'slugs',
+            'title',
+            'translation',
+            'user' => 'auth',
+            'version'
+        ]
+    ],
+];

kirby/config/api/models/Translation.php

@@ -0,0 +1,34 @@
+<?php
+
+use Kirby\Cms\Translation;
+
+/**
+ * Translation
+ */
+return [
+    'fields' => [
+        'author' => function (Translation $translation) {
+            return $translation->author();
+        },
+        'data' => function (Translation $translation) {
+            return $translation->dataWithFallback();
+        },
+        'direction' => function (Translation $translation) {
+            return $translation->direction();
+        },
+        'id' => function (Translation $translation) {
+            return $translation->id();
+        },
+        'name' => function (Translation $translation) {
+            return $translation->name();
+        },
+    ],
+    'type'  => 'Kirby\Cms\Translation',
+    'views' => [
+        'compact' => [
+            'direction',
+            'id',
+            'name'
+        ]
+    ]
+];

kirby/config/api/models/User.php

@@ -0,0 +1,108 @@
+<?php
+
+use Kirby\Cms\Form;
+use Kirby\Cms\User;
+
+/**
+ * User
+ */
+return [
+    'default' => function () {
+        return $this->user();
+    },
+    'fields' => [
+        'avatar' => function (User $user) {
+            return $user->avatar() ? $user->avatar()->crop(512) : null;
+        },
+        'blueprint' => function (User $user) {
+            return $user->blueprint();
+        },
+        'content' => function (User $user) {
+            return Form::for($user)->values();
+        },
+        'email' => function (User $user) {
+            return $user->email();
+        },
+        'files' => function (User $user) {
+            return $user->files()->sort('sort', 'asc', 'filename', 'asc');
+        },
+        'id' => function (User $user) {
+            return $user->id();
+        },
+        'language' => function (User $user) {
+            return $user->language();
+        },
+        'name' => function (User $user) {
+            return $user->name()->value();
+        },
+        'next' => function (User $user) {
+            return $user->next();
+        },
+        'options' => function (User $user) {
+            return $user->panelOptions();
+        },
+        'permissions' => function (User $user) {
+            return $user->role()->permissions()->toArray();
+        },
+        'prev' => function (User $user) {
+            return $user->prev();
+        },
+        'role' => function (User $user) {
+            return $user->role();
+        },
+        'roles' => function (User $user) {
+            return $user->roles();
+        },
+        'username' => function (User $user) {
+            return $user->username();
+        }
+    ],
+    'type'  => 'Kirby\Cms\User',
+    'views' => [
+        'default' => [
+            'avatar',
+            'content',
+            'email',
+            'id',
+            'language',
+            'name',
+            'next' => 'compact',
+            'options',
+            'prev' => 'compact',
+            'role',
+            'username'
+        ],
+        'compact' => [
+            'avatar' => 'compact',
+            'id',
+            'email',
+            'language',
+            'name',
+            'role' => 'compact',
+            'username'
+        ],
+        'auth' => [
+            'avatar' => 'compact',
+            'permissions',
+            'email',
+            'id',
+            'name',
+            'role',
+            'language'
+        ],
+        'panel' => [
+            'avatar' => 'compact',
+            'blueprint',
+            'content',
+            'email',
+            'id',
+            'language',
+            'name',
+            'next' => ['id', 'name'],
+            'options',
+            'prev' => ['id', 'name'],
+            'role',
+            'username',
+        ],
+    ]
+];

kirby/config/api/models/UserBlueprint.php

@@ -0,0 +1,26 @@
+<?php
+
+use Kirby\Cms\UserBlueprint;
+
+/**
+ * UserBlueprint
+ */
+return [
+    'fields' => [
+        'name' => function (UserBlueprint $blueprint) {
+            return $blueprint->name();
+        },
+        'options' => function (UserBlueprint $blueprint) {
+            return $blueprint->options();
+        },
+        'tabs' => function (UserBlueprint $blueprint) {
+            return $blueprint->tabs();
+        },
+        'title' => function (UserBlueprint $blueprint) {
+            return $blueprint->title();
+        },
+    ],
+    'type' => 'Kirby\Cms\UserBlueprint',
+    'views' => [
+    ],
+];

kirby/config/api/routes.php

@@ -0,0 +1,26 @@
+<?php
+
+/**
+ * Api Routes Definitions
+ */
+return function ($kirby) {
+    $routes = array_merge(
+        include __DIR__ . '/routes/auth.php',
+        include __DIR__ . '/routes/pages.php',
+        include __DIR__ . '/routes/roles.php',
+        include __DIR__ . '/routes/site.php',
+        include __DIR__ . '/routes/users.php',
+        include __DIR__ . '/routes/files.php',
+        include __DIR__ . '/routes/lock.php',
+        include __DIR__ . '/routes/system.php',
+        include __DIR__ . '/routes/translations.php'
+    );
+
+    // only add the language routes if the
+    // multi language setup is activated
+    if ($kirby->option('languages', false) !== false) {
+        $routes = array_merge($routes, include __DIR__ . '/routes/languages.php');
+    }
+
+    return $routes;
+};

kirby/config/api/routes/auth.php

@@ -0,0 +1,108 @@
+<?php
+
+use Kirby\Exception\InvalidArgumentException;
+use Kirby\Exception\NotFoundException;
+
+/**
+ * Authentication
+ */
+return [
+    [
+        'pattern' => 'auth',
+        'method'  => 'GET',
+        'action'  => function () {
+            if ($user = $this->kirby()->auth()->user()) {
+                return $this->resolve($user)->view('auth');
+            }
+
+            throw new NotFoundException('The user cannot be found');
+        }
+    ],
+    [
+        'pattern' => 'auth/code',
+        'method'  => 'POST',
+        'auth'    => false,
+        'action'  => function () {
+            $auth = $this->kirby()->auth();
+
+            // csrf token check
+            if ($auth->type() === 'session' && $auth->csrf() === false) {
+                throw new InvalidArgumentException('Invalid CSRF token');
+            }
+
+            $user = $auth->verifyChallenge($this->requestBody('code'));
+
+            return [
+                'code'   => 200,
+                'status' => 'ok',
+                'user'   => $this->resolve($user)->view('auth')->toArray()
+            ];
+        }
+    ],
+    [
+        'pattern' => 'auth/login',
+        'method'  => 'POST',
+        'auth'    => false,
+        'action'  => function () {
+            $auth    = $this->kirby()->auth();
+            $methods = $this->kirby()->system()->loginMethods();
+
+            // csrf token check
+            if ($auth->type() === 'session' && $auth->csrf() === false) {
+                throw new InvalidArgumentException('Invalid CSRF token');
+            }
+
+            $email    = $this->requestBody('email');
+            $long     = $this->requestBody('long');
+            $password = $this->requestBody('password');
+
+            if ($password) {
+                if (isset($methods['password']) !== true) {
+                    throw new InvalidArgumentException('Login with password is not enabled');
+                }
+
+                if (
+                    isset($methods['password']['2fa']) === true &&
+                    $methods['password']['2fa'] === true
+                ) {
+                    $status = $auth->login2fa($email, $password, $long);
+                } else {
+                    $user = $auth->login($email, $password, $long);
+                }
+            } else {
+                if (isset($methods['code']) === true) {
+                    $mode = 'login';
+                } elseif (isset($methods['password-reset']) === true) {
+                    $mode = 'password-reset';
+                } else {
+                    throw new InvalidArgumentException('Login without password is not enabled');
+                }
+
+                $status = $auth->createChallenge($email, $long, $mode);
+            }
+
+            if (isset($user)) {
+                return [
+                    'code'   => 200,
+                    'status' => 'ok',
+                    'user'   => $this->resolve($user)->view('auth')->toArray()
+                ];
+            } else {
+                return [
+                    'code'      => 200,
+                    'status'    => 'ok',
+                    'challenge' => $status->challenge()
+                ];
+            }
+        }
+    ],
+    [
+        'pattern' => 'auth/logout',
+        'method'  => 'POST',
+        'auth'    => false,
+        'action'  => function () {
+            $this->kirby()->auth()->logout();
+            return true;
+        }
+    ],
+];

kirby/config/api/routes/files.php

@@ -0,0 +1,123 @@
+<?php
+
+/**
+ * Files Routes
+ */
+return [
+
+    [
+        'pattern' => '(:all)/files/(:any)/sections/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $path, string $filename, string $sectionName) {
+            if ($section = $this->file($path, $filename)->blueprint()->section($sectionName)) {
+                return $section->toResponse();
+            }
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/(:any)/fields/(:any)/(:all?)',
+        'method'  => 'ALL',
+        'action'  => function (string $parent, string $filename, string $fieldName, string $path = null) {
+            if ($file = $this->file($parent, $filename)) {
+                return $this->fieldApi($file, $fieldName, $path);
+            }
+        }
+    ],
+    [
+        'pattern' => '(:all)/files',
+        'method'  => 'GET',
+        'action'  => function (string $path) {
+            return $this->parent($path)->files()->sort('sort', 'asc', 'filename', 'asc');
+        }
+    ],
+    [
+        'pattern' => '(:all)/files',
+        'method'  => 'POST',
+        'action'  => function (string $path) {
+            return $this->upload(function ($source, $filename) use ($path) {
+                return $this->parent($path)->createFile([
+                    'source'   => $source,
+                    'template' => $this->requestBody('template'),
+                    'filename' => $filename
+                ]);
+            });
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/search',
+        'method'  => 'GET|POST',
+        'action'  => function (string $path) {
+            $files = $this->parent($path)->files();
+
+            if ($this->requestMethod() === 'GET') {
+                return $files->search($this->requestQuery('q'));
+            } else {
+                return $files->query($this->requestBody());
+            }
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/sort',
+        'method'  => 'PATCH',
+        'action'  => function (string $path) {
+            return $this->parent($path)->files()->changeSort(
+                $this->requestBody('files'),
+                $this->requestBody('index')
+            );
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $path, string $filename) {
+            return $this->file($path, $filename);
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/(:any)',
+        'method'  => 'PATCH',
+        'action'  => function (string $path, string $filename) {
+            return $this->file($path, $filename)->update($this->requestBody(), $this->language(), true);
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/(:any)',
+        'method'  => 'POST',
+        'action'  => function (string $path, string $filename) {
+            return $this->upload(function ($source) use ($path, $filename) {
+                return $this->file($path, $filename)->replace($source);
+            });
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/(:any)',
+        'method'  => 'DELETE',
+        'action'  => function (string $path, string $filename) {
+            return $this->file($path, $filename)->delete();
+        }
+    ],
+    [
+        'pattern' => '(:all)/files/(:any)/name',
+        'method'  => 'PATCH',
+        'action'  => function (string $path, string $filename) {
+            return $this->file($path, $filename)->changeName($this->requestBody('name'));
+        }
+    ],
+    [
+        'pattern' => 'files/search',
+        'method'  => 'GET|POST',
+        'action'  => function () {
+            $files = $this
+                ->site()
+                ->index(true)
+                ->filter('isReadable', true)
+                ->files();
+
+            if ($this->requestMethod() === 'GET') {
+                return $files->search($this->requestQuery('q'));
+            } else {
+                return $files->query($this->requestBody());
+            }
+        }
+    ],
+];

kirby/config/api/routes/languages.php

@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * Roles Routes
+ */
+return [
+    [
+        'pattern' => 'languages',
+        'method'  => 'GET',
+        'action'  => function () {
+            return $this->kirby()->languages();
+        }
+    ],
+    [
+        'pattern' => 'languages',
+        'method'  => 'POST',
+        'action'  => function () {
+            return $this->kirby()->languages()->create($this->requestBody());
+        }
+    ],
+    [
+        'pattern' => 'languages/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $code) {
+            return $this->kirby()->languages()->find($code);
+        }
+    ],
+    [
+        'pattern' => 'languages/(:any)',
+        'method'  => 'PATCH',
+        'action'  => function (string $code) {
+            if ($language = $this->kirby()->languages()->find($code)) {
+                return $language->update($this->requestBody());
+            }
+        }
+    ],
+    [
+        'pattern' => 'languages/(:any)',
+        'method'  => 'DELETE',
+        'action'  => function (string $code) {
+            if ($language = $this->kirby()->languages()->find($code)) {
+                return $language->delete();
+            }
+        }
+    ]
+];

kirby/config/api/routes/lock.php

@@ -0,0 +1,99 @@
+<?php
+
+use Kirby\Exception\Exception;
+
+/**
+ * Content Lock Routes
+ */
+return [
+    [
+        'pattern' => '(:all)/lock',
+        'method'  => 'GET',
+        'action'  => function (string $path) {
+            if ($lock = $this->parent($path)->lock()) {
+                return [
+                    'supported' => true,
+                    'locked'    => $lock->get()
+                ];
+            }
+
+            return [
+                'supported' => false,
+                'locked'    => null
+            ];
+        }
+    ],
+    [
+        'pattern' => '(:all)/lock',
+        'method'  => 'PATCH',
+        'action'  => function (string $path) {
+            if ($lock = $this->parent($path)->lock()) {
+                return $lock->create();
+            }
+
+            throw new Exception([
+                'key'      => 'lock.notImplemented',
+                'httpCode' => 501
+            ]);
+        }
+    ],
+    [
+        'pattern' => '(:all)/lock',
+        'method'  => 'DELETE',
+        'action'  => function (string $path) {
+            if ($lock = $this->parent($path)->lock()) {
+                return $lock->remove();
+            }
+
+            throw new Exception([
+                'key'      => 'lock.notImplemented',
+                'httpCode' => 501
+            ]);
+        }
+    ],
+    [
+        'pattern' => '(:all)/unlock',
+        'method'  => 'GET',
+        'action'  => function (string $path) {
+            if ($lock = $this->parent($path)->lock()) {
+                return [
+                    'supported' => true,
+                    'unlocked'  => $lock->isUnlocked()
+                ];
+            }
+
+            return [
+                'supported' => false,
+                'unlocked'  => null
+            ];
+        }
+    ],
+    [
+        'pattern' => '(:all)/unlock',
+        'method'  => 'PATCH',
+        'action'  => function (string $path) {
+            if ($lock = $this->parent($path)->lock()) {
+                return $lock->unlock();
+            }
+
+            throw new Exception([
+                'key'      => 'lock.notImplemented',
+                'httpCode' => 501
+            ]);
+        }
+    ],
+    [
+        'pattern' => '(:all)/unlock',
+        'method'  => 'DELETE',
+        'action'  => function (string $path) {
+            if ($lock = $this->parent($path)->lock()) {
+                return $lock->resolve();
+            }
+
+            throw new Exception([
+                'key'      => 'lock.notImplemented',
+                'httpCode' => 501
+            ]);
+        }
+    ],
+];

kirby/config/api/routes/pages.php

@@ -0,0 +1,127 @@
+<?php
+
+/**
+ * Page Routes
+ */
+return [
+
+    [
+        'pattern' => 'pages/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->page($id);
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->page($id)->update($this->requestBody(), $this->language(), true);
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)',
+        'method'  => 'DELETE',
+        'action'  => function (string $id) {
+            return $this->page($id)->delete($this->requestBody('force', false));
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/blueprint',
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->page($id)->blueprint();
+        }
+    ],
+    [
+        'pattern' => [
+            'pages/(:any)/blueprints',
+            /**
+             * @deprecated
+             * @todo remove in 3.6.0
+             */
+            'pages/(:any)/children/blueprints',
+        ],
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->page($id)->blueprints($this->requestQuery('section'));
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/children',
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->pages($id, $this->requestQuery('status'));
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/children',
+        'method'  => 'POST',
+        'action'  => function (string $id) {
+            return $this->page($id)->createChild($this->requestBody());
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/children/search',
+        'method'  => 'GET|POST',
+        'action'  => function (string $id) {
+            return $this->searchPages($id);
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/duplicate',
+        'method'  => 'POST',
+        'action'  => function (string $id) {
+            return $this->page($id)->duplicate($this->requestBody('slug'), [
+                'children' => $this->requestBody('children'),
+                'files'    => $this->requestBody('files'),
+            ]);
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/slug',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->page($id)->changeSlug($this->requestBody('slug'));
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/status',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->page($id)->changeStatus($this->requestBody('status'), $this->requestBody('position'));
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/template',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->page($id)->changeTemplate($this->requestBody('template'));
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/title',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->page($id)->changeTitle($this->requestBody('title'));
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/sections/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $id, string $sectionName) {
+            if ($section = $this->page($id)->blueprint()->section($sectionName)) {
+                return $section->toResponse();
+            }
+        }
+    ],
+    [
+        'pattern' => 'pages/(:any)/fields/(:any)/(:all?)',
+        'method'  => 'ALL',
+        'action'  => function (string $id, string $fieldName, string $path = null) {
+            if ($page = $this->page($id)) {
+                return $this->fieldApi($page, $fieldName, $path);
+            }
+        }
+    ],
+];

kirby/config/api/routes/roles.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * Roles Routes
+ */
+return [
+    [
+        'pattern' => 'roles',
+        'method'  => 'GET',
+        'action'  => function () {
+            switch (get('canBe')) {
+                case 'changed':
+                    return $this->kirby()->roles()->canBeChanged();
+                case 'created':
+                    return $this->kirby()->roles()->canBeCreated();
+                default:
+                    return $this->kirby()->roles();
+            }
+        }
+    ],
+    [
+        'pattern' => 'roles/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $name) {
+            return $this->kirby()->roles()->find($name);
+        }
+    ]
+];

kirby/config/api/routes/site.php

@@ -0,0 +1,110 @@
+<?php
+
+/**
+ * Site Routes
+ */
+return [
+
+    [
+        'pattern' => 'site',
+        'action'  => function () {
+            return $this->site();
+        }
+    ],
+    [
+        'pattern' => 'site',
+        'method'  => 'PATCH',
+        'action'  => function () {
+            return $this->site()->update($this->requestBody(), $this->language(), true);
+        }
+    ],
+    [
+        'pattern' => 'site/children',
+        'method'  => 'GET',
+        'action'  => function () {
+            return $this->pages(null, $this->requestQuery('status'));
+        }
+    ],
+    [
+        'pattern' => 'site/children',
+        'method'  => 'POST',
+        'action'  => function () {
+            return $this->site()->createChild($this->requestBody());
+        }
+    ],
+    [
+        'pattern' => 'site/children/search',
+        'method'  => 'GET|POST',
+        'action'  => function () {
+            return $this->searchPages();
+        }
+    ],
+    [
+        'pattern' => 'site/blueprint',
+        'method'  => 'GET',
+        'action'  => function () {
+            return $this->site()->blueprint();
+        }
+    ],
+    [
+        'pattern' => [
+            'site/blueprints',
+            /**
+             * @deprecated
+             * @todo remove in 3.6.0
+             */
+            'site/children/blueprints',
+        ],
+        'method'  => 'GET',
+        'action'  => function () {
+            return $this->site()->blueprints($this->requestQuery('section'));
+        }
+    ],
+    [
+        'pattern' => 'site/find',
+        'method'  => 'POST',
+        'action'  => function () {
+            return $this->site()->find(false, ...$this->requestBody());
+        }
+    ],
+    [
+        'pattern' => 'site/title',
+        'method'  => 'PATCH',
+        'action'  => function () {
+            return $this->site()->changeTitle($this->requestBody('title'));
+        }
+    ],
+    [
+        'pattern' => 'site/search',
+        'method'  => 'GET|POST',
+        'action'  => function () {
+            $pages = $this
+                ->site()
+                ->index(true)
+                ->filter('isReadable', true);
+
+            if ($this->requestMethod() === 'GET') {
+                return $pages->search($this->requestQuery('q'));
+            } else {
+                return $pages->query($this->requestBody());
+            }
+        }
+    ],
+    [
+        'pattern' => 'site/sections/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $sectionName) {
+            if ($section = $this->site()->blueprint()->section($sectionName)) {
+                return $section->toResponse();
+            }
+        }
+    ],
+    [
+        'pattern' => 'site/fields/(:any)/(:all?)',
+        'method'  => 'ALL',
+        'action'  => function (string $fieldName, string $path = null) {
+            return $this->fieldApi($this->site(), $fieldName, $path);
+        }
+    ]
+
+];

kirby/config/api/routes/system.php

@@ -0,0 +1,79 @@
+<?php
+
+use Kirby\Exception\Exception;
+use Kirby\Exception\InvalidArgumentException;
+
+/**
+ * System Routes
+ */
+return [
+
+    [
+        'pattern' => 'system',
+        'method'  => 'GET',
+        'auth'    => false,
+        'action'  => function () {
+            $system = $this->kirby()->system();
+
+            if ($this->kirby()->user()) {
+                return $system;
+            } else {
+                if ($system->isOk() === true) {
+                    $info = $this->resolve($system)->view('login')->toArray();
+                } else {
+                    $info = $this->resolve($system)->view('troubleshooting')->toArray();
+                }
+
+                return [
+                    'status' => 'ok',
+                    'data'   => $info,
+                    'type'   => 'model'
+                ];
+            }
+        }
+    ],
+    [
+        'pattern' => 'system/register',
+        'method'  => 'POST',
+        'action'  => function () {
+            return $this->kirby()->system()->register($this->requestBody('license'), $this->requestBody('email'));
+        }
+    ],
+    [
+        'pattern' => 'system/install',
+        'method'  => 'POST',
+        'auth'    => false,
+        'action'  => function () {
+            $system = $this->kirby()->system();
+            $auth   = $this->kirby()->auth();
+
+            // csrf token check
+            if ($auth->type() === 'session' && $auth->csrf() === false) {
+                throw new InvalidArgumentException('Invalid CSRF token');
+            }
+
+            if ($system->isOk() === false) {
+                throw new Exception('The server is not setup correctly');
+            }
+
+            if ($system->isInstallable() === false) {
+                throw new Exception('The Panel cannot be installed');
+            }
+
+            if ($system->isInstalled() === true) {
+                throw new Exception('The Panel is already installed');
+            }
+
+            // create the first user
+            $user  = $this->users()->create($this->requestBody());
+            $token = $user->login($this->requestBody('password'));
+
+            return [
+                'status' => 'ok',
+                'token'  => $token,
+                'user'   => $this->resolve($user)->view('auth')->toArray()
+            ];
+        }
+    ]
+
+];

kirby/config/api/routes/translations.php

@@ -0,0 +1,24 @@
+<?php
+
+/**
+ * Translations Routes
+ */
+return [
+    [
+        'pattern' => 'translations',
+        'method'  => 'GET',
+        'auth'    => false,
+        'action'  => function () {
+            return $this->kirby()->translations();
+        }
+    ],
+    [
+        'pattern' => 'translations/(:any)',
+        'method'  => 'GET',
+        'auth'    => false,
+        'action'  => function (string $code) {
+            return $this->kirby()->translations()->find($code);
+        }
+    ]
+
+];

kirby/config/api/routes/users.php

@@ -0,0 +1,160 @@
+<?php
+
+use Kirby\Toolkit\F;
+
+/**
+ * User Routes
+ */
+return [
+
+    [
+        'pattern' => 'users',
+        'method'  => 'GET',
+        'action'  => function () {
+            return $this->users()->sort('username', 'asc', 'email', 'asc');
+        }
+    ],
+    [
+        'pattern' => 'users',
+        'method'  => 'POST',
+        'action'  => function () {
+            return $this->users()->create($this->requestBody());
+        }
+    ],
+    [
+        'pattern' => 'users/search',
+        'method'  => 'GET|POST',
+        'action'  => function () {
+            if ($this->requestMethod() === 'GET') {
+                return $this->users()->search($this->requestQuery('q'));
+            } else {
+                return $this->users()->query($this->requestBody());
+            }
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->user($id);
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->user($id)->update($this->requestBody(), $this->language(), true);
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)',
+        'method'  => 'DELETE',
+        'action'  => function (string $id) {
+            return $this->user($id)->delete();
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/avatar',
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->user($id)->avatar();
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/avatar',
+        'method'  => 'POST',
+        'action'  => function (string $id) {
+            if ($avatar = $this->user($id)->avatar()) {
+                $avatar->delete();
+            }
+
+            return $this->upload(function ($source, $filename) use ($id) {
+                return $this->user($id)->createFile([
+                    'filename' => 'profile.' . F::extension($filename),
+                    'template' => 'avatar',
+                    'source'   => $source
+                ]);
+            }, $single = true);
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/avatar',
+        'method'  => 'DELETE',
+        'action'  => function (string $id) {
+            return $this->user($id)->avatar()->delete();
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/blueprint',
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->user($id)->blueprint();
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/blueprints',
+        'method'  => 'GET',
+        'action'  => function (string $id) {
+            return $this->user($id)->blueprints($this->requestQuery('section'));
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/email',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->user($id)->changeEmail($this->requestBody('email'));
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/fields/(:any)/(:all?)',
+        'method'  => 'ALL',
+        'action'  => function (string $id, string $fieldName, string $path = null) {
+            if ($user = $this->user($id)) {
+                return $this->fieldApi($user, $fieldName, $path);
+            }
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/language',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->user($id)->changeLanguage($this->requestBody('language'));
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/name',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->user($id)->changeName($this->requestBody('name'));
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/password',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->user($id)->changePassword($this->requestBody('password'));
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/role',
+        'method'  => 'PATCH',
+        'action'  => function (string $id) {
+            return $this->user($id)->changeRole($this->requestBody('role'));
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/roles',
+        'action'  => function (string $id) {
+            return $this->user($id)->roles();
+        }
+    ],
+    [
+        'pattern' => 'users/(:any)/sections/(:any)',
+        'method'  => 'GET',
+        'action'  => function (string $id, string $sectionName) {
+            if ($section = $this->user($id)->blueprint()->section($sectionName)) {
+                return $section->toResponse();
+            }
+        }
+    ],
+];

kirby/config/blocks/code/code.php

@@ -0,0 +1,2 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<pre><code class="language-<?= $block->language()->or('text') ?>"><?= $block->code()->html(false) ?></code></pre>

kirby/config/blocks/code/code.yml

@@ -0,0 +1,59 @@
+name: field.blocks.code.name
+icon: code
+wysiwyg: true
+preview: code
+fields:
+  code:
+    label: field.blocks.code.name
+    type: textarea
+    placeholder: field.blocks.code.placeholder
+    buttons: false
+    font: monospace
+  language:
+    label: field.blocks.code.language
+    type: select
+    default: text
+    options:
+      bash: Bash
+      basic: BASIC
+      c: C
+      clojure: Clojure
+      cpp: C++
+      csharp: C#
+      css: CSS
+      diff: Diff
+      elixir: Elixir
+      elm: Elm
+      erlang: Erlang
+      go: Go
+      graphql: GraphQL
+      haskell: Haskell
+      html: HTML
+      java: Java
+      js: JavaScript
+      json: JSON
+      latext: LaTeX
+      less: Less
+      lisp: Lisp
+      lua: Lua
+      makefile: Makefile
+      markdown: Markdown
+      markup: Markup
+      objectivec: Objective-C
+      pascal: Pascal
+      perl: Perl
+      php: PHP
+      text: Plain Text
+      python: Python
+      r: R
+      ruby: Ruby
+      rust: Rust
+      sass: Sass
+      scss: SCSS
+      shell: Shell
+      sql: SQL
+      swift: Swift
+      typescript: TypeScript
+      vbnet: VB.net
+      xml: XML
+      yaml: YAML

kirby/config/blocks/gallery/gallery.php

@@ -0,0 +1,10 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<figure>
+  <ul>
+    <?php foreach ($block->images()->toFiles() as $image): ?>
+    <li>
+      <?= $image ?>
+    </li>
+    <?php endforeach ?>
+  </ul>
+</figure>

kirby/config/blocks/gallery/gallery.yml

@@ -0,0 +1,15 @@
+name: field.blocks.gallery.name
+icon: dashboard
+preview: gallery
+fields:
+  images:
+    label: field.blocks.gallery.images.label
+    type: files
+    multiple: true
+    layout: cards
+    size: tiny
+    empty: field.blocks.gallery.images.empty
+    uploads:
+      template: blocks/image
+    image:
+      ratio: 1/1

kirby/config/blocks/heading/heading.php

@@ -0,0 +1,2 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<<?= $level = $block->level()->or('h2') ?>><?= $block->text() ?></<?= $level ?>>

kirby/config/blocks/heading/heading.yml

@@ -0,0 +1,24 @@
+name: field.blocks.heading.name
+icon: title
+wysiwyg: true
+preview: heading
+fields:
+  level:
+    label: field.blocks.heading.level
+    type: select
+    empty: false
+    default: "h2"
+    width: 1/6
+    options:
+      - h1
+      - h2
+      - h3
+      - h4
+      - h5
+      - h6
+  text:
+    label: field.blocks.heading.text
+    type: writer
+    inline: true
+    width: 5/6
+    placeholder: field.blocks.heading.placeholder

kirby/config/blocks/image/image.php

@@ -0,0 +1,35 @@
+<?php
+
+/** @var \Kirby\Cms\Block $block */
+$alt     = $block->alt();
+$caption = $block->caption();
+$crop    = $block->crop()->isTrue();
+$link    = $block->link();
+$ratio   = $block->ratio()->or('auto');
+$src     = null;
+
+if ($block->location() == 'web') {
+    $src = $block->src();
+} elseif ($image = $block->image()->toFile()) {
+    $alt = $alt ?? $image->alt();
+    $src = $image->url();
+}
+
+?>
+<?php if ($src): ?>
+<figure<?= attr(['data-ratio' => $ratio, 'data-crop' => $crop], ' ') ?>>
+  <?php if ($link->isNotEmpty()): ?>
+  <a href="<?= $link->toUrl() ?>">
+    <img src="<?= $src ?>" alt="<?= $alt ?>">
+  </a>
+  <?php else: ?>
+  <img src="<?= $src ?>" alt="<?= $alt ?>">
+  <?php endif ?>
+
+  <?php if ($caption->isNotEmpty()): ?>
+  <figcaption>
+    <?= $caption ?>
+  </figcaption>
+  <?php endif ?>
+</figure>
+<?php endif ?>

kirby/config/blocks/image/image.yml

@@ -0,0 +1,59 @@
+name: field.blocks.image.name
+icon: image
+preview: image
+fields:
+  location:
+    label: field.blocks.image.location
+    type: radio
+    columns: 2
+    default: "kirby"
+    options:
+      kirby: Kirby
+      web: Web
+  image:
+    label: field.blocks.image.name
+    type: files
+    multiple: false
+    image:
+      back: black
+    uploads:
+      template: blocks/image
+    when:
+      location: kirby
+  src:
+    label: field.blocks.image.url
+    type: url
+    when:
+      location: web
+  alt:
+    label: field.blocks.image.alt
+    type: text
+    icon: title
+  caption:
+    label: field.blocks.image.caption
+    type: writer
+    icon: text
+    inline: true
+  link:
+    label: field.blocks.image.link
+    type: text
+    icon: url
+  ratio:
+    label: field.blocks.image.ratio
+    type: select
+    placeholder: Auto
+    width: 1/2
+    options:
+      1/1: "1:1"
+      16/9: "16:9"
+      10/8: "10:8"
+      21/9: "21:9"
+      7/5: "7:5"
+      4/3: "4:3"
+      5/3: "5:3"
+      3/2: "3:2"
+      3/1: "3:1"
+  crop:
+    label: field.blocks.image.crop
+    type: toggle
+    width: 1/2

kirby/config/blocks/list/list.php

@@ -0,0 +1,2 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<?= $block->text();

kirby/config/blocks/list/list.yml

@@ -0,0 +1,8 @@
+name: field.blocks.list.name
+icon: list-bullet
+wysiwyg: true
+preview: list
+fields:
+  text:
+    label: field.blocks.list.name
+    type: list

kirby/config/blocks/markdown/markdown.php

@@ -0,0 +1,2 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<?= $block->text()->kt();

kirby/config/blocks/markdown/markdown.yml

@@ -0,0 +1,11 @@
+name: field.blocks.markdown.name
+icon: markdown
+preview: markdown
+wysiwyg: true
+fields:
+  text:
+    label: field.blocks.markdown.label
+    placeholder: field.blocks.markdown.placeholder
+    type: textarea
+    buttons: false
+    font: monospace

kirby/config/blocks/quote/quote.php

@@ -0,0 +1,9 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<blockquote>
+  <?= $block->text() ?>
+  <?php if ($block->citation()->isNotEmpty()): ?>
+  <footer>
+    <?= $block->citation() ?>
+  </footer>
+  <?php endif ?>
+</blockquote>

kirby/config/blocks/quote/quote.yml

@@ -0,0 +1,17 @@
+name: field.blocks.quote.name
+icon: quote
+wysiwyg: true
+preview: quote
+fields:
+  text:
+    label: field.blocks.quote.text.label
+    placeholder: field.blocks.quote.text.placeholder
+    type: writer
+    inline: true
+    icon: quote
+  citation:
+    label: field.blocks.quote.citation.label
+    placeholder: field.blocks.quote.citation.placeholder
+    type: writer
+    inline: true
+    icon: user

kirby/config/blocks/table/table.yml

@@ -0,0 +1,3 @@
+name: Table
+icon: menu
+preview: table

kirby/config/blocks/text/text.php

@@ -0,0 +1,2 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<?= $block->text();

kirby/config/blocks/text/text.yml

@@ -0,0 +1,9 @@
+name: field.blocks.text.name
+icon: text
+wysiwyg: true
+preview: text
+fields:
+  text:
+    type: writer
+    nodes: false
+    placeholder: field.blocks.text.placeholder

kirby/config/blocks/video/video.php

@@ -0,0 +1,9 @@
+<?php /** @var \Kirby\Cms\Block $block */ ?>
+<?php if ($block->url()->isNotEmpty()): ?>
+<figure>
+  <?= video($block->url()) ?>
+  <?php if ($block->caption()->isNotEmpty()): ?>
+  <figcaption><?= $block->caption() ?></figcaption>
+  <?php endif ?>
+</figure>
+<?php endif ?>

kirby/config/blocks/video/video.yml

@@ -0,0 +1,12 @@
+name: field.blocks.video.name
+icon: video
+preview: video
+fields:
+  url:
+    label: field.blocks.video.url.label
+    type: url
+    placeholder: field.blocks.video.url.placeholder
+  caption:
+    label: field.blocks.video.caption
+    type: writer
+    inline: true

kirby/config/blueprints.php

@@ -0,0 +1,26 @@
+<?php
+
+$blocksRoot = __DIR__ . '/blocks';
+
+return [
+    // blocks
+    'blocks/code'     => $blocksRoot . '/code/code.yml',
+    'blocks/gallery'  => $blocksRoot . '/gallery/gallery.yml',
+    'blocks/heading'  => $blocksRoot . '/heading/heading.yml',
+    'blocks/image'    => $blocksRoot . '/image/image.yml',
+    'blocks/list'     => $blocksRoot . '/list/list.yml',
+    'blocks/markdown' => $blocksRoot . '/markdown/markdown.yml',
+    'blocks/quote'    => $blocksRoot . '/quote/quote.yml',
+    'blocks/table'    => $blocksRoot . '/table/table.yml',
+    'blocks/text'     => $blocksRoot . '/text/text.yml',
+    'blocks/video'    => $blocksRoot . '/video/video.yml',
+
+    // file blueprints
+    'files/default' => __DIR__ . '/blueprints/files/default.yml',
+
+    // page blueprints
+    'pages/default' => __DIR__ . '/blueprints/pages/default.yml',
+
+    // site blueprints
+    'site' => __DIR__ . '/blueprints/site.yml'
+];

kirby/config/blueprints/blocks/code.yml

@@ -0,0 +1,56 @@
+name: Code
+icon: code
+fields:
+  code:
+    label: Code
+    type: textarea
+    buttons: false
+    font: monospace
+  language:
+    label: Language
+    type: select
+    default: text
+    options:
+      bash: Bash
+      basic: BASIC
+      c: C
+      clojure: Clojure
+      cpp: C++
+      csharp: C#
+      css: CSS
+      diff: Diff
+      elixir: Elixir
+      elm: Elm
+      erlang: Erlang
+      go: Go
+      graphql: GraphQL
+      haskell: Haskell
+      html: HTML
+      java: Java
+      js: JavaScript
+      json: JSON
+      latext: LaTeX
+      less: Less
+      lisp: Lisp
+      lua: Lua
+      makefile: Makefile
+      markdown: Markdown
+      markup: Markup
+      objectivec: Objective-C
+      pascal: Pascal
+      perl: Perl
+      php: PHP
+      text: Plain Text
+      python: Python
+      r: R
+      ruby: Ruby
+      rust: Rust
+      sass: Sass
+      scss: SCSS
+      shell: Shell
+      sql: SQL
+      swift: Swift
+      typescript: TypeScript
+      vbnet: VB.net
+      xml: XML
+      yaml: YAML

kirby/config/blueprints/blocks/heading.yml

@@ -0,0 +1,21 @@
+icon: title
+fields:
+  text:
+    type: text
+  level:
+    type: select
+    width: 1/2
+    default: 1
+    empty: false
+    default: "2"
+    options:
+      - value: "1"
+        text: Heading 1
+      - value: "2"
+        text: Heading 2
+      - value: "3"
+        text: Heading 3
+  id:
+    type: text
+    label: ID
+    width: 1/2

kirby/config/blueprints/blocks/image.yml

@@ -0,0 +1,16 @@
+name: Image
+icon: image
+fields:
+  image:
+    type: files
+    multiple: false
+  alt:
+    type: text
+    icon: title
+  caption:
+    type: writer
+    inline: true
+    icon: text
+  link:
+    type: text
+    icon: url

kirby/config/blueprints/blocks/quote.yml

@@ -0,0 +1,12 @@
+name: Quote
+icon: quote
+fields:
+  text:
+    label: Quote Text
+    type: writer
+    inline: true
+  citation:
+    label: Citation
+    type: writer
+    inline: true
+    placeholder: by …

kirby/config/blueprints/blocks/table.yml

@@ -0,0 +1,25 @@
+name: Table
+icon: menu
+fields:
+  rows:
+    label: Menu
+    type: structure
+    columns:
+      dish: true
+      description: true
+      price:
+        before: €
+        width: 1/4
+        align: right
+    fields:
+      dish:
+        label: Dish
+        type: text
+      description:
+        label: Description
+        type: text
+      price:
+        label: Price
+        type: number
+        before: €
+        step: 0.01

kirby/config/blueprints/blocks/text.yml

@@ -0,0 +1,5 @@
+name: Text
+icon: text
+fields:
+  text:
+    type: writer

kirby/config/blueprints/blocks/video.yml

@@ -0,0 +1,8 @@
+name: Video
+icon: video
+label: "{{ url }}"
+fields:
+  url:
+    type: url
+  caption:
+    type: writer

kirby/config/blueprints/files/default.yml

@@ -0,0 +1,2 @@
+name: File
+title: file

kirby/config/blueprints/pages/default.yml

@@ -0,0 +1,3 @@
+name: Page
+title: Page
+

kirby/config/blueprints/site.yml

@@ -0,0 +1,7 @@
+name: Site
+title: Site
+sections:
+  pages:
+    headline: Pages
+    type: pages
+

kirby/config/components.php

@@ -0,0 +1,378 @@
+<?php
+
+use Kirby\Cms\App;
+use Kirby\Cms\Collection;
+use Kirby\Cms\File;
+use Kirby\Cms\Filename;
+use Kirby\Cms\FileVersion;
+use Kirby\Cms\Template;
+use Kirby\Data\Data;
+use Kirby\Http\Server;
+use Kirby\Http\Uri;
+use Kirby\Http\Url;
+use Kirby\Image\Darkroom;
+use Kirby\Text\Markdown;
+use Kirby\Text\SmartyPants;
+use Kirby\Toolkit\A;
+use Kirby\Toolkit\F;
+use Kirby\Toolkit\Str;
+use Kirby\Toolkit\Tpl as Snippet;
+
+return [
+
+    /**
+     * Used by the `css()` helper
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string $url Relative or absolute URL
+     * @param string|array $options An array of attributes for the link tag or a media attribute string
+     */
+    'css' => function (App $kirby, string $url, $options = null): string {
+        return $url;
+    },
+
+
+    /**
+     * Object and variable dumper
+     * to help with debugging.
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param mixed $variable
+     * @param bool $echo
+     * @return string
+     */
+    'dump' => function (App $kirby, $variable, bool $echo = true) {
+        if (Server::cli() === true) {
+            $output = print_r($variable, true) . PHP_EOL;
+        } else {
+            $output = '<pre>' . print_r($variable, true) . '</pre>';
+        }
+
+        if ($echo === true) {
+            echo $output;
+        }
+
+        return $output;
+    },
+
+    /**
+     * Modify URLs for file objects
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param \Kirby\Cms\File $file The original file object
+     * @return string
+     */
+    'file::url' => function (App $kirby, File $file): string {
+        return $file->mediaUrl();
+    },
+
+    /**
+     * Adapt file characteristics
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param \Kirby\Cms\File|\Kirby\Cms\FileModifications $file The file object
+     * @param array $options All thumb options (width, height, crop, blur, grayscale)
+     * @return \Kirby\Cms\File|\Kirby\Cms\FileVersion
+     */
+    'file::version' => function (App $kirby, $file, array $options = []) {
+        if ($file->isResizable() === false) {
+            return $file;
+        }
+
+        // create url and root
+        $mediaRoot = dirname($file->mediaRoot());
+        $template  = $mediaRoot . '/{{ name }}{{ attributes }}.{{ extension }}';
+        $thumbRoot = (new Filename($file->root(), $template, $options))->toString();
+        $thumbName = basename($thumbRoot);
+        $job       = $mediaRoot . '/.jobs/' . $thumbName . '.json';
+
+        if (file_exists($thumbRoot) === false) {
+            try {
+                Data::write($job, array_merge($options, [
+                    'filename' => $file->filename()
+                ]));
+            } catch (Throwable $e) {
+                return $file;
+            }
+        }
+
+        return new FileVersion([
+            'modifications' => $options,
+            'original'      => $file,
+            'root'          => $thumbRoot,
+            'url'           => dirname($file->mediaUrl()) . '/' . $thumbName,
+        ]);
+    },
+
+    /**
+     * Used by the `js()` helper
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string $url Relative or absolute URL
+     * @param string|array $options An array of attributes for the link tag or a media attribute string
+     */
+    'js' => function (App $kirby, string $url, $options = null): string {
+        return $url;
+    },
+
+    /**
+     * Add your own Markdown parser
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string $text Text to parse
+     * @param array $options Markdown options
+     * @param bool $inline Whether to wrap the text in `<p>` tags
+     * @return string
+     */
+    'markdown' => function (App $kirby, string $text = null, array $options = [], bool $inline = false): string {
+        static $markdown;
+        static $config;
+
+        // if the config options have changed or the component is called for the first time,
+        // (re-)initialize the parser object
+        if ($config !== $options) {
+            $markdown = new Markdown($options);
+            $config   = $options;
+        }
+
+        return $markdown->parse($text, $inline);
+    },
+
+    /**
+     * Add your own search engine
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param \Kirby\Cms\Collection $collection Collection of searchable models
+     * @param string $query
+     * @param mixed $params
+     * @return \Kirby\Cms\Collection|bool
+     */
+    'search' => function (App $kirby, Collection $collection, string $query = null, $params = []) {
+        if (empty(trim($query)) === true) {
+            return $collection->limit(0);
+        }
+
+        if (is_string($params) === true) {
+            $params = ['fields' => Str::split($params, '|')];
+        }
+
+        $defaults = [
+            'fields'    => [],
+            'minlength' => 2,
+            'score'     => [],
+            'words'     => false,
+        ];
+
+        $options     = array_merge($defaults, $params);
+        $collection  = clone $collection;
+        $searchWords = preg_replace('/(\s)/u', ',', $query);
+        $searchWords = Str::split($searchWords, ',', $options['minlength']);
+        $lowerQuery  = Str::lower($query);
+        $exactQuery  = $options['words'] ? '(\b' . preg_quote($query) . '\b)' : preg_quote($query);
+
+        if (empty($options['stopwords']) === false) {
+            $searchWords = array_diff($searchWords, $options['stopwords']);
+        }
+
+        $searchWords = array_map(function ($value) use ($options) {
+            return $options['words'] ? '\b' . preg_quote($value) . '\b' : preg_quote($value);
+        }, $searchWords);
+
+        $preg    = '!(' . implode('|', $searchWords) . ')!i';
+        $results = $collection->filter(function ($item) use ($query, $preg, $options, $lowerQuery, $exactQuery) {
+            $data = $item->content()->toArray();
+            $keys = array_keys($data);
+            $keys[] = 'id';
+
+            if (is_a($item, 'Kirby\Cms\User') === true) {
+                $keys[] = 'name';
+                $keys[] = 'email';
+                $keys[] = 'role';
+            } elseif (is_a($item, 'Kirby\Cms\Page') === true) {
+                // apply the default score for pages
+                $options['score'] = array_merge([
+                    'id'    => 64,
+                    'title' => 64,
+                ], $options['score']);
+            }
+
+            if (empty($options['fields']) === false) {
+                $fields = array_map('strtolower', $options['fields']);
+                $keys   = array_intersect($keys, $fields);
+            }
+
+            $item->searchHits  = 0;
+            $item->searchScore = 0;
+
+            foreach ($keys as $key) {
+                $score = $options['score'][$key] ?? 1;
+                $value = $data[$key] ?? (string)$item->$key();
+
+                $lowerValue = Str::lower($value);
+
+                // check for exact matches
+                if ($lowerQuery == $lowerValue) {
+                    $item->searchScore += 16 * $score;
+                    $item->searchHits  += 1;
+
+                // check for exact beginning matches
+                } elseif ($options['words'] === false && Str::startsWith($lowerValue, $lowerQuery) === true) {
+                    $item->searchScore += 8 * $score;
+                    $item->searchHits  += 1;
+
+                // check for exact query matches
+                } elseif ($matches = preg_match_all('!' . $exactQuery . '!i', $value, $r)) {
+                    $item->searchScore += 2 * $score;
+                    $item->searchHits  += $matches;
+                }
+
+                // check for any match
+                if ($matches = preg_match_all($preg, $value, $r)) {
+                    $item->searchHits  += $matches;
+                    $item->searchScore += $matches * $score;
+                }
+            }
+
+            return $item->searchHits > 0 ? true : false;
+        });
+
+        return $results->sort('searchScore', 'desc');
+    },
+
+    /**
+     * Add your own SmartyPants parser
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string $text Text to parse
+     * @param array $options SmartyPants options
+     * @return string
+     */
+    'smartypants' => function (App $kirby, string $text = null, array $options = []): string {
+        static $smartypants;
+        static $config;
+
+        // if the config options have changed or the component is called for the first time,
+        // (re-)initialize the parser object
+        if ($config !== $options) {
+            $smartypants = new Smartypants($options);
+            $config      = $options;
+        }
+
+        return $smartypants->parse($text);
+    },
+
+    /**
+     * Add your own snippet loader
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string|array $name Snippet name
+     * @param array $data Data array for the snippet
+     * @return string|null
+     */
+    'snippet' => function (App $kirby, $name, array $data = []): ?string {
+        $snippets = A::wrap($name);
+
+        foreach ($snippets as $name) {
+            $name = (string)$name;
+            $file = $kirby->root('snippets') . '/' . $name . '.php';
+
+            if (file_exists($file) === false) {
+                $file = $kirby->extensions('snippets')[$name] ?? null;
+            }
+
+            if ($file) {
+                break;
+            }
+        }
+
+        return Snippet::load($file, $data);
+    },
+
+    /**
+     * Add your own template engine
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string $name Template name
+     * @param string $type Extension type
+     * @param string $defaultType Default extension type
+     * @return \Kirby\Cms\Template
+     */
+    'template' => function (App $kirby, string $name, string $type = 'html', string $defaultType = 'html') {
+        return new Template($name, $type, $defaultType);
+    },
+
+    /**
+     * Add your own thumb generator
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string $src The root of the original file
+     * @param string $template The template for the root to the desired destination
+     * @param array $options All thumb options that should be applied: `width`, `height`, `crop`, `blur`, `grayscale`
+     * @return string
+     */
+    'thumb' => function (App $kirby, string $src, string $template, array $options): string {
+        $darkroom = Darkroom::factory(option('thumbs.driver', 'gd'), option('thumbs', []));
+        $options  = $darkroom->preprocess($src, $options);
+        $root     = (new Filename($src, $template, $options))->toString();
+
+        F::copy($src, $root, true);
+        $darkroom->process($root, $options);
+
+        return $root;
+    },
+
+    /**
+     * Modify all URLs
+     *
+     * @param \Kirby\Cms\App $kirby Kirby instance
+     * @param string $path URL path
+     * @param array|string|null $options Array of options for the Uri class
+     * @param Closure $originalHandler Deprecated: Callback function to the original URL handler with `$path` and `$options` as parameters
+     *                                 Use `$kirby->nativeComponent('url')` inside your URL component instead.
+     * @return string
+     *
+     * @todo Remove $originalHandler parameter in 3.6.0
+     */
+    'url' => function (App $kirby, string $path = null, $options = null, Closure $originalHandler = null): string {
+        $language = null;
+
+        // get language from simple string option
+        if (is_string($options) === true) {
+            $language = $options;
+            $options  = null;
+        }
+
+        // get language from array
+        if (is_array($options) === true && isset($options['language']) === true) {
+            $language = $options['language'];
+            unset($options['language']);
+        }
+
+        // get a language url for the linked page, if the page can be found
+        if ($kirby->multilang() === true) {
+            $parts = Str::split($path, '#');
+
+            if ($page = page($parts[0] ?? null)) {
+                $path = $page->url($language);
+
+                if (isset($parts[1]) === true) {
+                    $path .= '#' . $parts[1];
+                }
+            }
+        }
+
+        // keep relative urls
+        if (substr($path, 0, 2) === './' || substr($path, 0, 3) === '../') {
+            return $path;
+        }
+
+        $url = Url::makeAbsolute($path, $kirby->url());
+
+        if ($options === null) {
+            return $url;
+        }
+
+        return (new Uri($url, $options))->toString();
+    },
+
+];

kirby/config/fields.php

@@ -0,0 +1,32 @@
+<?php
+
+return [
+    'blocks'      => 'Kirby\Form\Field\BlocksField',
+    'checkboxes'  => __DIR__ . '/fields/checkboxes.php',
+    'date'        => __DIR__ . '/fields/date.php',
+    'email'       => __DIR__ . '/fields/email.php',
+    'files'       => __DIR__ . '/fields/files.php',
+    'gap'         => __DIR__ . '/fields/gap.php',
+    'headline'    => __DIR__ . '/fields/headline.php',
+    'hidden'      => __DIR__ . '/fields/hidden.php',
+    'info'        => __DIR__ . '/fields/info.php',
+    'layout'      => 'Kirby\Form\Field\LayoutField',
+    'line'        => __DIR__ . '/fields/line.php',
+    'list'        => __DIR__ . '/fields/list.php',
+    'multiselect' => __DIR__ . '/fields/multiselect.php',
+    'number'      => __DIR__ . '/fields/number.php',
+    'pages'       => __DIR__ . '/fields/pages.php',
+    'radio'       => __DIR__ . '/fields/radio.php',
+    'range'       => __DIR__ . '/fields/range.php',
+    'select'      => __DIR__ . '/fields/select.php',
+    'structure'   => __DIR__ . '/fields/structure.php',
+    'tags'        => __DIR__ . '/fields/tags.php',
+    'tel'         => __DIR__ . '/fields/tel.php',
+    'text'        => __DIR__ . '/fields/text.php',
+    'textarea'    => __DIR__ . '/fields/textarea.php',
+    'time'        => __DIR__ . '/fields/time.php',
+    'toggle'      => __DIR__ . '/fields/toggle.php',
+    'url'         => __DIR__ . '/fields/url.php',
+    'users'       => __DIR__ . '/fields/users.php',
+    'writer'      => __DIR__ . '/fields/writer.php'
+];

kirby/config/fields/checkboxes.php

@@ -0,0 +1,61 @@
+<?php
+
+use Kirby\Toolkit\A;
+use Kirby\Toolkit\Str;
+
+return [
+    'mixins' => ['min', 'options'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'before'      => null,
+        'icon'        => null,
+        'placeholder' => null,
+
+        /**
+         * Arranges the checkboxes in the given number of columns
+         */
+        'columns' => function (int $columns = 1) {
+            return $columns;
+        },
+        /**
+         * Default value for the field, which will be used when a page/file/user is created
+         */
+        'default' => function ($default = null) {
+            return Str::split($default, ',');
+        },
+        /**
+         * Maximum number of checked boxes
+         */
+        'max' => function (int $max = null) {
+            return $max;
+        },
+        /**
+         * Minimum number of checked boxes
+         */
+        'min' => function (int $min = null) {
+            return $min;
+        },
+        'value' => function ($value = null) {
+            return Str::split($value, ',');
+        },
+    ],
+    'computed' => [
+        'default' => function () {
+            return $this->sanitizeOptions($this->default);
+        },
+        'value' => function () {
+            return $this->sanitizeOptions($this->value);
+        },
+    ],
+    'save' => function ($value): string {
+        return A::join($value, ', ');
+    },
+    'validations' => [
+        'options',
+        'max',
+        'min'
+    ]
+];

kirby/config/fields/date.php

@@ -0,0 +1,179 @@
+<?php
+
+use Kirby\Exception\Exception;
+use Kirby\Form\Field;
+use Kirby\Toolkit\I18n;
+use Kirby\Toolkit\Str;
+
+return [
+    'mixins' => ['datetime'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'placeholder' => null,
+
+        /**
+         * Activate/deactivate the dropdown calendar
+         */
+        'calendar' => function (bool $calendar = true) {
+            return $calendar;
+        },
+
+
+        /**
+         * Default date when a new page/file/user gets created
+         */
+        'default' => function (string $default = null) {
+            return $default;
+        },
+
+        /**
+         * Custom format (dayjs tokens: `DD`, `MM`, `YYYY`) that is
+         * used to display the field in the Panel
+         */
+        'display' => function ($display = 'YYYY-MM-DD') {
+            return I18n::translate($display, $display);
+        },
+
+        /**
+         * Changes the calendar icon to something custom
+         */
+        'icon' => function (string $icon = 'calendar') {
+            return $icon;
+        },
+
+        /**
+         * Latest date, which can be selected/saved (Y-m-d)
+         */
+        'max' => function (string $max = null) {
+            return $this->toDatetime($max);
+        },
+        /**
+         * Earliest date, which can be selected/saved (Y-m-d)
+         */
+        'min' => function (string $min = null) {
+            return $this->toDatetime($min);
+        },
+
+        /**
+         * Round to the nearest: sub-options for `unit` (day) and `size` (1)
+         */
+        'step' => function ($step = null) {
+            $default = [
+                'size' => 1,
+                'unit' => 'day'
+            ];
+
+            if ($step === null) {
+                return $default;
+            }
+
+            if (is_array($step) === true) {
+                $step = array_merge($default, $step);
+                $step['unit'] = strtolower($step['unit']);
+                return $step;
+            }
+
+            if (is_int($step) === true) {
+                return array_merge($default, ['size' => $step]);
+            }
+
+            if (is_string($step) === true) {
+                return array_merge($default, ['unit' => strtolower($step)]);
+            }
+        },
+
+        /**
+         * Pass `true` or an array of time field options to show the time selector.
+         */
+        'time' => function ($time = false) {
+            return $time;
+        },
+        /**
+         * Must be a parseable date string
+         */
+        'value' => function ($value = null) {
+            return $value;
+        },
+    ],
+    'computed' => [
+        'default' => function () {
+            return $this->toDatetime($this->default);
+        },
+        'display' => function () {
+            if ($this->display) {
+                return Str::upper($this->display);
+            }
+        },
+        'format' => function () {
+            return $this->props['format'] ?? ($this->time === false ? 'Y-m-d' : 'Y-m-d H:i:s');
+        },
+        'time' => function () {
+            if ($this->time === false) {
+                return false;
+            }
+
+            $props = is_array($this->time) ? $this->time : [];
+            $props['model'] = $this->model();
+            $field = new Field('time', $props);
+            return $field->toArray();
+        },
+        'step' => function () {
+            if ($this->time === false) {
+                return $this->step;
+            }
+
+            return $this->time['step'];
+        },
+        'value' => function () {
+            return $this->toDatetime($this->value);
+        },
+    ],
+    'validations' => [
+        'date',
+        'minMax' => function ($value) {
+            $min    = $this->min ? strtotime($this->min) : null;
+            $max    = $this->max ? strtotime($this->max) : null;
+            $value  = strtotime($this->value());
+            $format = $this->time === false ? 'd.m.Y' : 'd.m.Y H:i';
+            $errors = [];
+
+            if ($value && $min && $value < $min) {
+                $errors['min'] = $min;
+            }
+
+            if ($value && $max && $value > $max) {
+                $errors['max'] = $max;
+            }
+
+            if (empty($errors) === false) {
+                if ($min && $max) {
+                    throw new Exception([
+                        'key' => 'validation.date.between',
+                        'data' => [
+                            'min' => date($format, $min),
+                            'max' => date($format, $max)
+                        ]
+                    ]);
+                } elseif ($min) {
+                    throw new Exception([
+                        'key' => 'validation.date.after',
+                        'data' => [
+                            'date' => date($format, $min),
+                        ]
+                    ]);
+                } else {
+                    throw new Exception([
+                        'key' => 'validation.date.before',
+                        'data' => [
+                            'date' => date($format, $max),
+                        ]
+                    ]);
+                }
+            }
+
+            return true;
+        },
+    ]
+];

kirby/config/fields/email.php

@@ -0,0 +1,40 @@
+<?php
+
+use Kirby\Toolkit\I18n;
+
+return [
+    'extends' => 'text',
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'converter' => null,
+        'counter'   => null,
+
+        /**
+         * Sets the HTML5 autocomplete mode for the input
+         */
+        'autocomplete' => function (string $autocomplete = 'email') {
+            return $autocomplete;
+        },
+
+        /**
+         * Changes the email icon to something custom
+         */
+        'icon' => function (string $icon = 'email') {
+            return $icon;
+        },
+
+        /**
+         * Custom placeholder text, when the field is empty.
+         */
+        'placeholder' => function ($value = null) {
+            return I18n::translate($value, $value) ?? I18n::translate('email.placeholder');
+        }
+    ],
+    'validations' => [
+        'minlength',
+        'maxlength',
+        'email'
+    ]
+];

kirby/config/fields/files.php

@@ -0,0 +1,138 @@
+<?php
+
+use Kirby\Data\Data;
+use Kirby\Toolkit\A;
+
+return [
+    'mixins' => [
+        'picker',
+        'filepicker',
+        'min',
+        'upload'
+    ],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'before'      => null,
+        'autofocus'   => null,
+        'icon'        => null,
+        'placeholder' => null,
+
+        /**
+         * Sets the file(s), which are selected by default when a new page is created
+         */
+        'default' => function ($default = null) {
+            return $default;
+        },
+
+        /**
+         * Changes the layout of the selected files. Available layouts: `list`, `cards`
+         */
+        'layout' => function (string $layout = 'list') {
+            return $layout;
+        },
+
+        /**
+         * Layout size for cards: `tiny`, `small`, `medium`, `large` or `huge`
+         */
+        'size' => function (string $size = 'auto') {
+            return $size;
+        },
+
+        'value' => function ($value = null) {
+            return $value;
+        }
+    ],
+    'computed' => [
+        'parentModel' => function () {
+            if (is_string($this->parent) === true && $model = $this->model()->query($this->parent, 'Kirby\Cms\Model')) {
+                return $model;
+            }
+
+            return $this->model();
+        },
+        'parent' => function () {
+            return $this->parentModel->apiUrl(true);
+        },
+        'query' => function () {
+            return $this->query ?? $this->parentModel::CLASS_ALIAS . '.files';
+        },
+        'default' => function () {
+            return $this->toFiles($this->default);
+        },
+        'value' => function () {
+            return $this->toFiles($this->value);
+        },
+    ],
+    'methods' => [
+        'fileResponse' => function ($file) {
+            return $file->panelPickerData([
+                'image' => $this->image,
+                'info'  => $this->info ?? false,
+                'model' => $this->model(),
+                'text'  => $this->text,
+            ]);
+        },
+        'toFiles' => function ($value = null) {
+            $files = [];
+
+            foreach (Data::decode($value, 'yaml') as $id) {
+                if (is_array($id) === true) {
+                    $id = $id['id'] ?? null;
+                }
+
+                if ($id !== null && ($file = $this->kirby()->file($id, $this->model()))) {
+                    $files[] = $this->fileResponse($file);
+                }
+            }
+
+            return $files;
+        }
+    ],
+    'api' => function () {
+        return [
+            [
+                'pattern' => '/',
+                'action'  => function () {
+                    $field = $this->field();
+
+                    return $field->filepicker([
+                        'image'  => $field->image(),
+                        'info'   => $field->info(),
+                        'limit'  => $field->limit(),
+                        'page'   => $this->requestQuery('page'),
+                        'query'  => $field->query(),
+                        'search' => $this->requestQuery('search'),
+                        'text'   => $field->text()
+                    ]);
+                }
+            ],
+            [
+                'pattern' => 'upload',
+                'method'  => 'POST',
+                'action'  => function () {
+                    $field   = $this->field();
+                    $uploads = $field->uploads();
+
+                    return $field->upload($this, $uploads, function ($file, $parent) use ($field) {
+                        return $file->panelPickerData([
+                            'image' => $field->image(),
+                            'info'  => $field->info(),
+                            'model' => $field->model(),
+                            'text'  => $field->text(),
+                        ]);
+                    });
+                }
+            ]
+        ];
+    },
+    'save' => function ($value = null) {
+        return A::pluck($value, 'uuid');
+    },
+    'validations' => [
+        'max',
+        'min'
+    ]
+];

kirby/config/fields/gap.php

@@ -0,0 +1,5 @@
+<?php
+
+return [
+    'save' => false
+];

kirby/config/fields/headline.php

@@ -0,0 +1,26 @@
+<?php
+
+return [
+    'save' => false,
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'autofocus'   => null,
+        'before'      => null,
+        'default'     => null,
+        'disabled'    => null,
+        'icon'        => null,
+        'placeholder' => null,
+        'required'    => null,
+        'translate'   => null,
+
+        /**
+         * If `false`, the prepended number will be hidden
+         */
+        'numbered' => function (bool $numbered = true) {
+            return $numbered;
+        }
+    ]
+];

kirby/config/fields/hidden.php

@@ -0,0 +1,3 @@
+<?php
+
+return [];

kirby/config/fields/info.php

@@ -0,0 +1,44 @@
+<?php
+
+use Kirby\Toolkit\I18n;
+
+return [
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'autofocus'   => null,
+        'before'      => null,
+        'default'     => null,
+        'disabled'    => null,
+        'icon'        => null,
+        'placeholder' => null,
+        'required'    => null,
+        'translate'   => null,
+
+        /**
+         * Text to be displayed
+         */
+        'text' => function ($value = null) {
+            return I18n::translate($value, $value);
+        },
+
+        /**
+         * Change the design of the info box
+         */
+        'theme' => function (string $theme = null) {
+            return $theme;
+        }
+    ],
+    'computed' => [
+        'text' => function () {
+            if ($text = $this->text) {
+                $text = $this->model()->toString($text);
+                $text = $this->kirby()->kirbytext($text);
+                return $text;
+            }
+        }
+    ],
+    'save' => false,
+];

kirby/config/fields/line.php

@@ -0,0 +1,5 @@
+<?php
+
+return [
+    'save' => false
+];

kirby/config/fields/list.php

@@ -0,0 +1,17 @@
+<?php
+
+return [
+    'props' => [
+        /**
+         * Sets the allowed HTML formats. Available formats: `bold`, `italic`, `underline`, `strike`, `code`, `link`. Activate them all by passing `true`. Deactivate them all by passing `false`
+         */
+        'marks' => function ($marks = true) {
+            return $marks;
+        }
+    ],
+    'computed' => [
+        'value' => function () {
+            return trim($this->value);
+        }
+    ]
+];

kirby/config/fields/mixins/datetime.php

@@ -0,0 +1,28 @@
+<?php
+
+return [
+    'props' => [
+        /**
+         * Defines a custom format that is used when the field is saved
+         */
+        'format' => function (string $format = null) {
+            return $format;
+        }
+    ],
+    'methods' => [
+        'toDatetime' => function ($value, string $format = 'Y-m-d H:i:s') {
+            if ($timestamp = timestamp($value, $this->step)) {
+                return date($format, $timestamp);
+            }
+
+            return null;
+        }
+    ],
+    'save' => function ($value) {
+        if ($value !== null && $timestamp = strtotime($value)) {
+            return date($this->format, $timestamp);
+        }
+
+        return '';
+    },
+];

kirby/config/fields/mixins/filepicker.php

@@ -0,0 +1,14 @@
+<?php
+
+use Kirby\Cms\FilePicker;
+
+return [
+    'methods' => [
+        'filepicker' => function (array $params = []) {
+            // fetch the parent model
+            $params['model'] = $this->model();
+
+            return (new FilePicker($params))->toArray();
+        }
+    ]
+];

kirby/config/fields/mixins/min.php

@@ -0,0 +1,22 @@
+<?php
+
+return [
+    'computed' => [
+        'min' => function () {
+            // set min to at least 1, if required
+            if ($this->required === true) {
+                return $this->min ?? 1;
+            }
+
+            return $this->min;
+        },
+        'required' => function () {
+            // set required to true if min is set
+            if ($this->min) {
+                return true;
+            }
+
+            return $this->required;
+        }
+    ]
+];

kirby/config/fields/mixins/options.php

@@ -0,0 +1,48 @@
+<?php
+
+use Kirby\Form\Options;
+
+return [
+    'props' => [
+        /**
+         * API settings for options requests. This will only take affect when `options` is set to `api`.
+         */
+        'api' => function ($api = null) {
+            return $api;
+        },
+        /**
+         * An array with options
+         */
+        'options' => function ($options = []) {
+            return $options;
+        },
+        /**
+         * Query settings for options queries. This will only take affect when `options` is set to `query`.
+         */
+        'query' => function ($query = null) {
+            return $query;
+        },
+    ],
+    'computed' => [
+        'options' => function (): array {
+            return $this->getOptions();
+        }
+    ],
+    'methods' => [
+        'getOptions' => function () {
+            return Options::factory(
+                $this->options(),
+                $this->props,
+                $this->model()
+            );
+        },
+        'sanitizeOption' => function ($option) {
+            $allowed = array_column($this->options(), 'value');
+            return in_array($option, $allowed, true) === true ? $option : null;
+        },
+        'sanitizeOptions' => function ($options) {
+            $allowed = array_column($this->options(), 'value');
+            return array_intersect($options, $allowed);
+        },
+    ]
+];

kirby/config/fields/mixins/pagepicker.php

@@ -0,0 +1,14 @@
+<?php
+
+use Kirby\Cms\PagePicker;
+
+return [
+    'methods' => [
+        'pagepicker' => function (array $params = []) {
+            // inject the current model
+            $params['model'] = $this->model();
+
+            return (new PagePicker($params))->toArray();
+        }
+    ]
+];

kirby/config/fields/mixins/picker.php

@@ -0,0 +1,78 @@
+<?php
+
+use Kirby\Toolkit\I18n;
+
+return [
+    'props' => [
+        /**
+         * The placeholder text if none have been selected yet
+         */
+        'empty' => function ($empty = null) {
+            return I18n::translate($empty, $empty);
+        },
+
+        /**
+         * Image settings for each item
+         */
+        'image' => function ($image = null) {
+            return $image;
+        },
+
+        /**
+         * Info text for each item
+         */
+        'info' => function (string $info = null) {
+            return $info;
+        },
+
+        /**
+         * Whether each item should be clickable
+         */
+        'link' => function (bool $link = true) {
+            return $link;
+        },
+
+        /**
+         * The minimum number of required selected
+         */
+        'min' => function (int $min = null) {
+            return $min;
+        },
+
+        /**
+         * The maximum number of allowed selected
+         */
+        'max' => function (int $max = null) {
+            return $max;
+        },
+
+        /**
+         * If `false`, only a single one can be selected
+         */
+        'multiple' => function (bool $multiple = true) {
+            return $multiple;
+        },
+
+        /**
+         * Query for the items to be included in the picker
+         */
+        'query' => function (string $query = null) {
+            return $query;
+        },
+
+        /**
+         * Enable/disable the search field in the picker
+         */
+        'search' => function (bool $search = true) {
+            return $search;
+        },
+
+        /**
+         * Main text for each item
+         */
+        'text' => function (string $text = null) {
+            return $text;
+        },
+
+    ],
+];

kirby/config/fields/mixins/upload.php

@@ -0,0 +1,72 @@
+<?php
+
+use Kirby\Cms\Api;
+use Kirby\Cms\File;
+use Kirby\Exception\Exception;
+
+return [
+    'props' => [
+        /**
+         * Sets the upload options for linked files (since 3.2.0)
+         */
+        'uploads' => function ($uploads = []) {
+            if ($uploads === false) {
+                return false;
+            }
+
+            if (is_string($uploads) === true) {
+                $uploads = ['template' => $uploads];
+            }
+
+            if (is_array($uploads) === false) {
+                $uploads = [];
+            }
+
+            $template = $uploads['template'] ?? null;
+
+            if ($template) {
+                $file = new File([
+                    'filename' => 'tmp',
+                    'template' => $template
+                ]);
+
+                $uploads['accept'] = $file->blueprint()->acceptMime();
+            } else {
+                $uploads['accept'] = '*';
+            }
+
+            return $uploads;
+        },
+    ],
+    'methods' => [
+        'upload' => function (Api $api, $params, Closure $map) {
+            if ($params === false) {
+                throw new Exception('Uploads are disabled for this field');
+            }
+
+            if ($parentQuery = ($params['parent'] ?? null)) {
+                $parent = $this->model()->query($parentQuery);
+            } else {
+                $parent = $this->model();
+            }
+
+            if (is_a($parent, 'Kirby\Cms\File') === true) {
+                $parent = $parent->parent();
+            }
+
+            return $api->upload(function ($source, $filename) use ($parent, $params, $map) {
+                $file = $parent->createFile([
+                    'source'   => $source,
+                    'template' => $params['template'] ?? null,
+                    'filename' => $filename,
+                ]);
+
+                if (is_a($file, 'Kirby\Cms\File') === false) {
+                    throw new Exception('The file could not be uploaded');
+                }
+
+                return $map($file, $parent);
+            });
+        }
+    ]
+];

kirby/config/fields/mixins/userpicker.php

@@ -0,0 +1,13 @@
+<?php
+
+use Kirby\Cms\UserPicker;
+
+return [
+    'methods' => [
+        'userpicker' => function (array $params = []) {
+            $params['model'] = $this->model();
+
+            return (new UserPicker($params))->toArray();
+        }
+    ]
+];

kirby/config/fields/multiselect.php

@@ -0,0 +1,32 @@
+<?php
+
+return [
+    'extends' => 'tags',
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'accept' => null,
+        /**
+         * Custom icon to replace the arrow down.
+         */
+        'icon' => function (string $icon = null) {
+            return $icon;
+        },
+        /**
+         * Enable/disable the search in the dropdown
+         * Also limit displayed items (display: 20)
+         * and set minimum number of characters to search (min: 3)
+         */
+        'search' => function ($search = true) {
+            return $search;
+        },
+        /**
+         * If `true`, selected entries will be sorted
+         * according to their position in the dropdown
+         */
+        'sort' => function (bool $sort = false) {
+            return $sort;
+        },
+    ]
+];

kirby/config/fields/number.php

@@ -0,0 +1,48 @@
+<?php
+
+use Kirby\Toolkit\Str;
+
+return [
+    'props' => [
+        /**
+         * Default number that will be saved when a new page/user/file is created
+         */
+        'default' => function ($default = null) {
+            return $this->toNumber($default);
+        },
+        /**
+         * The lowest allowed number
+         */
+        'min' => function (float $min = null) {
+            return $min;
+        },
+        /**
+         * The highest allowed number
+         */
+        'max' => function (float $max = null) {
+            return $max;
+        },
+        /**
+         * Allowed incremental steps between numbers (i.e `0.5`)
+         */
+        'step' => function ($step = null) {
+            return $this->toNumber($step);
+        },
+        'value' => function ($value = null) {
+            return $this->toNumber($value);
+        }
+    ],
+    'methods' => [
+        'toNumber' => function ($value) {
+            if ($this->isEmpty($value) === true) {
+                return null;
+            }
+
+            return is_float($value) === true ? $value : (float)Str::float($value);
+        }
+    ],
+    'validations' => [
+        'min',
+        'max'
+    ]
+];

kirby/config/fields/pages.php

@@ -0,0 +1,117 @@
+<?php
+
+use Kirby\Data\Data;
+use Kirby\Toolkit\A;
+
+return [
+    'mixins' => ['min', 'pagepicker', 'picker'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'autofocus'   => null,
+        'before'      => null,
+        'icon'        => null,
+        'placeholder' => null,
+
+        /**
+         * Default selected page(s) when a new page/file/user is created
+         */
+        'default' => function ($default = null) {
+            return $this->toPages($default);
+        },
+
+        /**
+         * Changes the layout of the selected files. Available layouts: `list`, `cards`
+         */
+        'layout' => function (string $layout = 'list') {
+            return $layout;
+        },
+
+        /**
+         * Optional query to select a specific set of pages
+         */
+        'query' => function (string $query = null) {
+            return $query;
+        },
+
+        /**
+         * Layout size for cards: `tiny`, `small`, `medium`, `large` or `huge`
+         */
+        'size' => function (string $size = 'auto') {
+            return $size;
+        },
+
+        /**
+         * Optionally include subpages of pages
+         */
+        'subpages' => function (bool $subpages = true) {
+            return $subpages;
+        },
+
+        'value' => function ($value = null) {
+            return $this->toPages($value);
+        },
+    ],
+    'computed' => [
+        /**
+         * Unset inherited computed
+         */
+        'default' => null
+    ],
+    'methods' => [
+        'pageResponse' => function ($page) {
+            return $page->panelPickerData([
+                'image' => $this->image,
+                'info'  => $this->info,
+                'text'  => $this->text,
+            ]);
+        },
+        'toPages' => function ($value = null) {
+            $pages = [];
+            $kirby = kirby();
+
+            foreach (Data::decode($value, 'yaml') as $id) {
+                if (is_array($id) === true) {
+                    $id = $id['id'] ?? null;
+                }
+
+                if ($id !== null && ($page = $kirby->page($id))) {
+                    $pages[] = $this->pageResponse($page);
+                }
+            }
+
+            return $pages;
+        }
+    ],
+    'api' => function () {
+        return [
+            [
+                'pattern' => '/',
+                'action' => function () {
+                    $field = $this->field();
+
+                    return $field->pagepicker([
+                        'image'    => $field->image(),
+                        'info'     => $field->info(),
+                        'limit'    => $field->limit(),
+                        'page'     => $this->requestQuery('page'),
+                        'parent'   => $this->requestQuery('parent'),
+                        'query'    => $field->query(),
+                        'search'   => $this->requestQuery('search'),
+                        'subpages' => $field->subpages(),
+                        'text'     => $field->text()
+                    ]);
+                }
+            ]
+        ];
+    },
+    'save' => function ($value = null) {
+        return A::pluck($value, 'id');
+    },
+    'validations' => [
+        'max',
+        'min'
+    ]
+];

kirby/config/fields/radio.php

@@ -0,0 +1,29 @@
+<?php
+
+return [
+    'mixins' => ['options'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'before'      => null,
+        'icon'        => null,
+        'placeholder' => null,
+
+        /**
+         * Arranges the radio buttons in the given number of columns
+         */
+        'columns' => function (int $columns = 1) {
+            return $columns;
+        },
+    ],
+    'computed' => [
+        'default' => function () {
+            return $this->sanitizeOption($this->default);
+        },
+        'value' => function () {
+            return $this->sanitizeOption($this->value) ?? '';
+        }
+    ]
+];

kirby/config/fields/range.php

@@ -0,0 +1,24 @@
+<?php
+
+return [
+    'extends' => 'number',
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'placeholder' => null,
+
+        /**
+         * The maximum value on the slider
+         */
+        'max' => function (float $max = 100) {
+            return $max;
+        },
+        /**
+         * Enables/disables the tooltip and set the before and after values
+         */
+        'tooltip' => function ($tooltip = true) {
+            return $tooltip;
+        },
+    ]
+];

kirby/config/fields/select.php

@@ -0,0 +1,24 @@
+<?php
+
+return [
+    'extends' => 'radio',
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'columns' => null,
+
+        /**
+         * Custom icon to replace the arrow down.
+         */
+        'icon' => function (string $icon = null) {
+            return $icon;
+        },
+        /**
+         * Custom placeholder string for empty option.
+         */
+        'placeholder' => function (string $placeholder = '—') {
+            return $placeholder;
+        },
+    ]
+];

kirby/config/fields/structure.php

@@ -0,0 +1,193 @@
+<?php
+
+use Kirby\Cms\Form;
+use Kirby\Data\Data;
+use Kirby\Toolkit\I18n;
+
+return [
+    'mixins' => ['min'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'before'      => null,
+        'autofocus'   => null,
+        'icon'        => null,
+        'placeholder' => null,
+
+        /**
+         * Optional columns definition to only show selected fields in the structure table.
+         */
+        'columns' => function (array $columns = []) {
+            // lower case all keys, because field names will
+            // be lowercase as well.
+            return array_change_key_case($columns);
+        },
+
+        /**
+         * Toggles duplicating rows for the structure
+         */
+        'duplicate' => function (bool $duplicate = true) {
+            return $duplicate;
+        },
+
+        /**
+         * The placeholder text if no items have been added yet
+         */
+        'empty' => function ($empty = null) {
+            return I18n::translate($empty, $empty);
+        },
+
+        /**
+         * Set the default rows for the structure
+         */
+        'default' => function (array $default = null) {
+            return $default;
+        },
+
+        /**
+         * Fields setup for the structure form. Works just like fields in regular forms.
+         */
+        'fields' => function (array $fields) {
+            return $fields;
+        },
+        /**
+         * The number of entries that will be displayed on a single page. Afterwards pagination kicks in.
+         */
+        'limit' => function (int $limit = null) {
+            return $limit;
+        },
+        /**
+         * Maximum allowed entries in the structure. Afterwards the "Add" button will be switched off.
+         */
+        'max' => function (int $max = null) {
+            return $max;
+        },
+        /**
+         * Minimum required entries in the structure
+         */
+        'min' => function (int $min = null) {
+            return $min;
+        },
+        /**
+         * Toggles adding to the top or bottom of the list
+         */
+        'prepend' => function (bool $prepend = null) {
+            return $prepend;
+        },
+        /**
+         * Toggles drag & drop sorting
+         */
+        'sortable' => function (bool $sortable = null) {
+            return $sortable;
+        },
+        /**
+         * Sorts the entries by the given field and order (i.e. `title desc`)
+         * Drag & drop is disabled in this case
+         */
+        'sortBy' => function (string $sort = null) {
+            return $sort;
+        }
+    ],
+    'computed' => [
+        'default' => function () {
+            return $this->rows($this->default);
+        },
+        'value' => function () {
+            return $this->rows($this->value);
+        },
+        'fields' => function () {
+            if (empty($this->fields) === true) {
+                throw new Exception('Please provide some fields for the structure');
+            }
+
+            return $this->form()->fields()->toArray();
+        },
+        'columns' => function () {
+            $columns = [];
+
+            if (empty($this->columns)) {
+                foreach ($this->fields as $field) {
+
+                    // Skip hidden and unsaveable fields
+                    // They should never be included as column
+                    if ($field['type'] === 'hidden' || $field['saveable'] === false) {
+                        continue;
+                    }
+
+                    $columns[$field['name']] = [
+                        'type'  => $field['type'],
+                        'label' => $field['label'] ?? $field['name']
+                    ];
+                }
+            } else {
+                foreach ($this->columns as $columnName => $columnProps) {
+                    if (is_array($columnProps) === false) {
+                        $columnProps = [];
+                    }
+
+                    $field = $this->fields[$columnName] ?? null;
+
+                    if (empty($field) === true || $field['saveable'] === false) {
+                        continue;
+                    }
+
+                    $columns[$columnName] = array_merge($columnProps, [
+                        'type'  => $field['type'],
+                        'label' => $field['label'] ?? $field['name']
+                    ]);
+                }
+            }
+
+            return $columns;
+        }
+    ],
+    'methods' => [
+        'rows' => function ($value) {
+            $rows  = Data::decode($value, 'yaml');
+            $value = [];
+
+            foreach ($rows as $index => $row) {
+                if (is_array($row) === false) {
+                    continue;
+                }
+
+                $value[] = $this->form($row)->values();
+            }
+
+            return $value;
+        },
+        'form' => function (array $values = []) {
+            return new Form([
+                'fields' => $this->attrs['fields'],
+                'values' => $values,
+                'model'  => $this->model
+            ]);
+        },
+    ],
+    'api' => function () {
+        return [
+            [
+                'pattern' => 'validate',
+                'method'  => 'ALL',
+                'action'  => function () {
+                    return array_values($this->field()->form($this->requestBody())->errors());
+                }
+            ]
+        ];
+    },
+    'save' => function ($value) {
+        $data = [];
+
+        foreach ($value as $row) {
+            $data[] = $this->form($row)->content();
+        }
+
+        return $data;
+    },
+    'validations' => [
+        'min',
+        'max'
+    ]
+];

kirby/config/fields/tags.php

@@ -0,0 +1,103 @@
+<?php
+
+use Kirby\Toolkit\A;
+use Kirby\Toolkit\Str;
+use Kirby\Toolkit\V;
+
+return [
+    'mixins' => ['min', 'options'],
+    'props' => [
+
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'before'      => null,
+        'placeholder' => null,
+
+        /**
+         * If set to `all`, any type of input is accepted. If set to `options` only the predefined options are accepted as input.
+         */
+        'accept' => function ($value = 'all') {
+            return V::in($value, ['all', 'options']) ? $value : 'all';
+        },
+        /**
+         * Changes the tag icon
+         */
+        'icon' => function ($icon = 'tag') {
+            return $icon;
+        },
+        /**
+         * Set to `list` to display each tag with 100% width,
+         * otherwise the tags are displayed inline
+         */
+        'layout' => function (?string $layout = null) {
+            return $layout;
+        },
+        /**
+         * Minimum number of required entries/tags
+         */
+        'min' => function (int $min = null) {
+            return $min;
+        },
+        /**
+         * Maximum number of allowed entries/tags
+         */
+        'max' => function (int $max = null) {
+            return $max;
+        },
+        /**
+         * Custom tags separator, which will be used to store tags in the content file
+         */
+        'separator' => function (string $separator = ',') {
+            return $separator;
+        },
+    ],
+    'computed' => [
+        'default' => function (): array {
+            return $this->toTags($this->default);
+        },
+        'value' => function (): array {
+            return $this->toTags($this->value);
+        }
+    ],
+    'methods' => [
+        'toTags' => function ($value) {
+            if (is_null($value) === true) {
+                return [];
+            }
+
+            $options = $this->options();
+
+            // transform into value-text objects
+            return array_map(function ($option) use ($options) {
+
+                // already a valid object
+                if (is_array($option) === true && isset($option['value'], $option['text']) === true) {
+                    return $option;
+                }
+
+                $index = array_search($option, array_column($options, 'value'));
+
+                if ($index !== false) {
+                    return $options[$index];
+                }
+
+                return [
+                    'value' => $option,
+                    'text'  => $option,
+                ];
+            }, Str::split($value, $this->separator()));
+        }
+    ],
+    'save' => function (array $value = null): string {
+        return A::join(
+            A::pluck($value, 'value'),
+            $this->separator() . ' '
+        );
+    },
+    'validations' => [
+        'min',
+        'max'
+    ]
+];

kirby/config/fields/tel.php

@@ -0,0 +1,27 @@
+<?php
+
+return [
+    'extends' => 'text',
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'converter'  => null,
+        'counter'    => null,
+        'spellcheck' => null,
+
+        /**
+         * Sets the HTML5 autocomplete attribute
+         */
+        'autocomplete' => function (string $autocomplete = 'tel') {
+            return $autocomplete;
+        },
+
+        /**
+         * Changes the phone icon
+         */
+        'icon' => function (string $icon = 'phone') {
+            return $icon;
+        }
+    ]
+];

kirby/config/fields/text.php

@@ -0,0 +1,103 @@
+<?php
+
+use Kirby\Exception\InvalidArgumentException;
+use Kirby\Toolkit\Str;
+
+return [
+    'props' => [
+
+        /**
+         * The field value will be converted with the selected converter before the value gets saved. Available converters: `lower`, `upper`, `ucfirst`, `slug`
+         */
+        'converter' => function ($value = null) {
+            if ($value !== null && in_array($value, array_keys($this->converters())) === false) {
+                throw new InvalidArgumentException([
+                    'key'  => 'field.converter.invalid',
+                    'data' => ['converter' => $value]
+                ]);
+            }
+
+            return $value;
+        },
+
+        /**
+         * Shows or hides the character counter in the top right corner
+         */
+        'counter' => function (bool $counter = true) {
+            return $counter;
+        },
+
+        /**
+         * Maximum number of allowed characters
+         */
+        'maxlength' => function (int $maxlength = null) {
+            return $maxlength;
+        },
+
+        /**
+         * Minimum number of required characters
+         */
+        'minlength' => function (int $minlength = null) {
+            return $minlength;
+        },
+
+        /**
+         * A regular expression, which will be used to validate the input
+         */
+        'pattern' => function (string $pattern = null) {
+            return $pattern;
+        },
+
+        /**
+         * If `false`, spellcheck will be switched off
+         */
+        'spellcheck' => function (bool $spellcheck = false) {
+            return $spellcheck;
+        },
+    ],
+    'computed' => [
+        'default' => function () {
+            return $this->convert($this->default);
+        },
+        'value' => function () {
+            return (string)$this->convert($this->value);
+        }
+    ],
+    'methods' => [
+        'convert' => function ($value) {
+            if ($this->converter() === null) {
+                return $value;
+            }
+
+            $value     = trim($value);
+            $converter = $this->converters()[$this->converter()];
+
+            if (is_array($value) === true) {
+                return array_map($converter, $value);
+            }
+
+            return call_user_func($converter, $value);
+        },
+        'converters' => function (): array {
+            return [
+                'lower' => function ($value) {
+                    return Str::lower($value);
+                },
+                'slug' => function ($value) {
+                    return Str::slug($value);
+                },
+                'ucfirst' => function ($value) {
+                    return Str::ucfirst($value);
+                },
+                'upper' => function ($value) {
+                    return Str::upper($value);
+                },
+            ];
+        },
+    ],
+    'validations' => [
+        'minlength',
+        'maxlength',
+        'pattern'
+    ]
+];

kirby/config/fields/textarea.php

@@ -0,0 +1,123 @@
+<?php
+
+return [
+    'mixins' => ['filepicker', 'upload'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'  => null,
+        'before' => null,
+
+        /**
+         * Enables/disables the format buttons. Can either be `true`/`false` or a list of allowed buttons. Available buttons: `headlines`, `italic`, `bold`, `link`, `email`, `file`, `code`, `ul`, `ol` (as well as `|` for a divider)
+         */
+        'buttons' => function ($buttons = true) {
+            return $buttons;
+        },
+
+        /**
+         * Enables/disables the character counter in the top right corner
+         */
+        'counter' => function (bool $counter = true) {
+            return $counter;
+        },
+
+        /**
+         * Sets the default text when a new page/file/user is created
+         */
+        'default' => function (string $default = null) {
+            return trim($default);
+        },
+
+        /**
+         * Sets the options for the files picker
+         */
+        'files' => function ($files = []) {
+            if (is_string($files) === true) {
+                return ['query' => $files];
+            }
+
+            if (is_array($files) === false) {
+                $files = [];
+            }
+
+            return $files;
+        },
+
+        /**
+         * Sets the font family (sans or monospace)
+         */
+        'font' => function (string $font = null) {
+            return $font === 'monospace' ? 'monospace' : 'sans-serif';
+        },
+
+        /**
+         * Maximum number of allowed characters
+         */
+        'maxlength' => function (int $maxlength = null) {
+            return $maxlength;
+        },
+
+        /**
+         * Minimum number of required characters
+         */
+        'minlength' => function (int $minlength = null) {
+            return $minlength;
+        },
+
+        /**
+         * Changes the size of the textarea. Available sizes: `small`, `medium`, `large`, `huge`
+         */
+        'size' => function (string $size = null) {
+            return $size;
+        },
+
+        /**
+         * If `false`, spellcheck will be switched off
+         */
+        'spellcheck' => function (bool $spellcheck = true) {
+            return $spellcheck;
+        },
+
+        'value' => function (string $value = null) {
+            return trim($value);
+        }
+    ],
+    'api' => function () {
+        return [
+            [
+                'pattern' => 'files',
+                'action' => function () {
+                    $params = array_merge($this->field()->files(), [
+                        'page'   => $this->requestQuery('page'),
+                        'search' => $this->requestQuery('search')
+                    ]);
+
+                    return $this->field()->filepicker($params);
+                }
+            ],
+            [
+                'pattern' => 'upload',
+                'method' => 'POST',
+                'action' => function () {
+                    $field   = $this->field();
+                    $uploads = $field->uploads();
+
+                    return $this->field()->upload($this, $uploads, function ($file, $parent) use ($field) {
+                        $absolute = $field->model()->is($parent) === false;
+
+                        return [
+                            'filename' => $file->filename(),
+                            'dragText' => $file->dragText('auto', $absolute),
+                        ];
+                    });
+                }
+            ]
+        ];
+    },
+    'validations' => [
+        'minlength',
+        'maxlength'
+    ]
+];

kirby/config/fields/time.php

@@ -0,0 +1,151 @@
+<?php
+
+use Kirby\Exception\Exception;
+use Kirby\Toolkit\I18n;
+
+return [
+    'mixins' => ['datetime'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'placeholder' => null,
+
+
+        /**
+         * Sets the default time when a new page/file/user is created
+         */
+        'default' => function ($default = null) {
+            return $default;
+        },
+
+        /**
+         * Custom format (dayjs tokens: `HH`, `hh`, `mm`, `ss`, `a`) that is
+         * used to display the field in the Panel
+         */
+        'display' => function ($display = null) {
+            return I18n::translate($display, $display);
+        },
+
+        /**
+         * Changes the clock icon
+         */
+        'icon' => function (string $icon = 'clock') {
+            return $icon;
+        },
+        /**
+         * Latest time, which can be selected/saved (H:i or H:i:s)
+         */
+        'max' => function (string $max = null) {
+            return $max ? $this->toDatetime(date('Y-m-d ') . $max) : null;
+        },
+        /**
+         * Earliest time, which can be selected/saved (H:i or H:i:s)
+         */
+        'min' => function (string $min = null) {
+            return $min ? $this->toDatetime(date('Y-m-d ') . $min) : null;
+        },
+
+        /**
+         * `12` or `24` hour notation. If `12`, an AM/PM selector will be shown.
+         * If `display` is defined, that option will take priority.
+         */
+        'notation' => function (int $value = 24) {
+            return $value === 24 ? 24 : 12;
+        },
+        /**
+         * Round to the nearest: sub-options for `unit` (minute) and `size` (5)
+         */
+        'step' => function ($step = null) {
+            $default = [
+                'size' => 5,
+                'unit' => 'minute'
+            ];
+
+            if ($step === null) {
+                return $default;
+            }
+
+            if (is_array($step) === true) {
+                $step = array_merge($default, $step);
+                $step['unit'] = strtolower($step['unit']);
+                return $step;
+            }
+
+            if (is_int($step) === true) {
+                return array_merge($default, ['size' => $step]);
+            }
+
+            if (is_string($step) === true) {
+                return array_merge($default, ['unit' => strtolower($step)]);
+            }
+        },
+        'value' => function ($value = null) {
+            return $value;
+        }
+    ],
+    'computed' => [
+        'default' => function () {
+            return $this->toDatetime($this->default, 'H:i:s');
+        },
+        'display' => function () {
+            if ($this->display) {
+                return $this->display;
+            }
+
+            return $this->notation === 24 ? 'HH:mm' : 'h:mm a';
+        },
+        'format' => function () {
+            return $this->props['format'] ?? 'H:i:s';
+        },
+        'value' => function () {
+            return $this->toDatetime($this->value, 'H:i:s');
+        }
+    ],
+    'validations' => [
+        'time',
+        'minMax' => function ($value) {
+            $min    = $this->min ? strtotime($this->min) : null;
+            $max    = $this->max ? strtotime($this->max) : null;
+            $value  = strtotime($this->value());
+            $format = 'H:i:s';
+            $errors = [];
+
+            if ($value && $min && $value < $min) {
+                $errors['min'] = $min;
+            }
+
+            if ($value && $max && $value > $max) {
+                $errors['max'] = $max;
+            }
+
+            if (empty($errors) === false) {
+                if ($min && $max) {
+                    throw new Exception([
+                        'key' => 'validation.time.between',
+                        'data' => [
+                            'min' => date($format, $min),
+                            'max' => date($format, $max)
+                        ]
+                    ]);
+                } elseif ($min) {
+                    throw new Exception([
+                        'key' => 'validation.time.after',
+                        'data' => [
+                            'time' => date($format, $min),
+                        ]
+                    ]);
+                } else {
+                    throw new Exception([
+                        'key' => 'validation.time.before',
+                        'data' => [
+                            'time' => date($format, $max),
+                        ]
+                    ]);
+                }
+            }
+
+            return true;
+        },
+    ]
+];

kirby/config/fields/toggle.php

@@ -0,0 +1,66 @@
+<?php
+
+use Kirby\Exception\InvalidArgumentException;
+use Kirby\Toolkit\I18n;
+
+return [
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'placeholder' => null,
+
+        /**
+         * Default value which will be saved when a new page/user/file is created
+         */
+        'default' => function ($default = null) {
+            return $this->default = $default;
+        },
+        /**
+         * Sets the text next to the toggle. The text can be a string or an array of two options. The first one is the negative text and the second one the positive. The text will automatically switch when the toggle is triggered.
+         */
+        'text' => function ($value = null) {
+            if (is_array($value) === true) {
+                if (A::isAssociative($value) === true) {
+                    return I18n::translate($value, $value);
+                }
+
+                foreach ($value as $key => $val) {
+                    $value[$key] = I18n::translate($val, $val);
+                }
+
+                return $value;
+            }
+
+            return I18n::translate($value, $value);
+        },
+    ],
+    'computed' => [
+        'default' => function () {
+            return $this->toBool($this->default);
+        },
+        'value' => function () {
+            if ($this->props['value'] === null) {
+                return $this->default();
+            } else {
+                return $this->toBool($this->props['value']);
+            }
+        }
+    ],
+    'methods' => [
+        'toBool' => function ($value) {
+            return in_array($value, [true, 'true', 1, '1', 'on'], true) === true;
+        }
+    ],
+    'save' => function (): string {
+        return $this->value() === true ? 'true' : 'false';
+    },
+    'validations' => [
+        'boolean',
+        'required' => function ($value) {
+            if ($this->isRequired() && ($value === false || $this->isEmpty($value))) {
+                throw new InvalidArgumentException(I18n::translate('field.required'));
+            }
+        },
+    ]
+];

kirby/config/fields/url.php

@@ -0,0 +1,41 @@
+<?php
+
+use Kirby\Toolkit\I18n;
+
+return [
+    'extends' => 'text',
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'converter'  => null,
+        'counter'    => null,
+        'spellcheck' => null,
+
+        /**
+         * Sets the HTML5 autocomplete attribute
+         */
+        'autocomplete' => function (string $autocomplete = 'url') {
+            return $autocomplete;
+        },
+
+        /**
+         * Changes the link icon
+         */
+        'icon' => function (string $icon = 'url') {
+            return $icon;
+        },
+
+        /**
+         * Sets custom placeholder text, when the field is empty
+         */
+        'placeholder'  => function ($value = null) {
+            return I18n::translate($value, $value) ?? 'https://example.com';
+        }
+    ],
+    'validations' => [
+        'minlength',
+        'maxlength',
+        'url'
+    ],
+];

kirby/config/fields/users.php

@@ -0,0 +1,97 @@
+<?php
+
+use Kirby\Data\Data;
+use Kirby\Toolkit\A;
+
+return [
+    'mixins' => ['min', 'picker', 'userpicker'],
+    'props' => [
+        /**
+         * Unset inherited props
+         */
+        'after'       => null,
+        'autofocus'   => null,
+        'before'      => null,
+        'icon'        => null,
+        'placeholder' => null,
+
+        /**
+         * Default selected user(s) when a new page/file/user is created
+         */
+        'default' => function ($default = null) {
+            if ($default === false) {
+                return [];
+            }
+
+            if ($default === null && $user = $this->kirby()->user()) {
+                return [
+                    $this->userResponse($user)
+                ];
+            }
+
+            return $this->toUsers($default);
+        },
+
+        'value' => function ($value = null) {
+            return $this->toUsers($value);
+        },
+    ],
+    'computed' => [
+        /**
+         * Unset inherited computed
+         */
+        'default' => null
+    ],
+    'methods' => [
+        'userResponse' => function ($user) {
+            return $user->panelPickerData([
+                'info'  => $this->info,
+                'image' => $this->image,
+                'text'  => $this->text,
+            ]);
+        },
+        'toUsers' => function ($value = null) {
+            $users = [];
+            $kirby = kirby();
+
+            foreach (Data::decode($value, 'yaml') as $email) {
+                if (is_array($email) === true) {
+                    $email = $email['email'] ?? null;
+                }
+
+                if ($email !== null && ($user = $kirby->user($email))) {
+                    $users[] = $this->userResponse($user);
+                }
+            }
+
+            return $users;
+        }
+    ],
+    'api' => function () {
+        return [
+            [
+                'pattern' => '/',
+                'action' => function () {
+                    $field = $this->field();
+
+                    return $field->userpicker([
+                        'image'  => $field->image(),
+                        'info'   => $field->info(),
+                        'limit'  => $field->limit(),
+                        'page'   => $this->requestQuery('page'),
+                        'query'  => $field->query(),
+                        'search' => $this->requestQuery('search'),
+                        'text'   => $field->text()
+                    ]);
+                }
+            ]
+        ];
+    },
+    'save' => function ($value = null) {
+        return A::pluck($value, 'id');
+    },
+    'validations' => [
+        'max',
+        'min'
+    ]
+];

kirby/config/fields/writer.php

@@ -0,0 +1,33 @@
+<?php
+
+return [
+    'props' => [
+        /**
+         * Enables inline mode, which will not wrap new lines in paragraphs and creates hard breaks instead.
+         *
+         * @param bool $inline
+         */
+        'inline' => function (bool $inline = false) {
+            return $inline;
+        },
+        /**
+         * Sets the allowed HTML formats. Available formats: `bold`, `italic`, `underline`, `strike`, `code`, `link`. Activate them all by passing `true`. Deactivate them all by passing `false`
+         * @param array|bool $marks
+         */
+        'marks' => function ($marks = true) {
+            return $marks;
+        },
+        /**
+         * Sets the allowed nodes. Available nodes: `bulletList`, `orderedList`, `heading`, `horizontalRule`, `listItem`. Activate/deactivate them all by passing `true`/`false`. Default nodes are `heading`, `bulletList`, `orderedList`.
+         * @param array|bool|null $nodes
+         */
+        'nodes' => function ($nodes = null) {
+            return $nodes;
+        }
+    ],
+    'computed' => [
+        'value' => function () {
+            return trim($this->value);
+        }
+    ],
+];

kirby/config/helpers.php

@@ -0,0 +1,953 @@
+<?php
+
+use Kirby\Cms\App;
+use Kirby\Cms\Asset;
+use Kirby\Cms\Html;
+use Kirby\Cms\Response;
+use Kirby\Cms\Url;
+use Kirby\Exception\InvalidArgumentException;
+use Kirby\Toolkit\Escape;
+use Kirby\Toolkit\F;
+use Kirby\Toolkit\I18n;
+use Kirby\Toolkit\Str;
+use Kirby\Toolkit\V;
+
+/**
+ * Helper to create an asset object
+ *
+ * @param string $path
+ * @return \Kirby\Cms\Asset
+ */
+function asset(string $path)
+{
+    return new Asset($path);
+}
+
+/**
+ * Generates a list of HTML attributes
+ *
+ * @param array $attr A list of attributes as key/value array
+ * @param string $before An optional string that will be prepended if the result is not empty
+ * @param string $after An optional string that will be appended if the result is not empty
+ * @return string
+ */
+function attr(array $attr = null, $before = null, $after = null)
+{
+    if ($attrs = Html::attr($attr)) {
+        return $before . $attrs . $after;
+    }
+
+    return null;
+}
+
+/**
+ * Returns the result of a collection by name
+ *
+ * @param string $name
+ * @return \Kirby\Cms\Collection|null
+ */
+function collection(string $name)
+{
+    return App::instance()->collection($name);
+}
+
+/**
+ * Checks / returns a CSRF token
+ *
+ * @param string $check Pass a token here to compare it to the one in the session
+ * @return string|bool Either the token or a boolean check result
+ */
+function csrf(string $check = null)
+{
+    $session = App::instance()->session();
+
+    // check explicitly if there have been no arguments at all;
+    // checking for null introduces a security issue because null could come
+    // from user input or bugs in the calling code!
+    if (func_num_args() === 0) {
+        // no arguments, generate/return a token
+
+        $token = $session->get('kirby.csrf');
+        if (is_string($token) !== true) {
+            $token = bin2hex(random_bytes(32));
+            $session->set('kirby.csrf', $token);
+        }
+
+        return $token;
+    } elseif (is_string($check) === true && is_string($session->get('kirby.csrf')) === true) {
+        // argument has been passed, check the token
+        return hash_equals($session->get('kirby.csrf'), $check) === true;
+    }
+
+    return false;
+}
+
+/**
+ * Creates one or multiple CSS link tags
+ *
+ * @param string|array $url Relative or absolute URLs, an array of URLs or `@auto` for automatic template css loading
+ * @param string|array $options Pass an array of attributes for the link tag or a media attribute string
+ * @return string|null
+ */
+function css($url, $options = null): ?string
+{
+    if (is_array($url) === true) {
+        $links = array_map(function ($url) use ($options) {
+            return css($url, $options);
+        }, $url);
+
+        return implode(PHP_EOL, $links);
+    }
+
+    if (is_string($options) === true) {
+        $options = ['media' => $options];
+    }
+
+    $kirby = App::instance();
+
+    if ($url === '@auto') {
+        if (!$url = Url::toTemplateAsset('css/templates', 'css')) {
+            return null;
+        }
+    }
+
+    $url  = ($kirby->component('css'))($kirby, $url, $options);
+    $url  = Url::to($url);
+    $attr = array_merge((array)$options, [
+        'href' => $url,
+        'rel'  => 'stylesheet'
+    ]);
+
+    return '<link ' . attr($attr) . '>';
+}
+
+/**
+ * Triggers a deprecation warning if debug mode is active
+ * @since 3.3.0
+ *
+ * @param string $message
+ * @return bool Whether the warning was triggered
+ */
+function deprecated(string $message): bool
+{
+    if (App::instance()->option('debug') === true) {
+        return trigger_error($message, E_USER_DEPRECATED) === true;
+    }
+
+    return false;
+}
+
+if (function_exists('dump') === false) {
+    /**
+     * Simple object and variable dumper
+     * to help with debugging.
+     *
+     * @param mixed $variable
+     * @param bool $echo
+     * @return string
+     */
+    function dump($variable, bool $echo = true): string
+    {
+        $kirby = App::instance();
+        return ($kirby->component('dump'))($kirby, $variable, $echo);
+    }
+}
+
+if (function_exists('e') === false) {
+    /**
+     * Smart version of echo with an if condition as first argument
+     *
+     * @param mixed $condition
+     * @param mixed $value The string to be echoed if the condition is true
+     * @param mixed $alternative An alternative string which should be echoed when the condition is false
+     */
+    function e($condition, $value, $alternative = null)
+    {
+        echo r($condition, $value, $alternative);
+    }
+}
+
+/**
+ * Escape context specific output
+ *
+ * @param string $string Untrusted data
+ * @param string $context Location of output (`html`, `attr`, `js`, `css`, `url` or `xml`)
+ * @return string Escaped data
+ */
+function esc($string, $context = 'html')
+{
+    if (method_exists('Kirby\Toolkit\Escape', $context) === true) {
+        return Escape::$context($string);
+    }
+
+    return $string;
+}
+
+
+/**
+ * Shortcut for $kirby->request()->get()
+ *
+ * @param mixed $key The key to look for. Pass false or null to return the entire request array.
+ * @param mixed $default Optional default value, which should be returned if no element has been found
+ * @return mixed
+ */
+function get($key = null, $default = null)
+{
+    return App::instance()->request()->get($key, $default);
+}
+
+/**
+ * Embeds a Github Gist
+ *
+ * @param string $url
+ * @param string $file
+ * @return string
+ */
+function gist(string $url, string $file = null): string
+{
+    return kirbytag([
+        'gist' => $url,
+        'file' => $file,
+    ]);
+}
+
+/**
+ * Redirects to the given Urls
+ * Urls can be relative or absolute.
+ *
+ * @param string $url
+ * @param int $code
+ * @return void
+ */
+function go(string $url = '/', int $code = 302)
+{
+    die(Response::redirect($url, $code));
+}
+
+/**
+ * Shortcut for html()
+ *
+ * @param string|null $string unencoded text
+ * @param bool $keepTags
+ * @return string
+ */
+function h(?string $string, bool $keepTags = false)
+{
+    return Html::encode($string, $keepTags);
+}
+
+/**
+ * Creates safe html by encoding special characters
+ *
+ * @param string|null $string unencoded text
+ * @param bool $keepTags
+ * @return string
+ */
+function html(?string $string, bool $keepTags = false)
+{
+    return Html::encode($string, $keepTags);
+}
+
+/**
+ * Return an image from any page
+ * specified by the path
+ *
+ * Example:
+ * <?= image('some/page/myimage.jpg') ?>
+ *
+ * @param string $path
+ * @return \Kirby\Cms\File|null
+ */
+function image(string $path = null)
+{
+    if ($path === null) {
+        return page()->image();
+    }
+
+    $uri      = dirname($path);
+    $filename = basename($path);
+
+    if ($uri === '.') {
+        $uri = null;
+    }
+
+    switch ($uri) {
+        case '/':
+            $parent = site();
+            break;
+        case null:
+            $parent = page();
+            break;
+        default:
+            $parent = page($uri);
+            break;
+    }
+
+    if ($parent) {
+        return $parent->image($filename);
+    } else {
+        return null;
+    }
+}
+
+/**
+ * Runs a number of validators on a set of data and checks if the data is invalid
+ *
+ * @param array $data
+ * @param array $rules
+ * @param array $messages
+ * @return false|array
+ */
+function invalid(array $data = [], array $rules = [], array $messages = [])
+{
+    $errors = [];
+
+    foreach ($rules as $field => $validations) {
+        $validationIndex = -1;
+
+        // See: http://php.net/manual/en/types.comparisons.php
+        // only false for: null, undefined variable, '', []
+        $value   = $data[$field] ?? null;
+        $filled  = $value !== null && $value !== '' && $value !== [];
+        $message = $messages[$field] ?? $field;
+
+        // True if there is an error message for each validation method.
+        $messageArray = is_array($message);
+
+        foreach ($validations as $method => $options) {
+            // If the index is numeric, there is no option
+            // and `$value` is sent directly as a `$options` parameter
+            if (is_numeric($method) === true) {
+                $method  = $options;
+                $options = [$value];
+            } else {
+                if (is_array($options) === false) {
+                    $options = [$options];
+                }
+
+                array_unshift($options, $value);
+            }
+
+            $validationIndex++;
+
+            if ($method === 'required') {
+                if ($filled) {
+                    // Field is required and filled.
+                    continue;
+                }
+            } elseif ($filled) {
+                if (V::$method(...$options) === true) {
+                    // Field is filled and passes validation method.
+                    continue;
+                }
+            } else {
+                // If a field is not required and not filled, no validation should be done.
+                continue;
+            }
+
+            // If no continue was called we have a failed validation.
+            if ($messageArray) {
+                $errors[$field][] = $message[$validationIndex] ?? $field;
+            } else {
+                $errors[$field] = $message;
+            }
+        }
+    }
+
+    return $errors;
+}
+
+/**
+ * Creates a script tag to load a javascript file
+ *
+ * @param string|array $url
+ * @param string|array $options
+ * @return string|null
+ */
+function js($url, $options = null): ?string
+{
+    if (is_array($url) === true) {
+        $scripts = array_map(function ($url) use ($options) {
+            return js($url, $options);
+        }, $url);
+
+        return implode(PHP_EOL, $scripts);
+    }
+
+    if (is_bool($options) === true) {
+        $options = ['async' => $options];
+    }
+
+    $kirby = App::instance();
+
+    if ($url === '@auto') {
+        if (!$url = Url::toTemplateAsset('js/templates', 'js')) {
+            return null;
+        }
+    }
+
+    $url  = ($kirby->component('js'))($kirby, $url, $options);
+    $url  = Url::to($url);
+    $attr = array_merge((array)$options, ['src' => $url]);
+
+    return '<script ' . attr($attr) . '></script>';
+}
+
+/**
+ * Returns the Kirby object in any situation
+ *
+ * @return \Kirby\Cms\App
+ */
+function kirby()
+{
+    return App::instance();
+}
+
+/**
+ * Makes it possible to use any defined Kirbytag as standalone function
+ *
+ * @param string|array $type
+ * @param string $value
+ * @param array $attr
+ * @param array $data
+ * @return string
+ */
+function kirbytag($type, string $value = null, array $attr = [], array $data = []): string
+{
+    if (is_array($type) === true) {
+        $kirbytag = $type;
+        $type     = key($kirbytag);
+        $value    = current($kirbytag);
+        $attr     = $kirbytag;
+
+        // check data attribute and separate from attr data if exists
+        if (isset($attr['data']) === true) {
+            $data = $attr['data'];
+            unset($attr['data']);
+        }
+    }
+
+    return App::instance()->kirbytag($type, $value, $attr, $data);
+}
+
+/**
+ * Parses KirbyTags in the given string. Shortcut
+ * for `$kirby->kirbytags($text, $data)`
+ *
+ * @param string $text
+ * @param array $data
+ * @return string
+ */
+function kirbytags(string $text = null, array $data = []): string
+{
+    return App::instance()->kirbytags($text, $data);
+}
+
+/**
+ * Parses KirbyTags and Markdown in the
+ * given string. Shortcut for `$kirby->kirbytext()`
+ *
+ * @param string $text
+ * @param array $data
+ * @return string
+ */
+function kirbytext(string $text = null, array $data = []): string
+{
+    return App::instance()->kirbytext($text, $data);
+}
+
+/**
+ * Parses KirbyTags and inline Markdown in the
+ * given string.
+ * @since 3.1.0
+ *
+ * @param string $text
+ * @param array $data
+ * @return string
+ */
+function kirbytextinline(string $text = null, array $data = []): string
+{
+    return App::instance()->kirbytext($text, $data, true);
+}
+
+/**
+ * Shortcut for `kirbytext()` helper
+ *
+ * @param string $text
+ * @param array $data
+ * @return string
+ */
+function kt(string $text = null, array $data = []): string
+{
+    return kirbytext($text, $data);
+}
+
+/**
+ * Shortcut for `kirbytextinline()` helper
+ * @since 3.1.0
+ *
+ * @param string $text
+ * @param array $data
+ * @return string
+ */
+function kti(string $text = null, array $data = []): string
+{
+    return kirbytextinline($text, $data);
+}
+
+/**
+ * A super simple class autoloader
+ *
+ * @param array $classmap
+ * @param string $base
+ * @return void
+ */
+function load(array $classmap, string $base = null)
+{
+    // convert all classnames to lowercase
+    $classmap = array_change_key_case($classmap);
+
+    spl_autoload_register(function ($class) use ($classmap, $base) {
+        $class = strtolower($class);
+
+        if (!isset($classmap[$class])) {
+            return false;
+        }
+
+        if ($base) {
+            include $base . '/' . $classmap[$class];
+        } else {
+            include $classmap[$class];
+        }
+    });
+}
+
+/**
+ * Parses markdown in the given string. Shortcut for
+ * `$kirby->markdown($text)`
+ *
+ * @param string $text
+ * @return string
+ */
+function markdown(string $text = null): string
+{
+    return App::instance()->markdown($text);
+}
+
+/**
+ * Shortcut for `$kirby->option($key, $default)`
+ *
+ * @param string $key
+ * @param mixed $default
+ * @return mixed
+ */
+function option(string $key, $default = null)
+{
+    return App::instance()->option($key, $default);
+}
+
+/**
+ * Fetches a single page or multiple pages by
+ * id or the current page when no id is specified
+ *
+ * @param string|array ...$id
+ * @return \Kirby\Cms\Page|null
+ */
+function page(...$id)
+{
+    if (empty($id) === true) {
+        return App::instance()->site()->page();
+    }
+
+    return App::instance()->site()->find(...$id);
+}
+
+/**
+ * Helper to build page collections
+ *
+ * @param string|array ...$id
+ * @return \Kirby\Cms\Pages
+ */
+function pages(...$id)
+{
+    return App::instance()->site()->find(...$id);
+}
+
+/**
+ * Returns a single param from the URL
+ *
+ * @param string $key
+ * @param string $fallback
+ * @return string|null
+ */
+function param(string $key, string $fallback = null): ?string
+{
+    return App::instance()->request()->url()->params()->$key ?? $fallback;
+}
+
+/**
+ * Returns all params from the current Url
+ *
+ * @return array
+ */
+function params(): array
+{
+    return App::instance()->request()->url()->params()->toArray();
+}
+
+/**
+ * Smart version of return with an if condition as first argument
+ *
+ * @param mixed $condition
+ * @param mixed $value The string to be returned if the condition is true
+ * @param mixed $alternative An alternative string which should be returned when the condition is false
+ * @return mixed
+ */
+function r($condition, $value, $alternative = null)
+{
+    return $condition ? $value : $alternative;
+}
+
+/**
+ * Returns the current site object
+ *
+ * @return \Kirby\Cms\Site
+ */
+function site()
+{
+    return App::instance()->site();
+}
+
+/**
+ * Determines the size/length of numbers, strings, arrays and countable objects
+ *
+ * @param mixed $value
+ * @return int
+ */
+function size($value): int
+{
+    if (is_numeric($value)) {
+        return (int)$value;
+    }
+
+    if (is_string($value)) {
+        return Str::length(trim($value));
+    }
+
+    if (is_array($value)) {
+        return count($value);
+    }
+
+    if (is_object($value)) {
+        if (is_a($value, 'Countable') === true) {
+            return count($value);
+        }
+
+        if (is_a($value, 'Kirby\Toolkit\Collection') === true) {
+            return $value->count();
+        }
+    }
+
+    throw new InvalidArgumentException('Could not determine the size of the given value');
+}
+
+/**
+ * Enhances the given string with
+ * smartypants. Shortcut for `$kirby->smartypants($text)`
+ *
+ * @param string $text
+ * @return string
+ */
+function smartypants(string $text = null): string
+{
+    return App::instance()->smartypants($text);
+}
+
+/**
+ * Embeds a snippet from the snippet folder
+ *
+ * @param string|array $name
+ * @param array|object $data
+ * @param bool $return
+ * @return string
+ */
+function snippet($name, $data = [], bool $return = false)
+{
+    if (is_object($data) === true) {
+        $data = ['item' => $data];
+    }
+
+    $snippet = App::instance()->snippet($name, $data);
+
+    if ($return === true) {
+        return $snippet;
+    }
+
+    echo $snippet;
+}
+
+/**
+ * Includes an SVG file by absolute or
+ * relative file path.
+ *
+ * @param string|\Kirby\Cms\File $file
+ * @return string|false
+ */
+function svg($file)
+{
+    // support for Kirby's file objects
+    if (is_a($file, 'Kirby\Cms\File') === true && $file->extension() === 'svg') {
+        return $file->read();
+    }
+
+    if (is_string($file) === false) {
+        return false;
+    }
+
+    $extension = F::extension($file);
+
+    // check for valid svg files
+    if ($extension !== 'svg') {
+        return false;
+    }
+
+    // try to convert relative paths to absolute
+    if (file_exists($file) === false) {
+        $root = App::instance()->root();
+        $file = realpath($root . '/' . $file);
+    }
+
+    return F::read($file);
+}
+
+/**
+ * Returns translate string for key from translation file
+ *
+ * @param string|array $key
+ * @param string|null $fallback
+ * @return mixed
+ */
+function t($key, string $fallback = null)
+{
+    return I18n::translate($key, $fallback);
+}
+
+/**
+ * Translates a count
+ *
+ * @param string|array $key
+ * @param int $count
+ * @return mixed
+ */
+function tc($key, int $count)
+{
+    return I18n::translateCount($key, $count);
+}
+
+/**
+ * Rounds the minutes of the given date
+ * by the defined step
+ *
+ * @param string $date
+ * @param int $step array of `unit` and `size` to round to nearest
+ * @return int|null
+ */
+function timestamp(string $date = null, $step = null): ?int
+{
+    if (V::date($date) === false) {
+        return null;
+    }
+
+    $date = strtotime($date);
+
+    if ($step === null) {
+        return $date;
+    }
+
+    // fallback for pre-3.5.0 usage
+    if (is_int($step) === true) {
+        $step = [
+            'unit' => 'minute',
+            'size' => $step
+        ];
+    }
+
+    if (is_array($step) === false) {
+        return $date;
+    }
+
+    $parts = [
+        'second' => date('s', $date),
+        'minute' => date('i', $date),
+        'hour'   => date('H', $date),
+        'day'    => date('d', $date),
+        'month'  => date('m', $date),
+        'year'   => date('Y', $date),
+    ];
+
+    $current = $parts[$step['unit']];
+    $nearest = round($current / $step['size']) * $step['size'];
+    $parts[$step['unit']] = $nearest;
+
+    foreach ($parts as $part => $value) {
+        if ($part === $step['unit']) {
+            break;
+        }
+
+        $parts[$part] = 0;
+    }
+
+    $timestamp = strtotime(
+        $parts['year'] . '-' .
+        str_pad($parts['month'], 2, 0, STR_PAD_LEFT) . '-' .
+        str_pad($parts['day'], 2, 0, STR_PAD_LEFT) . ' ' .
+        str_pad($parts['hour'], 2, 0, STR_PAD_LEFT) . ':' .
+        str_pad($parts['minute'], 2, 0, STR_PAD_LEFT) . ':' .
+        str_pad($parts['second'], 2, 0, STR_PAD_LEFT)
+    );
+
+    // on error, convert `false` into `null`
+    return $timestamp ? $timestamp : null;
+}
+
+/**
+ * Translate by key and then replace
+ * placeholders in the text
+ *
+ * @param string $key
+ * @param string $fallback
+ * @param array $replace
+ * @param string $locale
+ * @return string
+ */
+function tt(string $key, $fallback = null, array $replace = null, string $locale = null)
+{
+    return I18n::template($key, $fallback, $replace, $locale);
+}
+
+/**
+ * Builds a Twitter link
+ *
+ * @param string $username
+ * @param string $text
+ * @param string $title
+ * @param string $class
+ * @return string
+ */
+function twitter(string $username, string $text = null, string $title = null, string $class = null): string
+{
+    return kirbytag([
+        'twitter' => $username,
+        'text'    => $text,
+        'title'   => $title,
+        'class'   => $class
+    ]);
+}
+
+/**
+ * Shortcut for url()
+ *
+ * @param string $path
+ * @param array|string|null $options
+ * @return string
+ */
+function u(string $path = null, $options = null): string
+{
+    return Url::to($path, $options);
+}
+
+/**
+ * Builds an absolute URL for a given path
+ *
+ * @param string $path
+ * @param array|string|null $options
+ * @return string
+ */
+function url(string $path = null, $options = null): string
+{
+    return Url::to($path, $options);
+}
+
+/**
+ * Creates a compliant v4 UUID
+ * Taken from: https://github.com/symfony/polyfill
+ *
+ * @return string
+ */
+function uuid(): string
+{
+    $uuid = bin2hex(random_bytes(16));
+
+    return sprintf(
+        '%08s-%04s-4%03s-%04x-%012s',
+        // 32 bits for "time_low"
+        substr($uuid, 0, 8),
+        // 16 bits for "time_mid"
+        substr($uuid, 8, 4),
+        // 16 bits for "time_hi_and_version",
+        // four most significant bits holds version number 4
+        substr($uuid, 13, 3),
+        // 16 bits:
+        // * 8 bits for "clk_seq_hi_res",
+        // * 8 bits for "clk_seq_low",
+        // two most significant bits holds zero and one for variant DCE1.1
+        hexdec(substr($uuid, 16, 4)) & 0x3fff | 0x8000,
+        // 48 bits for "node"
+        substr($uuid, 20, 12)
+    );
+}
+
+
+/**
+ * Creates a video embed via iframe for Youtube or Vimeo
+ * videos. The embed Urls are automatically detected from
+ * the given Url.
+ *
+ * @param string $url
+ * @param array $options
+ * @param array $attr
+ * @return string
+ */
+function video(string $url, array $options = [], array $attr = []): string
+{
+    return Html::video($url, $options, $attr);
+}
+
+/**
+ * Embeds a Vimeo video by URL in an iframe
+ *
+ * @param string $url
+ * @param array $options
+ * @param array $attr
+ * @return string
+ */
+function vimeo(string $url, array $options = [], array $attr = []): string
+{
+    return Html::vimeo($url, $options, $attr);
+}
+
+/**
+ * The widont function makes sure that there are no
+ * typographical widows at the end of a paragraph –
+ * that's a single word in the last line
+ *
+ * @param string|null $string
+ * @return string
+ */
+function widont(string $string = null): string
+{
+    return Str::widont($string);
+}
+
+/**
+ * Embeds a Youtube video by URL in an iframe
+ *
+ * @param string $url
+ * @param array $options
+ * @param array $attr
+ * @return string
+ */
+function youtube(string $url, array $options = [], array $attr = []): string
+{
+    return Html::youtube($url, $options, $attr);
+}

kirby/config/methods.php

@@ -0,0 +1,606 @@
+<?php
+
+use Kirby\Cms\App;
+use Kirby\Cms\Blocks;
+use Kirby\Cms\Field;
+use Kirby\Cms\Files;
+use Kirby\Cms\Html;
+use Kirby\Cms\Layouts;
+use Kirby\Cms\Structure;
+use Kirby\Cms\Url;
+use Kirby\Data\Data;
+use Kirby\Exception\Exception;
+use Kirby\Exception\InvalidArgumentException;
+use Kirby\Toolkit\Str;
+use Kirby\Toolkit\V;
+use Kirby\Toolkit\Xml;
+
+/**
+ * Field method setup
+ */
+return function (App $app) {
+    return [
+
+        // states
+
+        /**
+         * Converts the field value into a proper boolean and inverts it
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return bool
+         */
+        'isFalse' => function (Field $field): bool {
+            return $field->toBool() === false;
+        },
+
+        /**
+         * Converts the field value into a proper boolean
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return bool
+         */
+        'isTrue' => function (Field $field): bool {
+            return $field->toBool() === true;
+        },
+
+        /**
+         * Validates the field content with the given validator and parameters
+         *
+         * @param string $validator
+         * @param mixed ...$arguments A list of optional validator arguments
+         * @return bool
+         */
+        'isValid' => function (Field $field, string $validator, ...$arguments): bool {
+            return V::$validator($field->value, ...$arguments);
+        },
+
+        // converters
+        /**
+         * Converts a yaml or json field to a Blocks object
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Blocks
+         */
+        'toBlocks' => function (Field $field) {
+            try {
+                $blocks = Blocks::factory(Blocks::parse($field->value()), [
+                    'parent' => $field->parent(),
+                ]);
+
+                return $blocks->filter('isHidden', false);
+            } catch (Throwable $e) {
+                if ($field->parent() === null) {
+                    $message = 'Invalid blocks data for "' . $field->key() . '" field';
+                } else {
+                    $message = 'Invalid blocks data for "' . $field->key() . '" field on parent "' . $field->parent()->title() . '"';
+                }
+
+                throw new InvalidArgumentException($message);
+            }
+        },
+
+        /**
+         * Converts the field value into a proper boolean
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param bool $default Default value if the field is empty
+         * @return bool
+         */
+        'toBool' => function (Field $field, $default = false): bool {
+            $value = $field->isEmpty() ? $default : $field->value;
+            return filter_var($value, FILTER_VALIDATE_BOOLEAN);
+        },
+
+        /**
+         * Parses the field value with the given method
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param string $method [',', 'yaml', 'json']
+         * @return array
+         */
+        'toData' => function (Field $field, string $method = ',') {
+            switch ($method) {
+                case 'yaml':
+                case 'json':
+                    return Data::decode($field->value, $method);
+                default:
+                    return $field->split($method);
+            }
+        },
+
+        /**
+         * Converts the field value to a timestamp or a formatted date
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param string|null $format PHP date formatting string
+         * @param string|null $fallback Fallback string for `strtotime` (since 3.2)
+         * @return string|int
+         */
+        'toDate' => function (Field $field, string $format = null, string $fallback = null) use ($app) {
+            if (empty($field->value) === true && $fallback === null) {
+                return null;
+            }
+
+            $time = empty($field->value) === true ? strtotime($fallback) : $field->toTimestamp();
+
+            if ($format === null) {
+                return $time;
+            }
+
+            return ($app->option('date.handler', 'date'))($format, $time);
+        },
+
+        /**
+         * Returns a file object from a filename in the field
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\File|null
+         */
+        'toFile' => function (Field $field) {
+            return $field->toFiles()->first();
+        },
+
+        /**
+         * Returns a file collection from a yaml list of filenames in the field
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param string $separator
+         * @return \Kirby\Cms\Files
+         */
+        'toFiles' => function (Field $field, string $separator = 'yaml') {
+            $parent = $field->parent();
+            $files  = new Files([]);
+
+            foreach ($field->toData($separator) as $id) {
+                if ($file = $parent->kirby()->file($id, $parent)) {
+                    $files->add($file);
+                }
+            }
+
+            return $files;
+        },
+
+        /**
+         * Converts the field value into a proper float
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param float $default Default value if the field is empty
+         * @return float
+         */
+        'toFloat' => function (Field $field, float $default = 0) {
+            $value = $field->isEmpty() ? $default : $field->value;
+            return (float)$value;
+        },
+
+        /**
+         * Converts the field value into a proper integer
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param int $default Default value if the field is empty
+         * @return int
+         */
+        'toInt' => function (Field $field, int $default = 0) {
+            $value = $field->isEmpty() ? $default : $field->value;
+            return (int)$value;
+        },
+
+        /**
+         * Parse layouts and turn them into
+         * Layout objects
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Layouts
+         */
+        'toLayouts' => function (Field $field) {
+            return Layouts::factory(Layouts::parse($field->value()), [
+                'parent' => $field->parent()
+            ]);
+        },
+
+        /**
+         * Wraps a link tag around the field value. The field value is used as the link text
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param mixed $attr1 Can be an optional Url. If no Url is set, the Url of the Page, File or Site will be used. Can also be an array of link attributes
+         * @param mixed $attr2 If `$attr1` is used to set the Url, you can use `$attr2` to pass an array of additional attributes.
+         * @return string
+         */
+        'toLink' => function (Field $field, $attr1 = null, $attr2 = null) {
+            if (is_string($attr1) === true) {
+                $href = $attr1;
+                $attr = $attr2;
+            } else {
+                $href = $field->parent()->url();
+                $attr = $attr1;
+            }
+
+            if ($field->parent()->isActive()) {
+                $attr['aria-current'] = 'page';
+            }
+
+            return Html::a($href, $field->value, $attr ?? []);
+        },
+
+        /**
+         * Returns a page object from a page id in the field
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Page|null
+         */
+        'toPage' => function (Field $field) {
+            return $field->toPages()->first();
+        },
+
+        /**
+         * Returns a pages collection from a yaml list of page ids in the field
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param string $separator Can be any other separator to split the field value by
+         * @return \Kirby\Cms\Pages
+         */
+        'toPages' => function (Field $field, string $separator = 'yaml') use ($app) {
+            return $app->site()->find(false, false, ...$field->toData($separator));
+        },
+
+        /**
+         * Converts a yaml field to a Structure object
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Structure
+         */
+        'toStructure' => function (Field $field) {
+            try {
+                return new Structure(Data::decode($field->value, 'yaml'), $field->parent());
+            } catch (Exception $e) {
+                if ($field->parent() === null) {
+                    $message = 'Invalid structure data for "' . $field->key() . '" field';
+                } else {
+                    $message = 'Invalid structure data for "' . $field->key() . '" field on parent "' . $field->parent()->title() . '"';
+                }
+
+                throw new InvalidArgumentException($message);
+            }
+        },
+
+        /**
+         * Converts the field value to a Unix timestamp
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return int
+         */
+        'toTimestamp' => function (Field $field): int {
+            return strtotime($field->value);
+        },
+
+        /**
+         * Turns the field value into an absolute Url
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return string
+         */
+        'toUrl' => function (Field $field): string {
+            return Url::to($field->value);
+        },
+
+        /**
+         * Converts a user email address to a user object
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\User|null
+         */
+        'toUser' => function (Field $field) {
+            return $field->toUsers()->first();
+        },
+
+        /**
+         * Returns a users collection from a yaml list of user email addresses in the field
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param string $separator
+         * @return \Kirby\Cms\Users
+         */
+        'toUsers' => function (Field $field, string $separator = 'yaml') use ($app) {
+            return $app->users()->find(false, false, ...$field->toData($separator));
+        },
+
+        // inspectors
+
+        /**
+         * Returns the length of the field content
+         */
+        'length' => function (Field $field) {
+            return Str::length($field->value);
+        },
+
+        /**
+         * Returns the number of words in the text
+         */
+        'words' => function (Field $field) {
+            return str_word_count(strip_tags($field->value));
+        },
+
+        // manipulators
+
+        /**
+         * Applies the callback function to the field
+         * @since 3.4.0
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param Closure $callback
+         */
+        'callback' => function (Field $field, Closure $callback) {
+            return $callback($field);
+        },
+
+        /**
+         * Escapes the field value to be safely used in HTML
+         * templates without the risk of XSS attacks
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param string $context Location of output (`html`, `attr`, `js`, `css`, `url` or `xml`)
+         */
+        'escape' => function (Field $field, string $context = 'html') {
+            $field->value = esc($field->value, $context);
+            return $field;
+        },
+
+        /**
+         * Creates an excerpt of the field value without html
+         * or any other formatting.
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param int $cahrs
+         * @param bool $strip
+         * @param string $rep
+         * @return \Kirby\Cms\Field
+         */
+        'excerpt' => function (Field $field, int $chars = 0, bool $strip = true, string $rep = ' …') {
+            $field->value = Str::excerpt($field->kirbytext()->value(), $chars, $strip, $rep);
+            return $field;
+        },
+
+        /**
+         * Converts the field content to valid HTML
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'html' => function (Field $field) {
+            $field->value = htmlentities($field->value, ENT_COMPAT, 'utf-8');
+            return $field;
+        },
+
+        /**
+         * Strips all block-level HTML elements from the field value,
+         * it can be safely placed inside of other inline elements
+         * without the risk of breaking the HTML structure.
+         * @since 3.3.0
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'inline' => function (Field $field) {
+            // List of valid inline elements taken from: https://developer.mozilla.org/de/docs/Web/HTML/Inline_elemente
+            // Obsolete elements, script tags, image maps and form elements have
+            // been excluded for safety reasons and as they are most likely not
+            // needed in most cases.
+            $field->value = strip_tags($field->value, '<b><i><small><abbr><cite><code><dfn><em><kbd><strong><samp><var><a><bdo><br><img><q><span><sub><sup>');
+            return $field;
+        },
+
+        /**
+         * Converts the field content from Markdown/Kirbytext to valid HTML
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'kirbytext' => function (Field $field) use ($app) {
+            $field->value = $app->kirbytext($field->value, [
+                'parent' => $field->parent(),
+                'field'  => $field
+            ]);
+
+            return $field;
+        },
+
+        /**
+         * Converts the field content from inline Markdown/Kirbytext
+         * to valid HTML
+         * @since 3.1.0
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'kirbytextinline' => function (Field $field) use ($app) {
+            $field->value = $app->kirbytext($field->value, [
+                'parent' => $field->parent(),
+                'field'  => $field
+            ], true);
+
+            return $field;
+        },
+
+        /**
+         * Parses all KirbyTags without also parsing Markdown
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'kirbytags' => function (Field $field) use ($app) {
+            $field->value = $app->kirbytags($field->value, [
+                'parent' => $field->parent(),
+                'field'  => $field
+            ]);
+
+            return $field;
+        },
+
+        /**
+         * Converts the field content to lowercase
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'lower' => function (Field $field) {
+            $field->value = Str::lower($field->value);
+            return $field;
+        },
+
+        /**
+         * Converts markdown to valid HTML
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'markdown' => function (Field $field) use ($app) {
+            $field->value = $app->markdown($field->value);
+            return $field;
+        },
+
+        /**
+         * Converts all line breaks in the field content to `<br>` tags.
+         * @since 3.3.0
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'nl2br' => function (Field $field) {
+            $field->value = nl2br($field->value, false);
+            return $field;
+        },
+
+        /**
+         * Uses the field value as Kirby query
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param string|null $expect
+         * @return mixed
+         */
+        'query' => function (Field $field, string $expect = null) use ($app) {
+            if ($parent = $field->parent()) {
+                return $parent->query($field->value, $expect);
+            }
+
+            return Str::query($field->value, [
+                'kirby' => $app,
+                'site'  => $app->site(),
+                'page'  => $app->page()
+            ]);
+        },
+
+        /**
+         * It parses any queries found in the field value.
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param array $data
+         * @param string $fallback Fallback for tokens in the template that cannot be replaced
+         * @return \Kirby\Cms\Field
+         */
+        'replace' => function (Field $field, array $data = [], string $fallback = '') use ($app) {
+            if ($parent = $field->parent()) {
+                $field->value = $field->parent()->toString($field->value, $data, $fallback);
+            } else {
+                $field->value = Str::template($field->value, array_replace([
+                    'kirby' => $app,
+                    'site'  => $app->site(),
+                    'page'  => $app->page()
+                ], $data), $fallback);
+            }
+
+            return $field;
+        },
+
+        /**
+         * Cuts the string after the given length and
+         * adds "…" if it is longer
+         *
+         * @param \Kirby\Cms\Field $field
+         * @param int $length The number of characters in the string
+         * @param string $appendix An optional replacement for the missing rest
+         * @return \Kirby\Cms\Field
+         */
+        'short' => function (Field $field, int $length, string $appendix = '…') {
+            $field->value = Str::short($field->value, $length, $appendix);
+            return $field;
+        },
+
+        /**
+         * Converts the field content to a slug
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'slug' => function (Field $field) {
+            $field->value = Str::slug($field->value);
+            return $field;
+        },
+
+        /**
+         * Applies SmartyPants to the field
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'smartypants' => function (Field $field) use ($app) {
+            $field->value = $app->smartypants($field->value);
+            return $field;
+        },
+
+        /**
+         * Splits the field content into an array
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return array
+         */
+        'split' => function (Field $field, $separator = ',') {
+            return Str::split((string)$field->value, $separator);
+        },
+
+        /**
+         * Converts the field content to uppercase
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'upper' => function (Field $field) {
+            $field->value = Str::upper($field->value);
+            return $field;
+        },
+
+        /**
+         * Avoids typographical widows in strings by replacing
+         * the last space with `&nbsp;`
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'widont' => function (Field $field) {
+            $field->value = Str::widont($field->value);
+            return $field;
+        },
+
+        /**
+         * Converts the field content to valid XML
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return \Kirby\Cms\Field
+         */
+        'xml' => function (Field $field) {
+            $field->value = Xml::encode($field->value);
+            return $field;
+        },
+
+        // aliases
+
+        /**
+         * Parses yaml in the field content and returns an array
+         *
+         * @param \Kirby\Cms\Field $field
+         * @return array
+         */
+        'yaml' => function (Field $field): array {
+            return $field->toData('yaml');
+        },
+
+    ];
+};

kirby/config/presets/files.php

@@ -0,0 +1,24 @@
+<?php
+
+return function (array $props) {
+    $props['sections'] = [
+        'files' => [
+            'headline' => $props['headline'] ?? t('files'),
+            'type'     => 'files',
+            'layout'   => $props['layout'] ?? 'cards',
+            'template' => $props['template'] ?? null,
+            'image'    => $props['image'] ?? null,
+            'info'     => '{{ file.dimensions }}'
+        ]
+    ];
+
+    // remove global options
+    unset(
+        $props['headline'],
+        $props['layout'],
+        $props['template'],
+        $props['image']
+    );
+
+    return $props;
+};

kirby/config/presets/page.php

@@ -0,0 +1,72 @@
+<?php
+
+return function ($props) {
+    $section = function ($defaults, $props) {
+        if ($props === true) {
+            $props = [];
+        }
+
+        if (is_string($props) === true) {
+            $props = [
+                'headline' => $props
+            ];
+        }
+
+        return array_replace_recursive($defaults, $props);
+    };
+
+    if (empty($props['sidebar']) === false) {
+        $sidebar = $props['sidebar'];
+    } else {
+        $sidebar = [];
+
+        $pages = $props['pages'] ?? [];
+        $files = $props['files'] ?? [];
+
+        if ($pages !== false) {
+            $sidebar['pages'] = $section([
+                'headline' => t('pages'),
+                'type'     => 'pages',
+                'status'   => 'all',
+                'layout'   => 'list',
+            ], $pages);
+        }
+
+        if ($files !== false) {
+            $sidebar['files'] = $section([
+                'headline' => t('files'),
+                'type'     => 'files',
+                'layout'   => 'list'
+            ], $files);
+        }
+    }
+
+    if (empty($sidebar) === true) {
+        $props['fields'] = $props['fields'] ?? [];
+
+        unset(
+            $props['files'],
+            $props['pages']
+        );
+    } else {
+        $props['columns'] = [
+            [
+                'width'  => '2/3',
+                'fields' => $props['fields'] ?? []
+            ],
+            [
+                'width' => '1/3',
+                'sections' => $sidebar
+            ],
+        ];
+
+        unset(
+            $props['fields'],
+            $props['files'],
+            $props['pages'],
+            $props['sidebar']
+        );
+    }
+
+    return $props;
+};

kirby/config/presets/pages.php

@@ -0,0 +1,57 @@
+<?php
+
+return function (array $props) {
+
+    // load the general templates setting for all sections
+    $templates = $props['templates'] ?? null;
+
+    $section = function ($headline, $status, $props) use ($templates) {
+        $defaults = [
+            'headline' => $headline,
+            'type'     => 'pages',
+            'layout'   => 'list',
+            'status'   => $status
+        ];
+
+        if ($props === true) {
+            $props = [];
+        }
+
+        if (is_string($props) === true) {
+            $props = [
+                'headline' => $props
+            ];
+        }
+
+        // inject the global templates definition
+        if (empty($templates) === false) {
+            $props['templates'] = $props['templates'] ?? $templates;
+        }
+
+        return array_replace_recursive($defaults, $props);
+    };
+
+    $sections = [];
+
+    $drafts   = $props['drafts']   ?? [];
+    $unlisted = $props['unlisted'] ?? false;
+    $listed   = $props['listed']   ?? [];
+
+
+    if ($drafts !== false) {
+        $sections['drafts'] = $section(t('pages.status.draft'), 'drafts', $drafts);
+    }
+
+    if ($unlisted !== false) {
+        $sections['unlisted'] = $section(t('pages.status.unlisted'), 'unlisted', $unlisted);
+    }
+
+    if ($listed !== false) {
+        $sections['listed'] = $section(t('pages.status.listed'), 'listed', $listed);
+    }
+
+    // cleaning up
+    unset($props['drafts'], $props['unlisted'], $props['listed'], $props['templates']);
+
+    return array_merge($props, ['sections' => $sections]);
+};

kirby/config/roots.php

@@ -0,0 +1,93 @@
+<?php
+
+return [
+    // kirby
+    'kirby' => function (array $roots) {
+        return realpath(__DIR__ . '/../');
+    },
+
+    // i18n
+    'i18n' => function (array $roots) {
+        return $roots['kirby'] . '/i18n';
+    },
+    'i18n:translations' => function (array $roots) {
+        return $roots['i18n'] . '/translations';
+    },
+    'i18n:rules' => function (array $roots) {
+        return $roots['i18n'] . '/rules';
+    },
+
+    // index
+    'index' => function (array $roots) {
+        return realpath(__DIR__ . '/../../');
+    },
+
+    // assets
+    'assets' => function (array $roots) {
+        return $roots['index'] . '/assets';
+    },
+
+    // content
+    'content' => function (array $roots) {
+        return $roots['index'] . '/content';
+    },
+
+    // media
+    'media' => function (array $roots) {
+        return $roots['index'] . '/media';
+    },
+
+    // panel
+    'panel' => function (array $roots) {
+        return $roots['kirby'] . '/panel';
+    },
+
+    // site
+    'site' => function (array $roots) {
+        return $roots['index'] . '/site';
+    },
+    'accounts' => function (array $roots) {
+        return $roots['site'] . '/accounts';
+    },
+    'blueprints' => function (array $roots) {
+        return $roots['site'] . '/blueprints';
+    },
+    'cache' => function (array $roots) {
+        return $roots['site'] . '/cache';
+    },
+    'collections' => function (array $roots) {
+        return $roots['site'] . '/collections';
+    },
+    'config' => function (array $roots) {
+        return $roots['site'] . '/config';
+    },
+    'controllers' => function (array $roots) {
+        return $roots['site'] . '/controllers';
+    },
+    'languages' => function (array $roots) {
+        return $roots['site'] . '/languages';
+    },
+    'logs' => function (array $roots) {
+        return $roots['site'] . '/logs';
+    },
+    'models' => function (array $roots) {
+        return $roots['site'] . '/models';
+    },
+    'plugins' => function (array $roots) {
+        return $roots['site'] . '/plugins';
+    },
+    'sessions' => function (array $roots) {
+        return $roots['site'] . '/sessions';
+    },
+    'snippets' => function (array $roots) {
+        return $roots['site'] . '/snippets';
+    },
+    'templates' => function (array $roots) {
+        return $roots['site'] . '/templates';
+    },
+
+    // blueprints
+    'roles' => function (array $roots) {
+        return $roots['blueprints'] . '/users';
+    },
+];