HTMLArea needs a global JavaScript variable to work correctly.
Before the change done for #77600, this variable was always initialized
by including a JS file when any backend editing form was rendered.

In this mentioned cleanup, this initialization code was moved to
the place where the RTE is actually rendered. But because this can
also happen in an Ajax request, where the needed JS calls are returned
as array and evaluated line by line with `eval`, the code to initialize
the global variable did not work, because it was prefixed with `var`

This lead to a JS error at a later point where the global var is accessed.

To fix this, we force to set/ initialize the global variable, by prefixing
it with the "super global" object `window`. Now the global `HTMLArea` variable
is also initialized when this code is executed in a `eval` context,
when loading RTE fields of IRRE records via Ajax.

If there is no content on a page the parameter $this->eRParts[1] will be
set to e.g. /new/1 which is not an integer value and it will throw an
exception here on certain dbms, thus let's check that before as there could
not be a history on a new record and skip the query to prevent the error.

The incorrect isRequiredClass check causes the btn class to be
removed from the RTE toolbarbuttons. This happens because it's
considered unneeded in DOM.removeClass(), which is called by
DOM.addClass() (to remove incompatible classes).

The check in isRequiredClass was probably copied from
some classesRequired lookups, but forgot to inverse the
class that's searched for.

This also fixes the RTE to properly remove the selectable=0 class
(e.g. btn), when a class that requires the aformentioned is removed
(e.g. btn-primary).

The patch changes the ajax result that delivers TCA tree
items to the SVG tree from a nested list of items to a
sorted flat list having a 'depth' argument to indicate the
nesting level.
This "flat" list is the native mode of the d3 tree, with
this change the JS side can be streamlined quite a bit.
Along the way, the item providing on PHP side is streamlined,
documented much better and easier to understand now within the
data provider of FormEngine.
The main tree data backend is still a huge, convoluted, slow
and insane mess that will eventually fully substituted with a
much straighter and quicker approach later. Changes in this area
are kept to a minimum for now.

The CLI command to detect RTE magic images (images added
within the RTE) and (as far as possible) remove unused RTE images
as well as copy RTE images referenced multiple times, is migrated to
Symfony Console to better structure the CLI command and get rid
of dependencies of the old CLI command line tools (non-extbase).

The command was previously available under
./typo3/cli_dispatch lowlevel_cleaner rte_images

and is now called via
./typo3/sysext/core/bin/typo3 cleanup:rteimages

and allows the following options:
--dry-run - do not update the images and delete lost files, but just print them
--update-refindex - update the reference index, do not ask the user

This patch makes the TYPO3 DB cache backend capable of
flushing tags using an array of tag names that is then turned
into a CSV list and used in an `IN` query. It limits the number
of cache flushes from $numRecords to ceil($numRecords/100).

NB: the desired behavior is introduced by reviving the
flushByTags() method as API for cache frontends and backends.
The method was previously present but was dropped in order to
keep sync with Flow - which then later added the method exactly
because of performance concerns.

TYPO3 however did not revive this method and obviously the sync
with Flow is no longer a concern. So this patch restores the
full API required to flush tags in bulk, adds an implementation
for the TYPO3 DB cache backend and adds delegation to the old
flushByTag method for backends not covered by this patch.

It will be possible to improve other backends as well but this
patch focuses exclusively on the DB cache backend for *NIX,
which is where the bad performance was observed in the wild.

What needs to be done
* Make editor configurable (height/width, etc)
* Evaluate UI information based on TSconfig
* Integrate plugin configuration in JS
* Check out best defaults for new editor
* Add labels by TYPO3, not from CKeditor
* Integrate "Toolbar Configuration" into "Tools=>Configuration"

The TSconfig option to override the page creation wizard via
`mod.web_list.newPageWiz.overrideWithExtension` is impossible
to use anymore since TYPO3 v8, due to the limitation
of the entry-scripts which are only allowed to be in typo3/index.php
for the backend. The option `mod.newPageWizard.override` was
introduced to register a custom route / module to be linked when
adding new pages.

Allow the the method CategoryRegistry->getCategoryFieldItems()
to be used as itemsProcFunc for select fields in the TCA in
arbitary contexts by introducing a new categoryFieldsTable
configuration in the config section of a column in the TCA.

This configuration key can either consist of a single string containing
the name of the table or a configuration array to define additional
conditions that need to be true so that a configured table is used.

The condition matching is based on the displayCond functionality of
the TCA. To make use of the existing functionality the code for
matching the display conditions is extracted from the form data
provider to a new DisplayConditionEvaluator utility class.

In case a content element and the accordant page have been deleted in
separate actions and get published together, the workspace process will
trigger an error message since the removed content element cannot be
published anymore (since it has been processed already with the page).

To avoid this behavior deleted records are collected and checked in the
workspace swapping/publishing process.

You can skip the dependency check if you want to enforce the installation
of an extension. This patch ensures that dependencies which are available
in the system but marked as not compatible are installed anyways.

According to task #78437 queries should follow the prepared statement
principle.
Thus method BackendUtiltiy::getRecordsByField() has to be refactored
to retrieve a queryBuilder which holds the parameter assigned to e.g.
additional where clause, etc. otherwise the parameter and the dynamically
generated placeholders in the queryQuilder will be reset.

This changes the internal date processing for FormEngine and DataHandler
to use ISO-8601 dates including a proper timezone. Dates are converted
to ISO-8601 as early as possible and converted back to UNIX timestamps
as late as possible.

As before, the database values are always values in the server’s
timezone, interpreted as UTC. Also, the client side inputs are
interpreted as UTC.

The main advantage is that once and for all we get rid of the timezone
issues that may potentially arise if the server and client use different
timezones. Additionally, the values are human readable (which is of
course not so much of an issue for hidden fields) and we can directly
use Moment.js for all heavy lifting.

Another big advantage is that we can make the date formats configurable
and decouple displayed dates and internally stored dates (by putting the
Moment objects to the input fields).

This patch fixes a problem where setting showAccessRestrictedPages
setting in HMENU etc. did not result in the correct behavior according
to documentation at https://docs.typo3.org/typo3cms/TyposcriptReference/MenuObjects/CommonProperties/Index.html.

The patch changes the behavior caused by using `NONE` as
keyword in the setting.

Before: using the option renders `<a>Page title</a>` when page is inaccessible.

After: using the option renders `<a href="index.php?id=123">Page title</a>`
when page is not accessible.

IRRE records have to point to their specific localized parent record.
This works in general for tables containing records of the default
language as well as localizations. For the "pages" table this look-up
has to be extended to query from "pages_language_overlay".

This patch reduces the number of SQL queries and PHP calls
which get performed when rendering menus. The patch has
two parts:

* Runtime cache is used to remember a generated link and
is given a cache identifier which includes a hash of all
parameters which may affect the link.
* Runtime cache is used to remember the decision if a page
is a submenu.

The item rendering function is called every time the same page
is rendered in any menu in the same request, and the decision
function to check if page is a sub-menu is called at least three
times with the same UID when generating a menu. Both of these
implements together reduce the necessary re-calling of methods
which generate the same output given the same arguments.

If a checkbox or a multiple selectbox is rendered, a hidden field is
automatically inserted before to send an empty default value. Field
information are stored within an own viewHelperVariableContainer
variable. After a form is rendered, this information has to be reset to
be able to render another form with same field names. This patch adds
the missing reset of the hidden field information.

Allows manually defining all options and optgroups for
the f:form.select parent field as tag contents of the
select field. The added ViewHelpers are TagBasedViewHelpers
which means they support all standard HTML attributes.

Note that while tag content rendering is now supported,
it is *STILL* not possible to create ``<option>`` tags
manually - you *HAVE* to use the form fields!

The suggest wizard does not work in FormEngine flex form
section containers for existing containers.

The patch splits the ajax controller action and the FormEngine
wizard display into two classes to have a dedicated entry point
for the ajax action and refactors the flex form field configuration
search logic to find the correct configuration for existing
containers, too.

TypoScriptFrontendController::reqCHash() is now called for Extbase
frontend plugin actions just like they were usually called for the
legacy AbstractPlugin.

This throws a 404, if plugin arguments are present, but cHash is not,
which would also happen, if the plugin arguments were added
to "cHashRequiredParameters" configuration.

This provides a more reliable page caching behavior
by default and with zero configuration for extension authors.

With the feature switch "requireCHashArgumentForActionArguments" this
behavior can be disabled, which could be useful, if all actions in a plugin
are uncached or one wants to manually control the cHash behavior.

The new flex form data structure handling in more picky and throws
exception if a given data structure identifier can not be resolved.
The FormEngine logic that displays exclude fields of flex forms
has to do some guess work to find possible data structures. This
may fail, resulting in an exception.
The patch changes the according general exception to a specific one,
catches it in the find flex form access rights logic, and adds
more docu on what exactly is happening in this code.

The method `BackendUtility::explodeSoftRefParserList()` checks whether
`$parserList` is an empty string. This check may fail, as the variable may
be null instead. `$parserList` is now casted to a string, which converts
null to an empty string.

Solves an issue in Chrome where calculating the height of
the editor window returns zero. Solved by hardcoding a
minimum context menu height of 150 pixels; applied via
Math.max()'ing the resolved height and 150.

The method GeneralUtility::callUserFunction() method allows
to call "&" to put this logic into a "persistent" pool. We already
have the SingletonInterface which should be used for objects
that should be persistent.

Currently there are two "persistent object pools", one for
makeInstance and one for callUserFunc, which makes it very hard
to understand which object is used when. Reducing complexity
and using the SingletonInterface everywhere should be the best practice.

This menu processor utilizes HMENU to generate a json encoded menu
string that will be decoded again and assigned to FLUIDTEMPLATE as
variable. Additional DataProcessing is supported and will be applied
to each record.