diff --git a/modules/contrib/token/tests/src/Kernel/FieldTest.php b/modules/contrib/token/tests/src/Kernel/FieldTest.php
index d418088..b9a7d88 100644
--- a/modules/contrib/token/tests/src/Kernel/FieldTest.php
+++ b/modules/contrib/token/tests/src/Kernel/FieldTest.php
@@ -12,6 +12,10 @@
 use Drupal\node\Entity\Node;
 use Drupal\node\Entity\NodeType;
 use Drupal\contact\Entity\Message;
+use Drupal\Component\Utility\Html;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\taxonomy\Tests\TaxonomyTestTrait;
+use Drupal\Core\Render\BubbleableMetadata;
 
 /**
  * Tests field tokens.
@@ -20,17 +24,27 @@
  */
 class FieldTest extends KernelTestBase {
 
+  use TaxonomyTestTrait;
+
   /**
    * @var \Drupal\filter\FilterFormatInterface
    */
   protected $testFormat;
 
+
+  /**
+   * Vocabulary for testing chained token support.
+   *
+   * @var \Drupal\taxonomy\VocabularyInterface
+   */
+  protected $vocabulary;
+
   /**
    * Modules to enable.
    *
    * @var array
    */
-  public static $modules = ['node', 'text', 'field', 'filter', 'contact', 'options'];
+  public static $modules = ['node', 'text', 'field', 'filter', 'contact', 'options', 'taxonomy'];
 
   /**
    * {@inheritdoc}
@@ -40,6 +54,7 @@ public function setUp() {
 
     $this->installEntitySchema('user');
     $this->installEntitySchema('node');
+    $this->installEntitySchema('taxonomy_term');
 
     // Create the article content type with a text field.
     $node_type = NodeType::create([
@@ -107,6 +122,64 @@ public function setUp() {
       'entity_type' => 'node',
       'bundle' => 'article',
     ])->save();
+
+    // Add a node reference field.
+    $reference_storage = FieldStorageConfig::create([
+      'field_name' => 'test_reference',
+      'entity_type' => 'node',
+      'type' => 'entity_reference',
+    ]);
+    $reference_storage->save();
+
+    $reference = FieldConfig::create([
+      'field_name' => 'test_reference',
+      'entity_type' => 'node',
+      'bundle' => 'article',
+      'label' => 'Test reference',
+    ]);
+    $reference->save();
+
+    // Add a taxonomy term reference field.
+    $this->vocabulary = $this->createVocabulary();
+    $reference_storage = FieldStorageConfig::create([
+      'field_name' => 'test_term_reference',
+      'entity_type' => 'node',
+      'type' => 'entity_reference',
+      'settings' => [
+        'target_type' => 'taxonomy_term',
+      ],
+    ]);
+    $reference_storage->save();
+
+    $reference = FieldConfig::create([
+      'field_name' => 'test_term_reference',
+      'entity_type' => 'node',
+      'bundle' => 'article',
+      'label' => 'Test term reference',
+      'settings' => [
+        'handler' => 'default:taxonomy_term',
+        'handler_settings' => [
+          'target_bundles' => [
+            $this->vocabulary->id() => $this->vocabulary->id(),
+          ],
+        ]
+      ]
+    ]);
+    $reference->save();
+
+    // Add a field to the vocabulary.
+    $storage = FieldStorageConfig::create([
+      'field_name' => 'term_field',
+      'entity_type' => 'taxonomy_term',
+      'type' => 'text',
+    ]);
+    $storage->save();
+    $field = FieldConfig::create([
+      'field_name' => 'term_field',
+      'entity_type' => 'taxonomy_term',
+      'bundle' => $this->vocabulary->id(),
+    ]);
+    $field->save();
   }
 
   /**
@@ -316,4 +389,118 @@ public function testBaseFieldTokens() {
     // Verify that node entity type doesn't have a uid token.
     $this->assertNull($tokenService->getTokenInfo('node', 'uid'));
   }
+
+  /*
+   * Tests chaining tokens.
+   */
+  public function testChainedTokens() {
+    $reference = Node::create([
+      'title' => 'Test node to reference',
+      'type' => 'article',
+      'test_field' => [
+        'value' => 'foo',
+        'format' => $this->testFormat->id(),
+      ]
+    ]);
+    $reference->save();
+    $term_reference_field_value = $this->randomString();
+    $term_reference = $this->createTerm($this->vocabulary, [
+      'name' => 'Term to reference',
+      'term_field' => [
+        'value' => $term_reference_field_value,
+        'format' => $this->testFormat->id(),
+      ],
+    ]);
+    $entity = Node::create([
+      'title' => 'Test entity reference',
+      'type' => 'article',
+      'test_reference' => ['target_id' => $reference->id()],
+      'test_term_reference' => ['target_id' => $term_reference->id()],
+    ]);
+    $entity->save();
+
+    $this->assertTokens('node', ['node' => $entity], [
+      'test_reference:entity:title' => Markup::create('Test node to reference'),
+      'test_reference:entity:test_field' => Markup::create('foo'),
+      'test_term_reference:entity:term_field' => Html::escape($term_reference_field_value),
+      'test_reference:target_id' => $reference->id(),
+      'test_term_reference:target_id' => $term_reference->id(),
+      'test_term_reference:entity:url:path' => '/' . $term_reference->toUrl('canonical')->getInternalPath(),
+    ]);
+
+    // Test the :entity tokens.
+    $input = $this->mapTokenNames('node', ['test_term_reference:entity']);
+    $bubbleable_metadata = new BubbleableMetadata();
+    $replacement = \Drupal::token()->generate('node', $input, ['node' => $entity], [], $bubbleable_metadata);
+    $replacement_term_field_value = $replacement['[node:test_term_reference:entity]']->get('term_field')->getValue()[0]['value'];
+    $this->assertTrue($replacement_term_field_value == $term_reference_field_value);
+
+    // Test some non existent tokens.
+    $this->assertNoTokens('node', ['node' => $entity], [
+      'test_reference:1:title',
+      'test_term_reference:do_not_exists',
+      'test_term_reference:do:not:exists',
+      'test_term_reference:do_not_exists:0',
+    ]);
+  }
+
+  /**
+   * Tests support for cardinality > 1 chaining.
+   */
+  public function testMultivalueCardinality() {
+    /** @var \Drupal\field\FieldStorageConfigInterface $storage */
+    $storage = FieldStorageConfig::load('node.test_term_reference');
+    $storage->setCardinality(FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED);
+    $storage->save();
+
+    // Add a few terms.
+    $terms = [];
+    $terms_value = [];
+    foreach (range(1, 3) as $i) {
+      $terms_value[$i] = $this->randomString();
+      $terms[$i] = $this->createTerm($this->vocabulary, [
+        'name' => $this->randomString(),
+        'term_field' => [
+          'value' => $terms_value[$i],
+          'format' => $this->testFormat->id(),
+        ],
+      ]);
+    }
+
+    $entity = Node::create([
+      'title' => 'Test multivalue chained tokens',
+      'type' => 'article',
+      'test_term_reference' => [
+        ['target_id' => $terms[1]->id()],
+        ['target_id' => $terms[2]->id()],
+        ['target_id' => $terms[3]->id()],
+      ],
+    ]);
+    $entity->save();
+
+    $this->assertTokens('node', ['node' => $entity], [
+      'test_term_reference:0:entity:term_field' => Html::escape($terms[1]->term_field->value),
+      'test_term_reference:1:entity:term_field' => Html::escape($terms[2]->term_field->value),
+      'test_term_reference:2:entity:term_field' => Html::escape($terms[3]->term_field->value),
+      'test_term_reference:0:target_id' => $terms[1]->id(),
+      'test_term_reference:1:target_id' => $terms[2]->id(),
+      'test_term_reference:2:target_id' => $terms[3]->id(),
+    ]);
+
+    // Test some non existent tokens.
+    $this->assertNoTokens('node', ['node' => $entity], [
+      'test_term_reference:3:term_field',
+      'test_term_reference:0:do_not_exists',
+      'test_term_reference:1:do:not:exists',
+      'test_term_reference:1:2:do_not_exists',
+    ]);
+
+    // Test the :entity tokens.
+    $input = $this->mapTokenNames('node', ['test_term_reference:0:entity']);
+    $bubbleable_metadata = new BubbleableMetadata();
+    $replacement = \Drupal::token()->generate('node', $input, ['node' => $entity], [], $bubbleable_metadata);
+    $replacement_term_field_value = $replacement['[node:test_term_reference:0:entity]']->get('term_field')->getValue()[0]['value'];
+    $this->assertTrue($replacement_term_field_value == $terms_value[1]);
+  }
+
 }
diff --git a/modules/contrib/token/token.tokens.inc b/modules/contrib/token/token.tokens.inc
index 68e2755..4f519e7 100644
--- a/modules/contrib/token/token.tokens.inc
+++ b/modules/contrib/token/token.tokens.inc
@@ -5,6 +5,7 @@
  * Token callbacks for the token module.
  */
 use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Entity\TypedData\EntityDataDefinitionInterface;
 use Drupal\Core\Field\BaseFieldDefinition;
 use Drupal\Core\Render\BubbleableMetadata;
 use Drupal\Core\Render\Element;
@@ -13,6 +14,7 @@
 use Drupal\Component\Utility\Unicode;
 use Drupal\Component\Utility\Html;
 use Drupal\Component\Utility\Xss;
+use Drupal\Core\TypedData\DataReferenceDefinitionInterface;
 use Drupal\Core\Url;
 use Drupal\field\FieldConfigInterface;
 use Drupal\field\FieldStorageConfigInterface;
@@ -1276,6 +1278,16 @@ function field_token_info_alter(&$info) {
             'module' => 'token',
           ];
         }
+        elseif (($property_definition instanceof DataReferenceDefinitionInterface) && ($property_definition->getTargetDefinition() instanceof EntityDataDefinitionInterface)) {
+          $referenced_entity_type = $property_definition->getTargetDefinition()->getEntityTypeId();
+          $referenced_token_type = \Drupal::service('token.entity_mapper')->getTokenTypeForEntityType($referenced_entity_type);
+          $info['tokens'][$field_token_name][$property] = [
+            'name' => 'Referenced entity',
+            'description' => t('The entity referenced by this entity reference field.'),
+            'module' => 'token',
+            'type' => $referenced_token_type,
+          ];
+        }
       }
     }
   }
@@ -1345,7 +1357,7 @@ function field_tokens($type, $tokens, array $data = array(), array $options = ar
         list($field_name, $delta) = explode(':', $name, 2);
         if (!is_numeric($delta)) {
           unset($delta);
-         }
+        }
         $token_name = $field_name;
       }
       if (_token_module($data['token_type'], $token_name) != 'token') {
@@ -1395,12 +1407,67 @@ function field_tokens($type, $tokens, array $data = array(), array $options = ar
       }
       // Handle [entity:field_name:value] and [entity:field_name:0:value]
       // tokens.
-      else if ($field_tokens = \Drupal::token()->findWithPrefix($tokens, $field_name)) {
-        $property_token_data = [
-          'field_property' => TRUE,
-          $data['entity_type'] . '-' . $field_name => $data['entity']->$field_name,
-          'field_name' => $data['entity_type'] . '-' . $field_name,
-        ];
+      else {
+        $field = $entity->$field_name;
+        $parts = explode(':', $name, 4);
+        $multivalued = false;
+        $delta = 0;
+        if ((count($parts) >= 3) && is_numeric($parts[1])) {
+          // Multivalued field.
+          $multivalued = true;
+          $delta = $parts[1];
+        }
+        // Handle entity reference fields.
+        if (
+          $field->getFieldDefinition()->getType() === 'entity_reference'
+          && (count($parts) > 2)
+          && !((count($parts) == 3) && $multivalued)
+        ) {
+          if ((count($parts) >= 4) && ($parts[2] === 'entity')) {
+            // Token is [entity:field_name:0:entity:value].
+            if (count($field) <= $delta) {
+              // No such delta for this field, abort token replacement.
+              continue;
+            }
+            $literal_text = $parts[3];
+          }
+          elseif (count($parts) >= 3 && ($parts[1] === 'entity')) {
+            // Token is [entity:field_name:entity:value].
+            $literal_text = implode(':', array_slice($parts, 2));
+          }
+          else {
+            // Token not of the form expected.
+            continue;
+          }
+
+          // Get the referenced entity type.
+          $field_storage_definition = $field->getFieldDefinition()->getFieldStorageDefinition();
+          $field_property_definition = $field_storage_definition->getPropertyDefinitions();
+          $referenced_token_type = $field_property_definition['entity']->getTargetDefinition()->getEntityTypeId();
+
+          $field_name = \Drupal::service('token.entity_mapper')->getTokenTypeForEntityType($referenced_token_type, TRUE);
+          $referenced_entity = $field[$delta]->entity;
+          $bubbleable_metadata->addCacheableDependency($referenced_entity);
+
+          $field_tokens = [
+            $literal_text => $original,
+          ];
+          $property_token_data = [
+            $field_name => $referenced_entity,
+          ];
+        }
+        // Handle fields that are not entity reference fields or field property
+        // tokens of entity reference fields (eg. [entity:field_name:entity] or
+        // [entity:field_name:0:entity]).
+        else {
+          $field_tokens = \Drupal::token()->findWithPrefix($tokens, $field_name);
+          $property_token_data = [
+            'field_property' => TRUE,
+            $data['entity_type'] . '-' . $field_name => $data['entity']->$field_name,
+            'field_name' => $data['entity_type'] . '-' . $field_name,
+          ];
+        }
+
         $replacements += \Drupal::token()->generate($field_name, $field_tokens, $property_token_data, $options, $bubbleable_metadata);
       }
     }
diff --git a/profiles/amaysim_profile/amaysim_profile.post_update.php b/profiles/amaysim_profile/amaysim_profile.post_update.php
index b6719dc..4584e72 100644
--- a/profiles/amaysim_profile/amaysim_profile.post_update.php
+++ b/profiles/amaysim_profile/amaysim_profile.post_update.php
@@ -182,6 +182,7 @@ function amaysim_profile_post_update_create_sample_hs_category_terms() {
     $vocabulary = Vocabulary::create([
       'vid' => 'hs_category',
       'name' => 'Help and Support category',
+      'uuid' => '36b2af70-7c7f-4943-8cf1-45745812e084',
     ]);
     $vocabulary->save();
   }
diff --git a/themes/custom/amaysim/amaysim.theme b/themes/custom/amaysim/amaysim.theme
index 9e427a5..f571a35 100644
--- a/themes/custom/amaysim/amaysim.theme
+++ b/themes/custom/amaysim/amaysim.theme
@@ -78,7 +78,7 @@ function amaysim_preprocess_page(&$vars) {
       // Add the search class if it's set to show.
       if ($node->get('field_show_search')->value) {
         $vars['is_search'] = TRUE;
-        if (!$node->get('field_popular_searches')->isEmpty()) {
+        if ($node->hasField('field_popular_searches') && !$node->get('field_popular_searches')->isEmpty()) {
           $vars['popular_searches'] = $node_view_builder->view($node, 'popular_searches');
         }