Reintroduce Webklex IMAP for ticket processing as PHP-IMAP is no longer being developed. This is optional for now and considered beta can be found in cron/ticket_email_parser.php

plugins/vendor/doctrine/inflector/src/Rules/English/Inflectible.php

@@ -0,0 +1,185 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\English;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return Transformation[] */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('(s)tatuses$'), '\1\2tatus');
+        yield new Transformation(new Pattern('(s)tatus$'), '\1\2tatus');
+        yield new Transformation(new Pattern('(c)ampus$'), '\1\2ampus');
+        yield new Transformation(new Pattern('^(.*)(menu)s$'), '\1\2');
+        yield new Transformation(new Pattern('(quiz)zes$'), '\\1');
+        yield new Transformation(new Pattern('(matr)ices$'), '\1ix');
+        yield new Transformation(new Pattern('(vert|ind)ices$'), '\1ex');
+        yield new Transformation(new Pattern('^(ox)en'), '\1');
+        yield new Transformation(new Pattern('(alias)(es)*$'), '\1');
+        yield new Transformation(new Pattern('(buffal|her|potat|tomat|volcan)oes$'), '\1o');
+        yield new Transformation(new Pattern('(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|viri?)i$'), '\1us');
+        yield new Transformation(new Pattern('([ftw]ax)es'), '\1');
+        yield new Transformation(new Pattern('(analys|ax|cris|test|thes)es$'), '\1is');
+        yield new Transformation(new Pattern('(shoe|slave)s$'), '\1');
+        yield new Transformation(new Pattern('(o)es$'), '\1');
+        yield new Transformation(new Pattern('ouses$'), 'ouse');
+        yield new Transformation(new Pattern('([^a])uses$'), '\1us');
+        yield new Transformation(new Pattern('([m|l])ice$'), '\1ouse');
+        yield new Transformation(new Pattern('(x|ch|ss|sh)es$'), '\1');
+        yield new Transformation(new Pattern('(m)ovies$'), '\1\2ovie');
+        yield new Transformation(new Pattern('(s)eries$'), '\1\2eries');
+        yield new Transformation(new Pattern('([^aeiouy]|qu)ies$'), '\1y');
+        yield new Transformation(new Pattern('([lr])ves$'), '\1f');
+        yield new Transformation(new Pattern('(tive)s$'), '\1');
+        yield new Transformation(new Pattern('(hive)s$'), '\1');
+        yield new Transformation(new Pattern('(drive)s$'), '\1');
+        yield new Transformation(new Pattern('(dive)s$'), '\1');
+        yield new Transformation(new Pattern('(olive)s$'), '\1');
+        yield new Transformation(new Pattern('([^fo])ves$'), '\1fe');
+        yield new Transformation(new Pattern('(^analy)ses$'), '\1sis');
+        yield new Transformation(new Pattern('(analy|diagno|^ba|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$'), '\1\2sis');
+        yield new Transformation(new Pattern('(tax)a$'), '\1on');
+        yield new Transformation(new Pattern('(c)riteria$'), '\1riterion');
+        yield new Transformation(new Pattern('([ti])a(?<!regatta)$'), '\1um');
+        yield new Transformation(new Pattern('(p)eople$'), '\1\2erson');
+        yield new Transformation(new Pattern('(m)en$'), '\1an');
+        yield new Transformation(new Pattern('(c)hildren$'), '\1\2hild');
+        yield new Transformation(new Pattern('(f)eet$'), '\1oot');
+        yield new Transformation(new Pattern('(n)ews$'), '\1\2ews');
+        yield new Transformation(new Pattern('eaus$'), 'eau');
+        yield new Transformation(new Pattern('^tights$'), 'tights');
+        yield new Transformation(new Pattern('^shorts$'), 'shorts');
+        yield new Transformation(new Pattern('s$'), '');
+    }
+
+    /** @return Transformation[] */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('(s)tatus$'), '\1\2tatuses');
+        yield new Transformation(new Pattern('(quiz)$'), '\1zes');
+        yield new Transformation(new Pattern('^(ox)$'), '\1\2en');
+        yield new Transformation(new Pattern('([m|l])ouse$'), '\1ice');
+        yield new Transformation(new Pattern('(matr|vert|ind)(ix|ex)$'), '\1ices');
+        yield new Transformation(new Pattern('(x|ch|ss|sh)$'), '\1es');
+        yield new Transformation(new Pattern('([^aeiouy]|qu)y$'), '\1ies');
+        yield new Transformation(new Pattern('(hive|gulf)$'), '\1s');
+        yield new Transformation(new Pattern('(?:([^f])fe|([lr])f)$'), '\1\2ves');
+        yield new Transformation(new Pattern('sis$'), 'ses');
+        yield new Transformation(new Pattern('([ti])um$'), '\1a');
+        yield new Transformation(new Pattern('(tax)on$'), '\1a');
+        yield new Transformation(new Pattern('(c)riterion$'), '\1riteria');
+        yield new Transformation(new Pattern('(p)erson$'), '\1eople');
+        yield new Transformation(new Pattern('(m)an$'), '\1en');
+        yield new Transformation(new Pattern('(c)hild$'), '\1hildren');
+        yield new Transformation(new Pattern('(f)oot$'), '\1eet');
+        yield new Transformation(new Pattern('(buffal|her|potat|tomat|volcan)o$'), '\1\2oes');
+        yield new Transformation(new Pattern('(alumn|bacill|cact|foc|fung|nucle|radi|stimul|syllab|termin|vir)us$'), '\1i');
+        yield new Transformation(new Pattern('us$'), 'uses');
+        yield new Transformation(new Pattern('(alias)$'), '\1es');
+        yield new Transformation(new Pattern('(analys|ax|cris|test|thes)is$'), '\1es');
+        yield new Transformation(new Pattern('s$'), 's');
+        yield new Transformation(new Pattern('^$'), '');
+        yield new Transformation(new Pattern('$'), 's');
+    }
+
+    /** @return Substitution[] */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('abuse'), new Word('abuses'));
+        yield new Substitution(new Word('alga'), new Word('algae'));
+        yield new Substitution(new Word('atlas'), new Word('atlases'));
+        yield new Substitution(new Word('avalanche'), new Word('avalanches'));
+        yield new Substitution(new Word('axis'), new Word('axes'));
+        yield new Substitution(new Word('axe'), new Word('axes'));
+        yield new Substitution(new Word('beef'), new Word('beefs'));
+        yield new Substitution(new Word('blouse'), new Word('blouses'));
+        yield new Substitution(new Word('brother'), new Word('brothers'));
+        yield new Substitution(new Word('brownie'), new Word('brownies'));
+        yield new Substitution(new Word('cache'), new Word('caches'));
+        yield new Substitution(new Word('cafe'), new Word('cafes'));
+        yield new Substitution(new Word('canvas'), new Word('canvases'));
+        yield new Substitution(new Word('cave'), new Word('caves'));
+        yield new Substitution(new Word('chateau'), new Word('chateaux'));
+        yield new Substitution(new Word('child'), new Word('children'));
+        yield new Substitution(new Word('cookie'), new Word('cookies'));
+        yield new Substitution(new Word('corpus'), new Word('corpuses'));
+        yield new Substitution(new Word('cow'), new Word('cows'));
+        yield new Substitution(new Word('criterion'), new Word('criteria'));
+        yield new Substitution(new Word('curriculum'), new Word('curricula'));
+        yield new Substitution(new Word('curve'), new Word('curves'));
+        yield new Substitution(new Word('demo'), new Word('demos'));
+        yield new Substitution(new Word('die'), new Word('dice'));
+        yield new Substitution(new Word('domino'), new Word('dominoes'));
+        yield new Substitution(new Word('echo'), new Word('echoes'));
+        yield new Substitution(new Word('emphasis'), new Word('emphases'));
+        yield new Substitution(new Word('epoch'), new Word('epochs'));
+        yield new Substitution(new Word('foe'), new Word('foes'));
+        yield new Substitution(new Word('foot'), new Word('feet'));
+        yield new Substitution(new Word('fungus'), new Word('fungi'));
+        yield new Substitution(new Word('ganglion'), new Word('ganglions'));
+        yield new Substitution(new Word('gas'), new Word('gases'));
+        yield new Substitution(new Word('genie'), new Word('genies'));
+        yield new Substitution(new Word('genus'), new Word('genera'));
+        yield new Substitution(new Word('goose'), new Word('geese'));
+        yield new Substitution(new Word('graffito'), new Word('graffiti'));
+        yield new Substitution(new Word('grave'), new Word('graves'));
+        yield new Substitution(new Word('hippopotamus'), new Word('hippopotami'));
+        yield new Substitution(new Word('hoax'), new Word('hoaxes'));
+        yield new Substitution(new Word('hoof'), new Word('hoofs'));
+        yield new Substitution(new Word('human'), new Word('humans'));
+        yield new Substitution(new Word('iris'), new Word('irises'));
+        yield new Substitution(new Word('larva'), new Word('larvae'));
+        yield new Substitution(new Word('leaf'), new Word('leaves'));
+        yield new Substitution(new Word('lens'), new Word('lenses'));
+        yield new Substitution(new Word('loaf'), new Word('loaves'));
+        yield new Substitution(new Word('man'), new Word('men'));
+        yield new Substitution(new Word('medium'), new Word('media'));
+        yield new Substitution(new Word('memorandum'), new Word('memoranda'));
+        yield new Substitution(new Word('money'), new Word('monies'));
+        yield new Substitution(new Word('mongoose'), new Word('mongooses'));
+        yield new Substitution(new Word('motto'), new Word('mottoes'));
+        yield new Substitution(new Word('move'), new Word('moves'));
+        yield new Substitution(new Word('mythos'), new Word('mythoi'));
+        yield new Substitution(new Word('neurosis'), new Word('neuroses'));
+        yield new Substitution(new Word('niche'), new Word('niches'));
+        yield new Substitution(new Word('niveau'), new Word('niveaux'));
+        yield new Substitution(new Word('nucleus'), new Word('nuclei'));
+        yield new Substitution(new Word('numen'), new Word('numina'));
+        yield new Substitution(new Word('nursery'), new Word('nurseries'));
+        yield new Substitution(new Word('oasis'), new Word('oases'));
+        yield new Substitution(new Word('occiput'), new Word('occiputs'));
+        yield new Substitution(new Word('octopus'), new Word('octopuses'));
+        yield new Substitution(new Word('opus'), new Word('opuses'));
+        yield new Substitution(new Word('ox'), new Word('oxen'));
+        yield new Substitution(new Word('passerby'), new Word('passersby'));
+        yield new Substitution(new Word('penis'), new Word('penises'));
+        yield new Substitution(new Word('person'), new Word('people'));
+        yield new Substitution(new Word('plateau'), new Word('plateaux'));
+        yield new Substitution(new Word('runner-up'), new Word('runners-up'));
+        yield new Substitution(new Word('safe'), new Word('safes'));
+        yield new Substitution(new Word('save'), new Word('saves'));
+        yield new Substitution(new Word('sex'), new Word('sexes'));
+        yield new Substitution(new Word('sieve'), new Word('sieves'));
+        yield new Substitution(new Word('soliloquy'), new Word('soliloquies'));
+        yield new Substitution(new Word('son-in-law'), new Word('sons-in-law'));
+        yield new Substitution(new Word('stadium'), new Word('stadiums'));
+        yield new Substitution(new Word('syllabus'), new Word('syllabi'));
+        yield new Substitution(new Word('testis'), new Word('testes'));
+        yield new Substitution(new Word('thief'), new Word('thieves'));
+        yield new Substitution(new Word('tooth'), new Word('teeth'));
+        yield new Substitution(new Word('tornado'), new Word('tornadoes'));
+        yield new Substitution(new Word('trilby'), new Word('trilbys'));
+        yield new Substitution(new Word('turf'), new Word('turfs'));
+        yield new Substitution(new Word('valve'), new Word('valves'));
+        yield new Substitution(new Word('volcano'), new Word('volcanoes'));
+        yield new Substitution(new Word('wave'), new Word('waves'));
+        yield new Substitution(new Word('zombie'), new Word('zombies'));
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/English/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\English;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/English/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\English;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/English/Uninflected.php

@@ -0,0 +1,189 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\English;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return Pattern[] */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+
+        yield new Pattern('.*ss');
+        yield new Pattern('clothes');
+        yield new Pattern('data');
+        yield new Pattern('fascia');
+        yield new Pattern('fuchsia');
+        yield new Pattern('galleria');
+        yield new Pattern('mafia');
+        yield new Pattern('militia');
+        yield new Pattern('pants');
+        yield new Pattern('petunia');
+        yield new Pattern('sepia');
+        yield new Pattern('trivia');
+        yield new Pattern('utopia');
+    }
+
+    /** @return Pattern[] */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+
+        yield new Pattern('people');
+        yield new Pattern('trivia');
+        yield new Pattern('\w+ware$');
+        yield new Pattern('media');
+    }
+
+    /** @return Pattern[] */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('\w+media');
+        yield new Pattern('advice');
+        yield new Pattern('aircraft');
+        yield new Pattern('amoyese');
+        yield new Pattern('art');
+        yield new Pattern('audio');
+        yield new Pattern('baggage');
+        yield new Pattern('bison');
+        yield new Pattern('borghese');
+        yield new Pattern('bream');
+        yield new Pattern('breeches');
+        yield new Pattern('britches');
+        yield new Pattern('buffalo');
+        yield new Pattern('butter');
+        yield new Pattern('cantus');
+        yield new Pattern('carp');
+        yield new Pattern('cattle');
+        yield new Pattern('chassis');
+        yield new Pattern('clippers');
+        yield new Pattern('clothing');
+        yield new Pattern('coal');
+        yield new Pattern('cod');
+        yield new Pattern('coitus');
+        yield new Pattern('compensation');
+        yield new Pattern('congoese');
+        yield new Pattern('contretemps');
+        yield new Pattern('coreopsis');
+        yield new Pattern('corps');
+        yield new Pattern('cotton');
+        yield new Pattern('data');
+        yield new Pattern('debris');
+        yield new Pattern('deer');
+        yield new Pattern('diabetes');
+        yield new Pattern('djinn');
+        yield new Pattern('education');
+        yield new Pattern('eland');
+        yield new Pattern('elk');
+        yield new Pattern('emoji');
+        yield new Pattern('equipment');
+        yield new Pattern('evidence');
+        yield new Pattern('faroese');
+        yield new Pattern('feedback');
+        yield new Pattern('fish');
+        yield new Pattern('flounder');
+        yield new Pattern('flour');
+        yield new Pattern('foochowese');
+        yield new Pattern('food');
+        yield new Pattern('furniture');
+        yield new Pattern('gallows');
+        yield new Pattern('genevese');
+        yield new Pattern('genoese');
+        yield new Pattern('gilbertese');
+        yield new Pattern('gold');
+        yield new Pattern('headquarters');
+        yield new Pattern('herpes');
+        yield new Pattern('hijinks');
+        yield new Pattern('homework');
+        yield new Pattern('hottentotese');
+        yield new Pattern('impatience');
+        yield new Pattern('information');
+        yield new Pattern('innings');
+        yield new Pattern('jackanapes');
+        yield new Pattern('jeans');
+        yield new Pattern('jedi');
+        yield new Pattern('kin');
+        yield new Pattern('kiplingese');
+        yield new Pattern('knowledge');
+        yield new Pattern('kongoese');
+        yield new Pattern('leather');
+        yield new Pattern('love');
+        yield new Pattern('lucchese');
+        yield new Pattern('luggage');
+        yield new Pattern('mackerel');
+        yield new Pattern('Maltese');
+        yield new Pattern('management');
+        yield new Pattern('metadata');
+        yield new Pattern('mews');
+        yield new Pattern('money');
+        yield new Pattern('moose');
+        yield new Pattern('mumps');
+        yield new Pattern('music');
+        yield new Pattern('nankingese');
+        yield new Pattern('news');
+        yield new Pattern('nexus');
+        yield new Pattern('niasese');
+        yield new Pattern('nutrition');
+        yield new Pattern('offspring');
+        yield new Pattern('oil');
+        yield new Pattern('patience');
+        yield new Pattern('pekingese');
+        yield new Pattern('piedmontese');
+        yield new Pattern('pincers');
+        yield new Pattern('pistoiese');
+        yield new Pattern('plankton');
+        yield new Pattern('pliers');
+        yield new Pattern('pokemon');
+        yield new Pattern('police');
+        yield new Pattern('polish');
+        yield new Pattern('portuguese');
+        yield new Pattern('proceedings');
+        yield new Pattern('progress');
+        yield new Pattern('rabies');
+        yield new Pattern('rain');
+        yield new Pattern('research');
+        yield new Pattern('rhinoceros');
+        yield new Pattern('rice');
+        yield new Pattern('salmon');
+        yield new Pattern('sand');
+        yield new Pattern('sarawakese');
+        yield new Pattern('scissors');
+        yield new Pattern('sea[- ]bass');
+        yield new Pattern('series');
+        yield new Pattern('shavese');
+        yield new Pattern('shears');
+        yield new Pattern('sheep');
+        yield new Pattern('siemens');
+        yield new Pattern('silk');
+        yield new Pattern('sms');
+        yield new Pattern('soap');
+        yield new Pattern('social media');
+        yield new Pattern('spam');
+        yield new Pattern('species');
+        yield new Pattern('staff');
+        yield new Pattern('sugar');
+        yield new Pattern('swine');
+        yield new Pattern('talent');
+        yield new Pattern('toothpaste');
+        yield new Pattern('traffic');
+        yield new Pattern('travel');
+        yield new Pattern('trousers');
+        yield new Pattern('trout');
+        yield new Pattern('tuna');
+        yield new Pattern('us');
+        yield new Pattern('vermontese');
+        yield new Pattern('vinegar');
+        yield new Pattern('weather');
+        yield new Pattern('wenchowese');
+        yield new Pattern('wheat');
+        yield new Pattern('whiting');
+        yield new Pattern('wildebeest');
+        yield new Pattern('wood');
+        yield new Pattern('wool');
+        yield new Pattern('yengeese');
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Esperanto/Inflectible.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Esperanto;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return Transformation[] */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('oj$'), 'o');
+    }
+
+    /** @return Transformation[] */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('o$'), 'oj');
+    }
+
+    /** @return Substitution[] */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word(''), new Word(''));
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Esperanto/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Esperanto;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Esperanto/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Esperanto;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Esperanto/Uninflected.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Esperanto;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return Pattern[] */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('');
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/French/Inflectible.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return Transformation[] */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/(b|cor|ém|gemm|soupir|trav|vant|vitr)aux$/'), '\1ail');
+        yield new Transformation(new Pattern('/ails$/'), 'ail');
+        yield new Transformation(new Pattern('/(journ|chev|loc)aux$/'), '\1al');
+        yield new Transformation(new Pattern('/(bijou|caillou|chou|genou|hibou|joujou|pou|au|eu|eau)x$/'), '\1');
+        yield new Transformation(new Pattern('/s$/'), '');
+    }
+
+    /** @return Transformation[] */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/(s|x|z)$/'), '\1');
+        yield new Transformation(new Pattern('/(b|cor|ém|gemm|soupir|trav|vant|vitr)ail$/'), '\1aux');
+        yield new Transformation(new Pattern('/ail$/'), 'ails');
+        yield new Transformation(new Pattern('/(chacal|carnaval|festival|récital)$/'), '\1s');
+        yield new Transformation(new Pattern('/al$/'), 'aux');
+        yield new Transformation(new Pattern('/(bleu|émeu|landau|pneu|sarrau)$/'), '\1s');
+        yield new Transformation(new Pattern('/(bijou|caillou|chou|genou|hibou|joujou|lieu|pou|au|eu|eau)$/'), '\1x');
+        yield new Transformation(new Pattern('/$/'), 's');
+    }
+
+    /** @return Substitution[] */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('monsieur'), new Word('messieurs'));
+        yield new Substitution(new Word('madame'), new Word('mesdames'));
+        yield new Substitution(new Word('mademoiselle'), new Word('mesdemoiselles'));
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/French/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/French/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/French/Uninflected.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\French;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return Pattern[] */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+
+        yield new Pattern('bois');
+        yield new Pattern('mas');
+    }
+
+    /** @return Pattern[] */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('');
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Italian/Inflectible.php

@@ -0,0 +1,218 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Italian;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return iterable<Transformation> */
+    public static function getSingular(): iterable
+    {
+        // Reverse of -sce → -scia (fasce → fascia)
+        yield new Transformation(new Pattern('([aeiou])sce$'), '\\1scia');
+
+        // Reverse of -cie → -cia (farmacia → farmacie)
+        yield new Transformation(new Pattern('cie$'), 'cia');
+
+        // Reverse of -gie → -gia (bugia → bugie)
+        yield new Transformation(new Pattern('gie$'), 'gia');
+
+        // Reverse of -ce → -cia (arance → arancia)
+        yield new Transformation(new Pattern('([^aeiou])ce$'), '\1cia');
+
+        // Reverse of -ge → -gia (valige → valigia)
+        yield new Transformation(new Pattern('([^aeiou])ge$'), '\1gia');
+
+        // Reverse of -chi → -co (bachi → baco)
+        yield new Transformation(new Pattern('([bcdfghjklmnpqrstvwxyz][aeiou])chi$'), '\1co');
+
+        // Reverse of -ghi → -go (laghi → lago)
+        yield new Transformation(new Pattern('([bcdfghjklmnpqrstvwxyz][aeiou])ghi$'), '\1go');
+
+        // Reverse of -ci → -co (medici → medico)
+        yield new Transformation(new Pattern('([aeiou][bcdfghjklmnpqrstvwxyz])ci$'), '\1co');
+
+        // Reverse of -gi → -go (psicologi → psicologo)
+        yield new Transformation(new Pattern('([aeiou][bcdfghjklmnpqrstvwxyz])gi$'), '\1go');
+
+        // Reverse of -i → -io (zii → zio, negozi → negozio)
+        // This is more complex due to Italian's stress patterns, but we'll handle the basic case
+        yield new Transformation(new Pattern('([^aeiou])i$'), '\1io');
+
+        // Handle words that end with -i but should go to -co/-go (amici → amico, not amice)
+        yield new Transformation(new Pattern('([^aeiou])ci$'), '\1co');
+        yield new Transformation(new Pattern('([^aeiou])gi$'), '\1go');
+
+        // Reverse of -a → -e
+        yield new Transformation(new Pattern('e$'), 'a');
+
+        // Reverse of -e → -i
+        yield new Transformation(new Pattern('i$'), 'e');
+
+        // Reverse of -o → -i
+        yield new Transformation(new Pattern('i$'), 'o');
+    }
+
+    /** @return iterable<Transformation> */
+    public static function getPlural(): iterable
+    {
+        // Words ending in -scia without stress on 'i' become -sce (e.g. fascia → fasce)
+        yield new Transformation(new Pattern('([aeiou])scia$'), '\\1sce');
+
+        // Words ending in -cia/gia with stress on 'i' keep the 'i' in plural
+        yield new Transformation(new Pattern('cia$'), 'cie'); // e.g. farmacia → farmacie
+        yield new Transformation(new Pattern('gia$'), 'gie'); // e.g. bugia → bugie
+
+        // Words ending in -cia/gia without stress on 'i' lose the 'i' in plural
+        yield new Transformation(new Pattern('([^aeiou])cia$'), '\\1ce'); // e.g. arancia → arance
+        yield new Transformation(new Pattern('([^aeiou])gia$'), '\\1ge'); // e.g. valigia → valige
+
+        // Words ending in -co/-go with stress on 'o' become -chi/-ghi
+        yield new Transformation(new Pattern('([bcdfghjklmnpqrstvwxyz][aeiou])co$'), '\\1chi'); // e.g. baco → bachi
+        yield new Transformation(new Pattern('([bcdfghjklmnpqrstvwxyz][aeiou])go$'), '\\1ghi'); // e.g. lago → laghi
+
+        // Words ending in -co/-go with stress on the penultimate syllable become -ci/-gi
+        yield new Transformation(new Pattern('([aeiou][bcdfghjklmnpqrstvwxyz])co$'), '\\1ci'); // e.g. medico → medici
+        yield new Transformation(new Pattern('([aeiou][bcdfghjklmnpqrstvwxyz])go$'), '\\1gi'); // e.g. psicologo → psicologi
+
+        // Words ending in -io with stress on 'i' keep the 'i' in plural
+        yield new Transformation(new Pattern('([^aeiou])io$'), '\\1i'); // e.g. zio → zii
+
+        // Words ending in -io with stress on 'o' lose the 'i' in plural
+        yield new Transformation(new Pattern('([aeiou])io$'), '\\1i'); // e.g. negozio → negozi
+
+        // Standard ending rules
+        yield new Transformation(new Pattern('a$'), 'e');  // -a → -e
+        yield new Transformation(new Pattern('e$'), 'i');  // -e → -i
+        yield new Transformation(new Pattern('o$'), 'i');  // -o → -i
+    }
+
+    /** @return iterable<Substitution> */
+    public static function getIrregular(): iterable
+    {
+        // Irregular substitutions (singular => plural)
+        $irregulars = [
+            'ala' => 'ali',
+            'albergo' => 'alberghi',
+            'amica' => 'amiche',
+            'amico' => 'amici',
+            'ampio' => 'ampi',
+            'arancia' => 'arance',
+            'arma' => 'armi',
+            'asparago' => 'asparagi',
+            'banca' => 'banche',
+            'belga' => 'belgi',
+            'braccio' => 'braccia',
+            'budello' => 'budella',
+            'bue' => 'buoi',
+            'caccia' => 'cacce',
+            'calcagno' => 'calcagna',
+            'camicia' => 'camicie',
+            'cane' => 'cani',
+            'capitale' => 'capitali',
+            'carcere' => 'carceri',
+            'casa' => 'case',
+            'cavaliere' => 'cavalieri',
+            'centinaio' => 'centinaia',
+            'cerchio' => 'cerchia',
+            'cervello' => 'cervella',
+            'chiave' => 'chiavi',
+            'chirurgo' => 'chirurgi',
+            'ciglio' => 'ciglia',
+            'città' => 'città',
+            'corno' => 'corna',
+            'corpo' => 'corpi',
+            'crisi' => 'crisi',
+            'dente' => 'denti',
+            'dio' => 'dei',
+            'dito' => 'dita',
+            'dottore' => 'dottori',
+            'fiore' => 'fiori',
+            'fratello' => 'fratelli',
+            'fuoco' => 'fuochi',
+            'gamba' => 'gambe',
+            'ginocchio' => 'ginocchia',
+            'gioco' => 'giochi',
+            'giornale' => 'giornali',
+            'giraffa' => 'giraffe',
+            'labbro' => 'labbra',
+            'lenzuolo' => 'lenzuola',
+            'libro' => 'libri',
+            'madre' => 'madri',
+            'maestro' => 'maestri',
+            'magico' => 'magici',
+            'mago' => 'maghi',
+            'maniaco' => 'maniaci',
+            'manico' => 'manici',
+            'mano' => 'mani',
+            'medico' => 'medici',
+            'membro' => 'membri',
+            'metropoli' => 'metropoli',
+            'migliaio' => 'migliaia',
+            'miglio' => 'miglia',
+            'mille' => 'mila',
+            'mio' => 'miei',
+            'moglie' => 'mogli',
+            'mosaico' => 'mosaici',
+            'muro' => 'muri',
+            'nemico' => 'nemici',
+            'nome' => 'nomi',
+            'occhio' => 'occhi',
+            'orecchio' => 'orecchi',
+            'osso' => 'ossa',
+            'paio' => 'paia',
+            'pane' => 'pani',
+            'papa' => 'papi',
+            'pasta' => 'paste',
+            'penna' => 'penne',
+            'pesce' => 'pesci',
+            'piede' => 'piedi',
+            'pittore' => 'pittori',
+            'poeta' => 'poeti',
+            'porco' => 'porci',
+            'porto' => 'porti',
+            'problema' => 'problemi',
+            'ragazzo' => 'ragazzi',
+            're' => 're',
+            'rene' => 'reni',
+            'riso' => 'risa',
+            'rosa' => 'rosa',
+            'sale' => 'sali',
+            'sarto' => 'sarti',
+            'scuola' => 'scuole',
+            'serie' => 'serie',
+            'serramento' => 'serramenta',
+            'sorella' => 'sorelle',
+            'specie' => 'specie',
+            'staio' => 'staia',
+            'stazione' => 'stazioni',
+            'strido' => 'strida',
+            'strillo' => 'strilla',
+            'studio' => 'studi',
+            'suo' => 'suoi',
+            'superficie' => 'superfici',
+            'tavolo' => 'tavoli',
+            'tempio' => 'templi',
+            'treno' => 'treni',
+            'tuo' => 'tuoi',
+            'uomo' => 'uomini',
+            'uovo' => 'uova',
+            'urlo' => 'urla',
+            'valigia' => 'valigie',
+            'vestigio' => 'vestigia',
+            'vino' => 'vini',
+            'viola' => 'viola',
+            'zio' => 'zii',
+        ];
+
+        foreach ($irregulars as $singular => $plural) {
+            yield new Substitution(new Word($singular), new Word($plural));
+        }
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Italian/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Italian;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Italian/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Italian;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Italian/Uninflected.php

@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Italian;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return iterable<Pattern> */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return iterable<Pattern> */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return iterable<Pattern> */
+    private static function getDefault(): iterable
+    {
+        // Invariable words (same form in singular and plural)
+        $invariables = [
+            'alpaca',
+            'auto',
+            'bar',
+            'blu',
+            'boia',
+            'boomerang',
+            'brindisi',
+            'campus',
+            'computer',
+            'crisi',
+            'crocevia',
+            'dopocena',
+            'film',
+            'foto',
+            'fuchsia',
+            'gnu',
+            'gorilla',
+            'gru',
+            'iguana',
+            'kamikaze',
+            'karaoke',
+            'koala',
+            'lama',
+            'menu',
+            'metropoli',
+            'moto',
+            'opossum',
+            'panda',
+            'quiz',
+            'radio',
+            're',
+            'scacciapensieri',
+            'serie',
+            'smartphone',
+            'sosia',
+            'sottoscala',
+            'specie',
+            'sport',
+            'tablet',
+            'taxi',
+            'vaglia',
+            'virtù',
+            'virus',
+            'yogurt',
+            'foto',
+            'fuchsia',
+        ];
+
+        foreach ($invariables as $word) {
+            yield new Pattern($word);
+        }
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/NorwegianBokmal/Inflectible.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return Transformation[] */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/re$/i'), 'r');
+        yield new Transformation(new Pattern('/er$/i'), '');
+    }
+
+    /** @return Transformation[] */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/e$/i'), 'er');
+        yield new Transformation(new Pattern('/r$/i'), 're');
+        yield new Transformation(new Pattern('/$/'), 'er');
+    }
+
+    /** @return Substitution[] */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('konto'), new Word('konti'));
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/NorwegianBokmal/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/NorwegianBokmal/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/NorwegianBokmal/Uninflected.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\NorwegianBokmal;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return Pattern[] */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('barn');
+        yield new Pattern('fjell');
+        yield new Pattern('hus');
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Pattern.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use function preg_match;
+
+final class Pattern
+{
+    /** @var string */
+    private $pattern;
+
+    /** @var string */
+    private $regex;
+
+    public function __construct(string $pattern)
+    {
+        $this->pattern = $pattern;
+
+        if (isset($this->pattern[0]) && $this->pattern[0] === '/') {
+            $this->regex = $this->pattern;
+        } else {
+            $this->regex = '/' . $this->pattern . '/i';
+        }
+    }
+
+    public function getPattern(): string
+    {
+        return $this->pattern;
+    }
+
+    public function getRegex(): string
+    {
+        return $this->regex;
+    }
+
+    public function matches(string $word): bool
+    {
+        return preg_match($this->getRegex(), $word) === 1;
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Patterns.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use function array_map;
+use function implode;
+use function preg_match;
+
+class Patterns
+{
+    /** @var string */
+    private $regex;
+
+    public function __construct(Pattern ...$patterns)
+    {
+        $patterns = array_map(static function (Pattern $pattern): string {
+            return $pattern->getPattern();
+        }, $patterns);
+
+        $this->regex = '/^(?:' . implode('|', $patterns) . ')$/i';
+    }
+
+    public function matches(string $word): bool
+    {
+        return preg_match($this->regex, $word, $regs) === 1;
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Portuguese/Inflectible.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return Transformation[] */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/^(g|)ases$/i'), '\1ás');
+        yield new Transformation(new Pattern('/(japon|escoc|ingl|dinamarqu|fregu|portugu)eses$/i'), '\1ês');
+        yield new Transformation(new Pattern('/(ae|ao|oe)s$/'), 'ao');
+        yield new Transformation(new Pattern('/(ãe|ão|õe)s$/'), 'ão');
+        yield new Transformation(new Pattern('/^(.*[^s]s)es$/i'), '\1');
+        yield new Transformation(new Pattern('/sses$/i'), 'sse');
+        yield new Transformation(new Pattern('/ns$/i'), 'm');
+        yield new Transformation(new Pattern('/(r|t|f|v)is$/i'), '\1il');
+        yield new Transformation(new Pattern('/uis$/i'), 'ul');
+        yield new Transformation(new Pattern('/ois$/i'), 'ol');
+        yield new Transformation(new Pattern('/eis$/i'), 'ei');
+        yield new Transformation(new Pattern('/éis$/i'), 'el');
+        yield new Transformation(new Pattern('/([^p])ais$/i'), '\1al');
+        yield new Transformation(new Pattern('/(r|z)es$/i'), '\1');
+        yield new Transformation(new Pattern('/^(á|gá)s$/i'), '\1s');
+        yield new Transformation(new Pattern('/([^ê])s$/i'), '\1');
+    }
+
+    /** @return Transformation[] */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/^(alem|c|p)ao$/i'), '\1aes');
+        yield new Transformation(new Pattern('/^(irm|m)ao$/i'), '\1aos');
+        yield new Transformation(new Pattern('/ao$/i'), 'oes');
+        yield new Transformation(new Pattern('/^(alem|c|p)ão$/i'), '\1ães');
+        yield new Transformation(new Pattern('/^(irm|m)ão$/i'), '\1ãos');
+        yield new Transformation(new Pattern('/ão$/i'), 'ões');
+        yield new Transformation(new Pattern('/^(|g)ás$/i'), '\1ases');
+        yield new Transformation(new Pattern('/^(japon|escoc|ingl|dinamarqu|fregu|portugu)ês$/i'), '\1eses');
+        yield new Transformation(new Pattern('/m$/i'), 'ns');
+        yield new Transformation(new Pattern('/([^aeou])il$/i'), '\1is');
+        yield new Transformation(new Pattern('/ul$/i'), 'uis');
+        yield new Transformation(new Pattern('/ol$/i'), 'ois');
+        yield new Transformation(new Pattern('/el$/i'), 'eis');
+        yield new Transformation(new Pattern('/al$/i'), 'ais');
+        yield new Transformation(new Pattern('/(z|r)$/i'), '\1es');
+        yield new Transformation(new Pattern('/(s)$/i'), '\1');
+        yield new Transformation(new Pattern('/$/'), 's');
+    }
+
+    /** @return Substitution[] */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('abdomen'), new Word('abdomens'));
+        yield new Substitution(new Word('alemão'), new Word('alemães'));
+        yield new Substitution(new Word('artesã'), new Word('artesãos'));
+        yield new Substitution(new Word('álcool'), new Word('álcoois'));
+        yield new Substitution(new Word('árvore'), new Word('árvores'));
+        yield new Substitution(new Word('bencão'), new Word('bencãos'));
+        yield new Substitution(new Word('cão'), new Word('cães'));
+        yield new Substitution(new Word('campus'), new Word('campi'));
+        yield new Substitution(new Word('cadáver'), new Word('cadáveres'));
+        yield new Substitution(new Word('capelão'), new Word('capelães'));
+        yield new Substitution(new Word('capitão'), new Word('capitães'));
+        yield new Substitution(new Word('chão'), new Word('chãos'));
+        yield new Substitution(new Word('charlatão'), new Word('charlatães'));
+        yield new Substitution(new Word('cidadão'), new Word('cidadãos'));
+        yield new Substitution(new Word('consul'), new Word('consules'));
+        yield new Substitution(new Word('cristão'), new Word('cristãos'));
+        yield new Substitution(new Word('difícil'), new Word('difíceis'));
+        yield new Substitution(new Word('email'), new Word('emails'));
+        yield new Substitution(new Word('escrivão'), new Word('escrivães'));
+        yield new Substitution(new Word('fóssil'), new Word('fósseis'));
+        yield new Substitution(new Word('gás'), new Word('gases'));
+        yield new Substitution(new Word('germens'), new Word('germen'));
+        yield new Substitution(new Word('grão'), new Word('grãos'));
+        yield new Substitution(new Word('hífen'), new Word('hífens'));
+        yield new Substitution(new Word('irmão'), new Word('irmãos'));
+        yield new Substitution(new Word('liquens'), new Word('liquen'));
+        yield new Substitution(new Word('mal'), new Word('males'));
+        yield new Substitution(new Word('mão'), new Word('mãos'));
+        yield new Substitution(new Word('orfão'), new Word('orfãos'));
+        yield new Substitution(new Word('país'), new Word('países'));
+        yield new Substitution(new Word('pai'), new Word('pais'));
+        yield new Substitution(new Word('pão'), new Word('pães'));
+        yield new Substitution(new Word('projétil'), new Word('projéteis'));
+        yield new Substitution(new Word('réptil'), new Word('répteis'));
+        yield new Substitution(new Word('sacristão'), new Word('sacristães'));
+        yield new Substitution(new Word('sotão'), new Word('sotãos'));
+        yield new Substitution(new Word('tabelião'), new Word('tabeliães'));
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Portuguese/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Portuguese/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Portuguese/Uninflected.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Portuguese;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return Pattern[] */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('tórax');
+        yield new Pattern('tênis');
+        yield new Pattern('ônibus');
+        yield new Pattern('lápis');
+        yield new Pattern('fênix');
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Ruleset.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+class Ruleset
+{
+    /** @var Transformations */
+    private $regular;
+
+    /** @var Patterns */
+    private $uninflected;
+
+    /** @var Substitutions */
+    private $irregular;
+
+    public function __construct(Transformations $regular, Patterns $uninflected, Substitutions $irregular)
+    {
+        $this->regular     = $regular;
+        $this->uninflected = $uninflected;
+        $this->irregular   = $irregular;
+    }
+
+    public function getRegular(): Transformations
+    {
+        return $this->regular;
+    }
+
+    public function getUninflected(): Patterns
+    {
+        return $this->uninflected;
+    }
+
+    public function getIrregular(): Substitutions
+    {
+        return $this->irregular;
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Spanish/Inflectible.php

@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return Transformation[] */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/ereses$/'), 'erés');
+        yield new Transformation(new Pattern('/iones$/'), 'ión');
+        yield new Transformation(new Pattern('/ces$/'), 'z');
+        yield new Transformation(new Pattern('/es$/'), '');
+        yield new Transformation(new Pattern('/s$/'), '');
+    }
+
+    /** @return Transformation[] */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/ú([sn])$/i'), 'u\1es');
+        yield new Transformation(new Pattern('/ó([sn])$/i'), 'o\1es');
+        yield new Transformation(new Pattern('/í([sn])$/i'), 'i\1es');
+        yield new Transformation(new Pattern('/é([sn])$/i'), 'e\1es');
+        yield new Transformation(new Pattern('/á([sn])$/i'), 'a\1es');
+        yield new Transformation(new Pattern('/z$/i'), 'ces');
+        yield new Transformation(new Pattern('/([aeiou]s)$/i'), '\1');
+        yield new Transformation(new Pattern('/([^aeéiou])$/i'), '\1es');
+        yield new Transformation(new Pattern('/$/'), 's');
+    }
+
+    /** @return Substitution[] */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('el'), new Word('los'));
+        yield new Substitution(new Word('papá'), new Word('papás'));
+        yield new Substitution(new Word('mamá'), new Word('mamás'));
+        yield new Substitution(new Word('sofá'), new Word('sofás'));
+        yield new Substitution(new Word('mes'), new Word('meses'));
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Spanish/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Spanish/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Spanish/Uninflected.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Spanish;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return Pattern[] */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('lunes');
+        yield new Pattern('rompecabezas');
+        yield new Pattern('crisis');
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Substitution.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+final class Substitution
+{
+    /** @var Word */
+    private $from;
+
+    /** @var Word */
+    private $to;
+
+    public function __construct(Word $from, Word $to)
+    {
+        $this->from = $from;
+        $this->to   = $to;
+    }
+
+    public function getFrom(): Word
+    {
+        return $this->from;
+    }
+
+    public function getTo(): Word
+    {
+        return $this->to;
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Substitutions.php

@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use Doctrine\Inflector\WordInflector;
+
+use function strtolower;
+use function strtoupper;
+use function substr;
+
+class Substitutions implements WordInflector
+{
+    /** @var Substitution[] */
+    private $substitutions;
+
+    public function __construct(Substitution ...$substitutions)
+    {
+        foreach ($substitutions as $substitution) {
+            $this->substitutions[$substitution->getFrom()->getWord()] = $substitution;
+        }
+    }
+
+    public function getFlippedSubstitutions(): Substitutions
+    {
+        $substitutions = [];
+
+        foreach ($this->substitutions as $substitution) {
+            $substitutions[] = new Substitution(
+                $substitution->getTo(),
+                $substitution->getFrom()
+            );
+        }
+
+        return new Substitutions(...$substitutions);
+    }
+
+    public function inflect(string $word): string
+    {
+        $lowerWord = strtolower($word);
+
+        if (isset($this->substitutions[$lowerWord])) {
+            $firstLetterUppercase = $lowerWord[0] !== $word[0];
+
+            $toWord = $this->substitutions[$lowerWord]->getTo()->getWord();
+
+            if ($firstLetterUppercase) {
+                return strtoupper($toWord[0]) . substr($toWord, 1);
+            }
+
+            return $toWord;
+        }
+
+        return $word;
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Transformation.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use Doctrine\Inflector\WordInflector;
+
+use function preg_replace;
+
+final class Transformation implements WordInflector
+{
+    /** @var Pattern */
+    private $pattern;
+
+    /** @var string */
+    private $replacement;
+
+    public function __construct(Pattern $pattern, string $replacement)
+    {
+        $this->pattern     = $pattern;
+        $this->replacement = $replacement;
+    }
+
+    public function getPattern(): Pattern
+    {
+        return $this->pattern;
+    }
+
+    public function getReplacement(): string
+    {
+        return $this->replacement;
+    }
+
+    public function inflect(string $word): string
+    {
+        return (string) preg_replace($this->pattern->getRegex(), $this->replacement, $word);
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Transformations.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+use Doctrine\Inflector\WordInflector;
+
+class Transformations implements WordInflector
+{
+    /** @var Transformation[] */
+    private $transformations;
+
+    public function __construct(Transformation ...$transformations)
+    {
+        $this->transformations = $transformations;
+    }
+
+    public function inflect(string $word): string
+    {
+        foreach ($this->transformations as $transformation) {
+            if ($transformation->getPattern()->matches($word)) {
+                return $transformation->inflect($word);
+            }
+        }
+
+        return $word;
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Turkish/Inflectible.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\Rules\Pattern;
+use Doctrine\Inflector\Rules\Substitution;
+use Doctrine\Inflector\Rules\Transformation;
+use Doctrine\Inflector\Rules\Word;
+
+class Inflectible
+{
+    /** @return Transformation[] */
+    public static function getSingular(): iterable
+    {
+        yield new Transformation(new Pattern('/l[ae]r$/i'), '');
+    }
+
+    /** @return Transformation[] */
+    public static function getPlural(): iterable
+    {
+        yield new Transformation(new Pattern('/([eöiü][^aoıueöiü]{0,6})$/u'), '\1ler');
+        yield new Transformation(new Pattern('/([aoıu][^aoıueöiü]{0,6})$/u'), '\1lar');
+    }
+
+    /** @return Substitution[] */
+    public static function getIrregular(): iterable
+    {
+        yield new Substitution(new Word('ben'), new Word('biz'));
+        yield new Substitution(new Word('sen'), new Word('siz'));
+        yield new Substitution(new Word('o'), new Word('onlar'));
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Turkish/InflectorFactory.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\GenericLanguageInflectorFactory;
+use Doctrine\Inflector\Rules\Ruleset;
+
+final class InflectorFactory extends GenericLanguageInflectorFactory
+{
+    protected function getSingularRuleset(): Ruleset
+    {
+        return Rules::getSingularRuleset();
+    }
+
+    protected function getPluralRuleset(): Ruleset
+    {
+        return Rules::getPluralRuleset();
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Turkish/Rules.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\Rules\Patterns;
+use Doctrine\Inflector\Rules\Ruleset;
+use Doctrine\Inflector\Rules\Substitutions;
+use Doctrine\Inflector\Rules\Transformations;
+
+final class Rules
+{
+    public static function getSingularRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getSingular()),
+            new Patterns(...Uninflected::getSingular()),
+            (new Substitutions(...Inflectible::getIrregular()))->getFlippedSubstitutions()
+        );
+    }
+
+    public static function getPluralRuleset(): Ruleset
+    {
+        return new Ruleset(
+            new Transformations(...Inflectible::getPlural()),
+            new Patterns(...Uninflected::getPlural()),
+            new Substitutions(...Inflectible::getIrregular())
+        );
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Turkish/Uninflected.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules\Turkish;
+
+use Doctrine\Inflector\Rules\Pattern;
+
+final class Uninflected
+{
+    /** @return Pattern[] */
+    public static function getSingular(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    public static function getPlural(): iterable
+    {
+        yield from self::getDefault();
+    }
+
+    /** @return Pattern[] */
+    private static function getDefault(): iterable
+    {
+        yield new Pattern('lunes');
+        yield new Pattern('rompecabezas');
+        yield new Pattern('crisis');
+    }
+}

plugins/vendor/doctrine/inflector/src/Rules/Word.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Inflector\Rules;
+
+class Word
+{
+    /** @var string */
+    private $word;
+
+    public function __construct(string $word)
+    {
+        $this->word = $word;
+    }
+
+    public function getWord(): string
+    {
+        return $this->word;
+    }
+}