Overloaded: It might be IBAN or not and depending on that return a different part of the description.

@inheritdoc
435243
protected function parseTransactionAccount()
    {
        $parts = $this->getDescriptionParts();
        $account = $parts[0];
        if (preg_match('#[A-Z]{2}[\d]{2}[A-Z]{4}(.*)#', $parts[2], $results)) {
            $account = $parts[2];
        } elseif (preg_match('#10(\d+)#', $parts[0], $results)) {
            $account = $results[1];
        }

        return $this->sanitizeAccount($account);
    }
283616
public function filter($value)
    {
        $type    = $this->getType();
        $casting = $this->getCasting();

        // LOCALIZED
        if ($type >= self::TYPE_LOCALIZED) {
            $type -= self::TYPE_LOCALIZED;
            if (is_string($value)) {
                if (isset($this->options['translations'][$value])) {
                    return (bool) $this->options['translations'][$value];
                }
            }
        }

        // FALSE_STRING ('false')
        if ($type >= self::TYPE_FALSE_STRING) {
            $type -= self::TYPE_FALSE_STRING;
            if (is_string($value) && (strtolower($value) == 'false')) {
                return false;
            }

            if (!$casting && is_string($value) && (strtolower($value) == 'true')) {
                return true;
            }
        }

        // NULL (null)
        if ($type >= self::TYPE_NULL) {
            $type -= self::TYPE_NULL;
            if ($value === null) {
                return false;
            }
        }

        // EMPTY_ARRAY (array())
        if ($type >= self::TYPE_EMPTY_ARRAY) {
            $type -= self::TYPE_EMPTY_ARRAY;
            if (is_array($value) && ($value == [])) {
                return false;
            }
        }

        // ZERO_STRING ('0')
        if ($type >= self::TYPE_ZERO_STRING) {
            $type -= self::TYPE_ZERO_STRING;
            if (is_string($value) && ($value == '0')) {
                return false;
            }

            if (!$casting && (is_string($value)) && ($value == '1')) {
                return true;
            }
        }

        // STRING ('')
        if ($type >= self::TYPE_STRING) {
            $type -= self::TYPE_STRING;
            if (is_string($value) && ($value == '')) {
                return false;
            }
        }

        // FLOAT (0.0)
        if ($type >= self::TYPE_FLOAT) {
            $type -= self::TYPE_FLOAT;
            if (is_float($value) && ($value == 0.0)) {
                return false;
            }

            if (!$casting && is_float($value) && ($value == 1.0)) {
                return true;
            }
        }

        // INTEGER (0)
        if ($type >= self::TYPE_INTEGER) {
            $type -= self::TYPE_INTEGER;
            if (is_int($value) && ($value == 0)) {
                return false;
            }

            if (!$casting && is_int($value) && ($value == 1)) {
                return true;
            }
        }

        // BOOLEAN (false)
        if ($type >= self::TYPE_BOOLEAN) {
            $type -= self::TYPE_BOOLEAN;
            if (is_bool($value)) {
                return $value;
            }
        }

        if ($casting) {
            return true;
        }

        return $value;
    }
345000
public static function isEEATransaction($iban1, $iban2)
    {
        // remove whitespaces
        $iban1 = preg_replace('#\s+#','',$iban1);
        $iban2 = preg_replace('#\s+#','',$iban2);

        // check if both county codes belong to the EEA
        $EEA = ['IS' => 1, 'LI' => 1, 'NO' => 1, 'BE' => 1, 'BG' => 1, 'DK' => 1, 'DE' => 1,
                'EE' => 1, 'FI' => 1, 'FR' => 1, 'GR' => 1, 'IE' => 1, 'IT' => 1, 'HR' => 1,
                'LV' => 1, 'LT' => 1, 'LU' => 1, 'MT' => 1, 'NL' => 1, 'AT' => 1, 'PL' => 1,
                'PT' => 1, 'RO' => 1, 'SE' => 1, 'SK' => 1, 'SI' => 1, 'ES' => 1, 'CZ' => 1,
                'HU' => 1, 'GB' => 1, 'CY' => 1];

        if(isset($EEA[strtoupper(substr($iban1,0,2))],$EEA[strtoupper(substr($iban2,0,2))]))
            return true;

        return false;
    }
547919
function(types, options){
			if(!Array.isArray(types)) {
				return options.inverse(this);
			}
			var typesWithDescriptions = [];
			types.forEach(function( type ){
				if(type.description){
					typesWithDescriptions.push(type)
				}
			});
			
			if( !typesWithDescriptions.length ) {
				// check the 1st one's options
				if(types.length == 1 && types[0].options ) {
					types[0].options.forEach(function(option){
						typesWithDescriptions.push(option);
					});
				}
				
			}
			
			if(typesWithDescriptions.length){
				return options.fn({types: typesWithDescriptions});
			} else {
				return options.inverse(this);
			}
		}
793290
public static function crossCheckIbanBic($iban, $bic)
    {
        // check for special cases
        if(in_array(strtoupper($bic), self::$exceptionalBics))
            return true;

        // remove whitespaces
        $iban = preg_replace('#\s+#','',$iban);
        $bic  = preg_replace('#\s+#','',$bic);

        // check the country code
        $ibanCountryCode = strtoupper(substr($iban,0,2));
        $bicCountryCode = strtoupper(substr($bic,4,2));

        if($ibanCountryCode === $bicCountryCode
            || (isset(self::$bicIbanCountryCodeExceptions[$ibanCountryCode])
                && in_array($bicCountryCode,self::$bicIbanCountryCodeExceptions[$ibanCountryCode])))
            return true;
        else
            return false;
    }
644372
public function isMultilang()
	{
		// Flag to avoid doing multiple database queries.
		static $tested = false;

		// Status of language filter plugin.
		static $enabled = false;

		// If being called from the front-end, we can avoid the database query.
		if (\App::isSite())
		{
			return \App::get('language.filter');
		}

		// If already tested, don't test again.
		if (!$tested)
		{
			// Determine status of language filter plug-in.
			$db = \App::get('db');
			$query = $db->getQuery()
				->select('enabled')
				->from('#__extensions')
				->whereEquals('type', 'plugin')
				->whereEquals('folder', 'system')
				->whereEquals('element', 'languagefilter');
			$db->setQuery($query->toString());

			$enabled = $db->loadResult();
			$tested  = true;
		}

		return $enabled;
	}
76576
protected function guessBelongsToManyRelation()
    {
        $caller = null;
        foreach (debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS) as $trace) {
            if (in_array($trace['function'], Model::$manyMethods)) {
                $caller = $trace;
                break;
            }
        }

        return ! is_null($caller) ? $caller['function'] : null;
    }
667377
public function isTypeOf($value)
    {
        return isset($this->isTypeOf) ? call_user_func($this->isTypeOf, $value) : NULL;
    }
12615
private function return_($value) {
        if (abs($value) === INF) {
            return $value;
        } else if ($value === 'INF') {
            return INF;
        } else if ($value === '-INF') {
            return -INF;
        } else {
            return (float) $value;
        }
    }
1264517
public function getReturnType()
    {
        $isBuiltin  = false;
        $returnType = $this->functionLikeNode->getReturnType();
        $isNullable = $returnType instanceof NullableType;

        if ($isNullable) {
            $returnType = $returnType->type;
        }
        if ($returnType instanceof Identifier) {
            $isBuiltin = true;
            $returnType = $returnType->toString();
        } elseif (is_object($returnType)) {
            $returnType = $returnType->toString();
        } elseif (is_string($returnType)) {
            $isBuiltin = true;
        } else {
            return null;
        }

        return new ReflectionType($returnType, $isNullable, $isBuiltin);
    }
785529
public static function getPrimitiveTypeOf($instance)
    {
        $phpType = gettype($instance);

        if (isset(self::$phpToJson[$phpType])) {
            return self::$phpToJson[$phpType];
        }

        throw new UnsupportedTypeException($phpType);
    }
1133765
public function isSupported()
    {
        $result = true;
        $table  = $this->getMixer();

        //Only check if we are connected with a table object, otherwise just return true.
        if($table instanceof DatabaseTableInterface)
        {
            if($table->hasColumn('slug'))
            {
                //If unique is NULL use the column metadata
                if(is_null($this->_unique)) {
                    $this->_unique = $table->getColumn('slug', true)->unique;
                }
            }
            else $result = false;
        }

        return $result;
    }
285299
protected function query($value)
    {
        $conditions = [$this->field => $value];
        /** @var MapperInterface $mapper */
        $mapper = $this->mapperManager->get($this->getEntity());
        if (!empty($this->exclude)) {
            $field = $this->exclude['field'] ?? '';
            $excludedValue = $this->exclude['value'] ?? '';
            $operator = $this->exclude['operator'] ?? '!=';

            if (!empty($field) && !empty($excludedValue)) {
                $conditions[] = $mapper->quoteIdentifier($field) . $operator . $mapper->quoteValue($excludedValue);
            }
        }
        $result = $mapper->find('all', [
            'conditions' => $conditions
        ]);

        return $result;
    }
816835
private function areNullableReturnTypesSupported(): bool
    {
        $testVersion = trim(PHPCompatibility\PHPCSHelper::getConfigData('testVersion') ?: '');
        if (!$testVersion) {
            return false;
        }

        preg_match('`^(\d+\.\d+)(?:\s*-\s*(?:\d+\.\d+)?)?$`', $testVersion, $matches);
        $min = $matches[1] ?? null;

        return $min && version_compare($min, '7.1', '>=');
    }
123875
public function interpret()
    {
        /** @var Collection|ModuleInterface[] $modules */
        $modules = $this->sortModules(
            $this->core->modules()->getModules()
        );

        foreach ($modules as $moduleKey => $module) {

            // If the configuration has overriding data for this module's presence,
            // use it. Otherwise load the menu's own presence.
            // Normalize single & plural presences for each module.

            if ($this->isConfiguredModulePresenceDisabled($module)) {
                continue;
            }

            if ($this->hasConfiguredModulePresence($module)) {

                $configuredPresencesForModule = $this->normalizeConfiguredPresence(
                    $this->getConfiguredModulePresence($module)
                );

                $presencesForModule = $this->mergeNormalizedMenuPresences(
                    $this->normalizeMenuPresence($module->getMenuPresence()),
                    $configuredPresencesForModule
                );

            } else {
                // If no configuration is set, simply normalize and use the original

                $presencesForModule = $this->normalizeMenuPresence($module->getMenuPresence());
            }


            // If a module has no presence, skip it
            if ( ! $presencesForModule) {
                continue;
            }

            $standard    = [];
            $alternative = [];

            foreach ($presencesForModule as $presence) {

                // If a menu presence is deemed 'alternative',
                // it should not appear in the normal menu structure.
                if ($this->isMenuPresenceAlternative($presence)) {

                    $alternative[] = $presence;
                    continue;
                }

                $standard[] = $presence;
            }

            if (count($standard)) {
                $this->presences->standard->put($moduleKey, $standard);
            }
            if (count($alternative)) {
                $this->presences->alternative->put($moduleKey, $alternative);
            }
        }

        return $this->presences;
    }
257205
public function getWith()
    {
        // protect entity if it demands that nothing be sideloaded
        if ($this->entityWith == 'block') {
            return 'none';
        }

        // put entity in charge if client defers
        if ($this->suppliedWith == 'default') {
            return $this->entityWith;
        }

        // put client in charge if entity defers
        if ($this->entityWith == 'none') {
            return $this->suppliedWith;
        }

        // check for all
        if ($this->entityWith == 'all' or $this->suppliedWith == 'all') {
            return 'all';
        }

        // return merged result if nothing else was detected
        return $this->entityWith . ',' . $this->suppliedWith;
    }
849786
public static function isValueType($value)
    {
        if (is_scalar($value) || $value === null) {
            return true;
        } elseif (is_array($value)) {
            $isScalar = true;
            array_walk_recursive($value,
                    function ($value) use (&$isScalar) {
                        if ($isScalar && !(is_scalar($value) || $value === null)) {
                            $isScalar = false;
                        }
                    });

            return $isScalar;
        } else {
            return false;
        }
    }