From d1f68d0d791edb511ae0a0a6fe94866e95a4b6c4 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Thu, 26 Mar 2026 00:30:20 +0000
Subject: [PATCH] Refactor - auto update credential provider script

---
 .../AddressMetaDataExtension.sys.mjs          |    3 +
 .../Assets/CC_Script/AddressParser.sys.mjs    |   36 +
 .../Assets/CC_Script/AddressRecord.sys.mjs    |   20 +
 .../CC_Script/AutofillFormFactory.sys.mjs     |    4 +
 .../CC_Script/AutofillTelemetry.sys.mjs       |   47 -
 .../Client/Assets/CC_Script/Constants.ios.mjs |    3 +-
 .../Assets/CC_Script/CreditCard.sys.mjs       |    3 +-
 .../Assets/CC_Script/CreditCardRecord.sys.mjs |   45 +
 .../Assets/CC_Script/FieldScanner.sys.mjs     |   75 +-
 .../Assets/CC_Script/FormAutofill.sys.mjs     |   45 +-
 .../CC_Script/FormAutofillHandler.sys.mjs     | 1036 +++++++++++------
 .../CC_Script/FormAutofillHeuristics.sys.mjs  |  241 ++--
 .../CC_Script/FormAutofillSection.sys.mjs     |  225 ++--
 .../CC_Script/FormAutofillUtils.sys.mjs       |  255 ++--
 .../Assets/CC_Script/FormLikeFactory.sys.mjs  |    4 +-
 .../Client/Assets/CC_Script/Helpers.ios.mjs   |   17 +-
 .../Assets/CC_Script/HeuristicsRegExp.sys.mjs |   89 +-
 .../Assets/CC_Script/LabelUtils.sys.mjs       |  210 ++--
 .../CC_Script/LoginManager.shared.sys.mjs     |  116 +-
 .../Assets/CC_Script/NewPasswordModel.sys.mjs |    3 +
 .../Client/Assets/CC_Script/Overrides.ios.js  |    3 -
 .../CC_Script/PasswordGenerator.sys.mjs       |    5 +-
 .../Assets/CC_Script/PhoneNumber.sys.mjs      |   23 +
 23 files changed, 1556 insertions(+), 952 deletions(-)

diff --git a/firefox-ios/Client/Assets/CC_Script/AddressMetaDataExtension.sys.mjs b/firefox-ios/Client/Assets/CC_Script/AddressMetaDataExtension.sys.mjs
index f4dca18dde145..ef5bdcd2d7349 100644
--- a/firefox-ios/Client/Assets/CC_Script/AddressMetaDataExtension.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/AddressMetaDataExtension.sys.mjs
@@ -342,6 +342,8 @@ export const AddressMetaDataExtension = {
   },
   "data/JP": {
     alpha_3_code: "JPN",
+    fmt: "〒%Z%n%S%C%n%A%n%O%n%N",
+    require: "ACSZ",
   },
   "data/JE": {
     alpha_3_code: "JEY",
@@ -474,6 +476,7 @@ export const AddressMetaDataExtension = {
   },
   "data/NL": {
     alpha_3_code: "NLD",
+    address_reversed: true,
   },
   "data/NC": {
     alpha_3_code: "NCL",
diff --git a/firefox-ios/Client/Assets/CC_Script/AddressParser.sys.mjs b/firefox-ios/Client/Assets/CC_Script/AddressParser.sys.mjs
index e3d4c0e6cde00..daadcfdef22e1 100644
--- a/firefox-ios/Client/Assets/CC_Script/AddressParser.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/AddressParser.sys.mjs
@@ -313,4 +313,40 @@ export class AddressParser {
   static mergeWhitespace(s) {
     return s?.replace(/\s{2,}/g, " ");
   }
+
+  // This is quite fragile, but handles a number of basic cases. This is intended
+  // to split the street number suffix from the street number. For example:
+  // 35B will be split into number=35,suffix=B
+  // Returns an array with [housenumber, suffix]
+  static parseHouseSuffix(address, structuredAddress) {
+    let streetNumber = structuredAddress?.street_number;
+    if (!streetNumber) {
+      return null;
+    }
+
+    let numberIndex = address.indexOf(streetNumber);
+    if (numberIndex < 0) {
+      return [streetNumber];
+    }
+
+    let match = streetNumber.match(/^(\d+)(\w?)/);
+    if (!match) {
+      return [streetNumber];
+    }
+
+    let suffix;
+    let result = [match[1]];
+    // If the house number is after the street, include the rest of the address
+    // as part of the suffix, otherwise just include the suffix on the number.
+    if (numberIndex > structuredAddress?.street_name.length) {
+      suffix = address.substring(numberIndex + match[1].length).trim();
+    } else {
+      suffix = match[2];
+    }
+    if (suffix) {
+      result.push(suffix.replace("\n", " "));
+    }
+
+    return result;
+  }
 }
diff --git a/firefox-ios/Client/Assets/CC_Script/AddressRecord.sys.mjs b/firefox-ios/Client/Assets/CC_Script/AddressRecord.sys.mjs
index 599a802dcd130..313b27cedc8da 100644
--- a/firefox-ios/Client/Assets/CC_Script/AddressRecord.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/AddressRecord.sys.mjs
@@ -7,6 +7,7 @@ import { FormAutofillNameUtils } from "resource://gre/modules/shared/FormAutofil
 import { FormAutofillUtils } from "resource://gre/modules/shared/FormAutofillUtils.sys.mjs";
 import { PhoneNumber } from "resource://gre/modules/shared/PhoneNumber.sys.mjs";
 import { FormAutofill } from "resource://autofill/FormAutofill.sys.mjs";
+import { AddressParser } from "resource://gre/modules/shared/AddressParser.sys.mjs";
 
 /**
  * The AddressRecord class serves to handle and normalize internal address records.
@@ -32,6 +33,7 @@ export class AddressRecord {
   static computeFields(address) {
     this.#computeNameFields(address);
     this.#computeAddressLineFields(address);
+    this.#computeStreetAndHouseNumberFields(address);
     this.#computeCountryFields(address);
     this.#computeTelFields(address);
   }
@@ -66,6 +68,24 @@ export class AddressRecord {
     }
   }
 
+  static #computeStreetAndHouseNumberFields(address) {
+    if (!("address-housenumber" in address) && "street-address" in address) {
+      let streetAddress = address["street-address"];
+      let parsedAddress = AddressParser.parseStreetAddress(streetAddress);
+      if (parsedAddress) {
+        address["address-housenumber"] = parsedAddress.street_number;
+
+        let splitNumber = AddressParser.parseHouseSuffix(
+          streetAddress,
+          parsedAddress
+        );
+        if (splitNumber?.length >= 2) {
+          address["address-extra-housesuffix"] = splitNumber[1];
+        }
+      }
+    }
+  }
+
   static #computeCountryFields(address) {
     // Compute country name
     if (!("country-name" in address)) {
diff --git a/firefox-ios/Client/Assets/CC_Script/AutofillFormFactory.sys.mjs b/firefox-ios/Client/Assets/CC_Script/AutofillFormFactory.sys.mjs
index 68db143640172..450e8e96fad29 100644
--- a/firefox-ios/Client/Assets/CC_Script/AutofillFormFactory.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/AutofillFormFactory.sys.mjs
@@ -39,4 +39,8 @@ export const AutofillFormFactory = {
     }
     return lazy.FormLikeFactory.createFromField(aField, { ignoreForm });
   },
+
+  createFromDocumentRoot(aDocRoot) {
+    return lazy.FormLikeFactory.createFromDocumentRoot(aDocRoot);
+  },
 };
diff --git a/firefox-ios/Client/Assets/CC_Script/AutofillTelemetry.sys.mjs b/firefox-ios/Client/Assets/CC_Script/AutofillTelemetry.sys.mjs
index 9825aeacfe845..15e4f952342d5 100644
--- a/firefox-ios/Client/Assets/CC_Script/AutofillTelemetry.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/AutofillTelemetry.sys.mjs
@@ -12,10 +12,6 @@ class AutofillTelemetryBase {
   EVENT_CATEGORY = null;
   EVENT_OBJECT_FORM_INTERACTION = null;
 
-  HISTOGRAM_NUM_USES = null;
-  HISTOGRAM_PROFILE_NUM_USES = null;
-  HISTOGRAM_PROFILE_NUM_USES_KEY = null;
-
   #initFormEventExtra(value) {
     let extra = {};
     for (const field of Object.values(this.SUPPORTED_FIELDS)) {
@@ -183,17 +179,6 @@ class AutofillTelemetryBase {
     throw new Error("Not implemented.");
   }
 
-  recordNumberOfUse(records) {
-    let histogram = Services.telemetry.getKeyedHistogramById(
-      this.HISTOGRAM_PROFILE_NUM_USES
-    );
-    histogram.clear();
-
-    for (let record of records) {
-      histogram.add(this.HISTOGRAM_PROFILE_NUM_USES_KEY, record.timesUsed);
-    }
-  }
-
   recordIframeLayoutDetection(flowId, fieldDetails) {
     const fieldsInMainFrame = [];
     const fieldsInIframe = [];
@@ -238,9 +223,6 @@ export class AddressTelemetry extends AutofillTelemetryBase {
   EVENT_OBJECT_FORM_INTERACTION = "AddressForm";
   EVENT_OBJECT_FORM_INTERACTION_EXT = "AddressFormExt";
 
-  HISTOGRAM_PROFILE_NUM_USES = "AUTOFILL_PROFILE_NUM_USES";
-  HISTOGRAM_PROFILE_NUM_USES_KEY = "address";
-
   // Fields that are recorded in `address_form` and `address_form_ext` telemetry
   SUPPORTED_FIELDS = {
     "street-address": "street_address",
@@ -316,10 +298,6 @@ class CreditCardTelemetry extends AutofillTelemetryBase {
   EVENT_CATEGORY = "creditcard";
   EVENT_OBJECT_FORM_INTERACTION = "CcFormV2";
 
-  HISTOGRAM_NUM_USES = "CREDITCARD_NUM_USES";
-  HISTOGRAM_PROFILE_NUM_USES = "AUTOFILL_PROFILE_NUM_USES";
-  HISTOGRAM_PROFILE_NUM_USES_KEY = "credit_card";
-
   // Mapping of field name used in formautofill code to the field name
   // used in the telemetry.
   SUPPORTED_FIELDS = {
@@ -369,23 +347,6 @@ class CreditCardTelemetry extends AutofillTelemetryBase {
     }
   }
 
-  recordNumberOfUse(records) {
-    super.recordNumberOfUse(records);
-
-    if (!this.HISTOGRAM_NUM_USES) {
-      return;
-    }
-
-    let histogram = Services.telemetry.getHistogramById(
-      this.HISTOGRAM_NUM_USES
-    );
-    histogram.clear();
-
-    for (let record of records) {
-      histogram.add(record.timesUsed);
-    }
-  }
-
   recordAutofillProfileCount(count) {
     Glean.formautofillCreditcards.autofillProfilesCount.set(count);
   }
@@ -463,14 +424,6 @@ export class AutofillTelemetry {
     telemetry.recordAutofillProfileCount(count);
   }
 
-  /**
-   * Utility functions for address/credit card number of use
-   */
-  static recordNumberOfUse(type, records) {
-    const telemetry = this.#getTelemetryByType(type);
-    telemetry.recordNumberOfUse(records);
-  }
-
   static recordFormSubmissionHeuristicCount(label) {
     Glean.formautofill.formSubmissionHeuristic[label].add(1);
   }
diff --git a/firefox-ios/Client/Assets/CC_Script/Constants.ios.mjs b/firefox-ios/Client/Assets/CC_Script/Constants.ios.mjs
index 1281ac259f914..cd73ef59d48e1 100644
--- a/firefox-ios/Client/Assets/CC_Script/Constants.ios.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/Constants.ios.mjs
@@ -5,7 +5,6 @@
 const IOS_DEFAULT_PREFERENCES = {
   "extensions.formautofill.creditCards.heuristics.mode": 1,
   "extensions.formautofill.creditCards.heuristics.fathom.confidenceThreshold": 0.5,
-  "extensions.formautofill.creditCards.heuristics.fathom.highConfidenceThreshold": 0.95,
   "extensions.formautofill.creditCards.heuristics.fathom.testConfidence": 0,
   "extensions.formautofill.creditCards.heuristics.fathom.types":
     "cc-number,cc-name",
@@ -32,11 +31,11 @@ const IOS_DEFAULT_PREFERENCES = {
   "extensions.formautofill.heuristics.captureOnPageNavigation": false,
   "extensions.formautofill.heuristics.detectDynamicFormChanges": false,
   "extensions.formautofill.heuristics.fillOnDynamicFormChanges": false,
+  "extensions.formautofill.heuristics.refillOnSiteClearingFields": false,
   "extensions.formautofill.focusOnAutofill": false,
   "extensions.formautofill.test.ignoreVisibilityCheck": false,
   "extensions.formautofill.heuristics.autofillSameOriginWithTop": false,
   "signon.generation.confidenceThreshold": 0.75,
-  "extensions.formautofill.ml.experiment.enabled": false,
 };
 
 // Used Mimic the behavior of .getAutocompleteInfo()
diff --git a/firefox-ios/Client/Assets/CC_Script/CreditCard.sys.mjs b/firefox-ios/Client/Assets/CC_Script/CreditCard.sys.mjs
index 622c371d76ad8..0b52d96f7ed7a 100644
--- a/firefox-ios/Client/Assets/CC_Script/CreditCard.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/CreditCard.sys.mjs
@@ -217,6 +217,7 @@ export class CreditCard {
 
   /**
    * Normalizes a credit card number.
+   *
    * @param {string} number
    * @return {string | null}
    * @memberof CreditCard
@@ -346,8 +347,8 @@ export class CreditCard {
   }
 
   /**
-   *
    * Please use getLabelInfo above, as it allows for localization.
+   *
    * @deprecated
    */
   static getLabel({ number, name }) {
diff --git a/firefox-ios/Client/Assets/CC_Script/CreditCardRecord.sys.mjs b/firefox-ios/Client/Assets/CC_Script/CreditCardRecord.sys.mjs
index 97235e8cddad7..a7436213da35a 100644
--- a/firefox-ios/Client/Assets/CC_Script/CreditCardRecord.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/CreditCardRecord.sys.mjs
@@ -12,6 +12,51 @@ import { FormAutofillNameUtils } from "resource://gre/modules/shared/FormAutofil
  * for processing and consistent data representation.
  */
 export class CreditCardRecord {
+  /**
+   * Computes derived fields from the basic fields in the CreditCard object.
+   *
+   * @param {object} creditCard The credit card object
+   */
+  static computeFields(creditCard) {
+    this.#computeCCNameFields(creditCard);
+    this.#computeCCExpirationDateFields(creditCard);
+    this.#computeCCTypeField(creditCard);
+  }
+
+  static #computeCCExpirationDateFields(creditCard) {
+    if (!("cc-exp" in creditCard)) {
+      if (creditCard["cc-exp-month"] && creditCard["cc-exp-year"]) {
+        creditCard["cc-exp"] =
+          String(creditCard["cc-exp-year"]) +
+          "-" +
+          String(creditCard["cc-exp-month"]).padStart(2, "0");
+      } else {
+        creditCard["cc-exp"] = "";
+      }
+    }
+  }
+
+  static #computeCCNameFields(creditCard) {
+    if (!("cc-given-name" in creditCard)) {
+      const nameParts = FormAutofillNameUtils.splitName(creditCard["cc-name"]);
+      creditCard["cc-given-name"] = nameParts.given;
+      creditCard["cc-additional-name"] = nameParts.middle;
+      creditCard["cc-family-name"] = nameParts.family;
+    }
+  }
+
+  static #computeCCTypeField(creditCard) {
+    const type = CreditCard.getType(creditCard["cc-number"]);
+    if (type) {
+      creditCard["cc-type"] = type;
+    }
+  }
+
+  /**
+   * Normalizes credit card fields by removing derived fields from the CreditCard, leaving the basic fields.
+   *
+   * @param {object} creditCard The credit card object
+   */
   static normalizeFields(creditCard) {
     this.#normalizeCCNameFields(creditCard);
     this.#normalizeCCNumberFields(creditCard);
diff --git a/firefox-ios/Client/Assets/CC_Script/FieldScanner.sys.mjs b/firefox-ios/Client/Assets/CC_Script/FieldScanner.sys.mjs
index 7d6a87d255cce..1110070fb3c8e 100644
--- a/firefox-ios/Client/Assets/CC_Script/FieldScanner.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/FieldScanner.sys.mjs
@@ -4,9 +4,7 @@
 
 const lazy = {};
 ChromeUtils.defineESModuleGetters(lazy, {
-  FormAutofill: "resource://autofill/FormAutofill.sys.mjs",
   FormAutofillUtils: "resource://gre/modules/shared/FormAutofillUtils.sys.mjs",
-  MLAutofill: "resource://autofill/MLAutofill.sys.mjs",
 });
 
 /**
@@ -42,6 +40,10 @@ export class FieldDetail {
   // The possible values are "autocomplete", "fathom", and "regex-heuristic"
   reason = null;
 
+  // This field could be a lookup field, for example, one that could be used to
+  // search for an address or postal code and fill in other fields.
+  isLookup = false;
+
   /*
    * The "section", "addressType", and "contactType" values are
    * used to identify the exact field when the serializable data is received
@@ -96,11 +98,9 @@ export class FieldDetail {
     fieldName = null,
     {
       autocompleteInfo = null,
-      fathomLabel = null,
       fathomConfidence = null,
       isVisible = true,
-      mlHeaderInput = null,
-      mlButtonInput = null,
+      isLookup = false,
     } = {}
   ) {
     const fieldDetail = new FieldDetail(element);
@@ -133,23 +133,6 @@ export class FieldDetail {
     } else if (fathomConfidence) {
       fieldDetail.reason = "fathom";
       fieldDetail.confidence = fathomConfidence;
-
-      // TODO: This should be removed once we support reference field info across iframe.
-      // Temporarily add an addtional "the field is the only visible input" constraint
-      // when determining whether a form has only a high-confidence cc-* field a valid
-      // credit card section. We can remove this restriction once we are confident
-      // about only using fathom.
-      fieldDetail.isOnlyVisibleFieldWithHighConfidence = false;
-      if (
-        fieldDetail.confidence >
-        lazy.FormAutofillUtils.ccFathomHighConfidenceThreshold
-      ) {
-        const root = element.form || element.ownerDocument;
-        const inputs = root.querySelectorAll("input:not([type=hidden])");
-        if (inputs.length == 1 && inputs[0] == element) {
-          fieldDetail.isOnlyVisibleFieldWithHighConfidence = true;
-        }
-      }
     } else {
       fieldDetail.reason = "regex-heuristic";
     }
@@ -168,16 +151,7 @@ export class FieldDetail {
     // Info required by heuristics
     fieldDetail.maxLength = element.maxLength;
 
-    if (
-      lazy.FormAutofill.isMLExperimentEnabled &&
-      ["input", "select"].includes(element.localName)
-    ) {
-      fieldDetail.mlinput = lazy.MLAutofill.getMLMarkup(fieldDetail.element);
-      fieldDetail.mlHeaderInput = mlHeaderInput;
-      fieldDetail.mlButtonInput = mlButtonInput;
-      fieldDetail.fathomLabel = fathomLabel;
-      fieldDetail.fathomConfidence = fathomConfidence;
-    }
+    fieldDetail.isLookup = isLookup;
 
     return fieldDetail;
   }
@@ -251,6 +225,43 @@ export class FieldScanner {
     return this.#fieldDetails[index];
   }
 
+  getFieldsMatching(matchFn, includeInvisible = false) {
+    let fields = [];
+
+    for (let idx = 0; this.elementExisting(idx); idx++) {
+      let field = this.#fieldDetails[idx];
+      if ((includeInvisible || field.isVisible) && matchFn(field)) {
+        fields.push(field);
+      }
+    }
+
+    return fields;
+  }
+
+  /**
+   * Return the index of the first visible field found with the given name.
+   *
+   * @param {string} fieldName
+   *        The field name to find.
+   * @param {string} includeInvisible
+   *        Whether to find non-visible fields.
+   * @returns {number}
+   *          The index of the element or -1 if not found.
+   */
+  getFieldIndexByName(fieldName, includeInvisible = false) {
+    for (let idx = 0; this.elementExisting(idx); idx++) {
+      let field = this.#fieldDetails[idx];
+      if (
+        field.fieldName == fieldName &&
+        (includeInvisible || field.isVisible)
+      ) {
+        return idx;
+      }
+    }
+
+    return -1;
+  }
+
   /**
    * When a field detail should be changed its fieldName after parsing, use
    * this function to update the fieldName which is at a specific index.
diff --git a/firefox-ios/Client/Assets/CC_Script/FormAutofill.sys.mjs b/firefox-ios/Client/Assets/CC_Script/FormAutofill.sys.mjs
index fb4e49a0fb84c..f7cd9fe232fc3 100644
--- a/firefox-ios/Client/Assets/CC_Script/FormAutofill.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/FormAutofill.sys.mjs
@@ -24,8 +24,8 @@ const ENABLED_AUTOFILL_ADDRESSES_SUPPORTED_COUNTRIES_PREF =
   "extensions.formautofill.addresses.supportedCountries";
 const ENABLED_AUTOFILL_CREDITCARDS_PREF =
   "extensions.formautofill.creditCards.enabled";
-const AUTOFILL_CREDITCARDS_REAUTH_PREF =
-  "extensions.formautofill.creditCards.reauth.optout";
+const AUTOFILL_CREDITCARDS_OS_AUTH_LOCKED_PREF =
+  "extensions.formautofill.creditCards.os-auth.locked.enabled";
 const AUTOFILL_CREDITCARDS_HIDE_UI_PREF =
   "extensions.formautofill.creditCards.hideui";
 const FORM_AUTOFILL_SUPPORT_RTL_PREF = "extensions.formautofill.supportRTL";
@@ -45,6 +45,10 @@ const AUTOFILL_FILL_ON_DYNAMIC_FORM_CHANGES_TIMEOUT_PREF =
   "extensions.formautofill.heuristics.fillOnDynamicFormChanges.timeout";
 const AUTOFILL_FILL_ON_DYNAMIC_FORM_CHANGES_PREF =
   "extensions.formautofill.heuristics.fillOnDynamicFormChanges";
+const AUTOFILL_REFILL_ON_SITE_CLEARING_VALUE_PREF =
+  "extensions.formautofill.heuristics.refillOnSiteClearingFields";
+const AUTOFILL_REFILL_ON_SITE_CLEARING_VALUE_TIMEOUT_PREF =
+  "extensions.formautofill.heuristics.refillOnSiteClearingFields.timeout";
 
 export const FormAutofill = {
   ENABLED_AUTOFILL_ADDRESSES_PREF,
@@ -54,11 +58,13 @@ export const FormAutofill = {
   ENABLED_AUTOFILL_SAME_ORIGIN_WITH_TOP,
   ENABLED_AUTOFILL_CREDITCARDS_PREF,
   ENABLED_AUTOFILL_DETECT_DYNAMIC_FORM_CHANGES_PREF,
-  AUTOFILL_CREDITCARDS_REAUTH_PREF,
+  AUTOFILL_CREDITCARDS_OS_AUTH_LOCKED_PREF,
   AUTOFILL_CREDITCARDS_AUTOCOMPLETE_OFF_PREF,
   AUTOFILL_ADDRESSES_AUTOCOMPLETE_OFF_PREF,
   AUTOFILL_FILL_ON_DYNAMIC_FORM_CHANGES_PREF,
   AUTOFILL_FILL_ON_DYNAMIC_FORM_CHANGES_TIMEOUT_PREF,
+  AUTOFILL_REFILL_ON_SITE_CLEARING_VALUE_PREF,
+  AUTOFILL_REFILL_ON_SITE_CLEARING_VALUE_TIMEOUT_PREF,
 
   _region: null,
 
@@ -212,10 +218,6 @@ export const FormAutofill = {
       prefix: logPrefix,
     });
   },
-
-  get isMLExperimentEnabled() {
-    return FormAutofill._isMLEnabled && FormAutofill._isMLExperimentEnabled;
-  },
 };
 
 // TODO: Bug 1747284. Use Region.home instead of reading "browser.serach.region"
@@ -326,43 +328,36 @@ XPCOMUtils.defineLazyPreferenceGetter(
 
 XPCOMUtils.defineLazyPreferenceGetter(
   FormAutofill,
-  "_isMLEnabled",
-  "browser.ml.enable",
+  "detectDynamicFormChanges",
+  "extensions.formautofill.heuristics.detectDynamicFormChanges",
   false
 );
 
 XPCOMUtils.defineLazyPreferenceGetter(
   FormAutofill,
-  "_isMLExperimentEnabled",
-  "extensions.formautofill.ml.experiment.enabled",
+  "fillOnDynamicFormChanges",
+  "extensions.formautofill.heuristics.fillOnDynamicFormChanges",
   false
 );
 
 XPCOMUtils.defineLazyPreferenceGetter(
   FormAutofill,
-  "MLModelRevision",
-  "extensions.formautofill.ml.experiment.modelRevision",
-  null
-);
-
-XPCOMUtils.defineLazyPreferenceGetter(
-  FormAutofill,
-  "detectDynamicFormChanges",
-  "extensions.formautofill.heuristics.detectDynamicFormChanges",
-  false
+  "fillOnDynamicFormChangeTimeout",
+  "extensions.formautofill.heuristics.fillOnDynamicFormChanges.timeout",
+  0
 );
 
 XPCOMUtils.defineLazyPreferenceGetter(
   FormAutofill,
-  "fillOnDynamicFormChanges",
-  "extensions.formautofill.heuristics.fillOnDynamicFormChanges",
+  "refillOnSiteClearingFields",
+  "extensions.formautofill.heuristics.refillOnSiteClearingFields",
   false
 );
 
 XPCOMUtils.defineLazyPreferenceGetter(
   FormAutofill,
-  "fillOnDynamicFormChangeTimeout",
-  "extensions.formautofill.heuristics.fillOnDynamicFormChanges.timeout",
+  "refillOnSiteClearingFieldsTimeout",
+  "extensions.formautofill.heuristics.refillOnSiteClearingFields.timeout",
   0
 );
 
diff --git a/firefox-ios/Client/Assets/CC_Script/FormAutofillHandler.sys.mjs b/firefox-ios/Client/Assets/CC_Script/FormAutofillHandler.sys.mjs
index 4b03f37653810..6fd5b7011bb48 100644
--- a/firefox-ios/Client/Assets/CC_Script/FormAutofillHandler.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/FormAutofillHandler.sys.mjs
@@ -17,6 +17,9 @@ ChromeUtils.defineESModuleGetters(lazy, {
   FormAutofillNameUtils:
     "resource://gre/modules/shared/FormAutofillNameUtils.sys.mjs",
   LabelUtils: "resource://gre/modules/shared/LabelUtils.sys.mjs",
+  PhoneNumber: "resource://gre/modules/shared/PhoneNumber.sys.mjs",
+  clearTimeout: "resource://gre/modules/Timer.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
 });
 
 const { FIELD_STATES } = FormAutofillUtils;
@@ -24,6 +27,7 @@ const { FIELD_STATES } = FormAutofillUtils;
 export const FORM_CHANGE_REASON = {
   NODES_ADDED: "nodes-added",
   NODES_REMOVED: "nodes-removed",
+  SELECT_OPTIONS_CHANGED: "select-options-changed",
   ELEMENT_INVISIBLE: "visible-element-became-invisible",
   ELEMENT_VISIBLE: "invisible-element-became-visible",
 };
@@ -67,13 +71,14 @@ export class FormAutofillHandler {
 
   #formMutationObserver = null;
 
+  #visibilityObserver = null;
   #visibilityStateObserverByElement = new WeakMap();
 
   /**
    *
    * fillOnFormChangeData.isWithinDynamicFormChangeThreshold:
    *              Flags if a "form-change" event is received within the timeout threshold
-   *              (see lazy.FormAutofill.fillOnDynamicFormChangeTimeout), that we set
+   *              (see FormAutofill.fillOnDynamicFormChangeTimeout), that we set
    *              in order to consider newly detected fields for filling.
    * fillOnFormChangeData.previouslyUsedProfile
    *              The previously used profile from the latest autocompletion.
@@ -81,10 +86,16 @@ export class FormAutofillHandler {
    *              The previously focused element id from the latest autocompletion
    *
    * This is used for any following form changes and is cleared after a time threshold
-   * set by lazy.FormAutofill.fillOnDynamicFormChangeTimeout.
+   * set by FormAutofill.fillOnDynamicFormChangeTimeout.
    */
   #fillOnFormChangeData = new Map();
 
+  /**
+   * Caching the refill timeout id to cancel it once we know that we're about to fill
+   * on form change, because this sets up another refill timeout.
+   */
+  #refillTimeoutId = null;
+
   /**
    * Flag to indicate whethere there is an ongoing autofilling/clearing process.
    */
@@ -155,6 +166,30 @@ export class FormAutofillHandler {
     this.#fieldDetails = fieldDetails;
   }
 
+  /**
+   * Replaces a field detail with a different element.
+   *
+   * @param {FieldDetail} fieldDetail
+   *        Field detail to replace.
+   * @param {Element} element
+   *        Element to replace.
+   * @returns {FieldDetail} the new field detail object.
+   */
+  #replaceFieldDetail(fieldDetail, element) {
+    let idx = this.#fieldDetails.indexOf(fieldDetail);
+    if (idx < 0) {
+      return null;
+    }
+
+    let newfd = lazy.FieldDetail.create(
+      element,
+      element.form,
+      fieldDetail.fieldName
+    );
+    this.#fieldDetails[idx] = newfd;
+    return newfd;
+  }
+
   /**
    * Determines whether 'setIdentifiedFieldDetails' has been called and the
    * `fieldDetails` have been initialized.
@@ -212,20 +247,10 @@ export class FormAutofillHandler {
     return this.#filledStateByElement.get(element);
   }
 
-  isVisiblityStateObserverSetUpByElement(element) {
-    return this.#visibilityStateObserverByElement.has(element);
-  }
-
-  setVisibilityStateObserverByElement(element, observer) {
-    this.#visibilityStateObserverByElement.set(element, observer);
-  }
-
-  clearVisibilityStateObserverByElement(element) {
-    if (this.isVisiblityStateObserverSetUpByElement(element)) {
-      const observer = this.#visibilityStateObserverByElement.get(element);
-      observer.disconnect();
-      this.#visibilityStateObserverByElement.delete(element);
-    }
+  #clearVisibilityObserver() {
+    this.#visibilityObserver.disconnect();
+    this.#visibilityObserver = null;
+    this.#visibilityStateObserverByElement = new WeakMap();
   }
 
   /**
@@ -268,6 +293,11 @@ export class FormAutofillHandler {
     return false;
   }
 
+  updateFormByElement(element) {
+    const formLike = lazy.AutofillFormFactory.createFromField(element);
+    this._updateForm(formLike);
+  }
+
   /**
    * Update the form with a new FormLike, and the related fields should be
    * updated or clear to ensure the data consistency.
@@ -286,8 +316,6 @@ export class FormAutofillHandler {
    *
    * @param {formLike} formLike
    *        The form that we collect information from.
-   * @param {boolean} includeIframe
-   *        True to add <iframe> to the returned FieldDetails array.
    * @param {boolean} ignoreInvisibleInput
    *        True to NOT run heuristics on invisible <input> fields.
    *
@@ -295,22 +323,13 @@ export class FormAutofillHandler {
    *        An array containing eligible fields for autofill, also
    *        including iframe.
    */
-  static collectFormFieldDetails(
-    formLike,
-    includeIframe,
-    ignoreInvisibleInput = true
-  ) {
+  static collectFormFieldDetails(formLike, ignoreInvisibleInput = true) {
     const fieldDetails =
       lazy.FormAutofillHeuristics.getFormInfo(formLike, ignoreInvisibleInput) ??
       [];
 
     // 'FormLike' only contains <input> & <select>, so in order to include <iframe>
     // in the list of 'FieldDetails', we need to search for <iframe> in the form.
-    if (!includeIframe) {
-      return fieldDetails;
-    }
-
-    // Insert <iframe> elements into the fieldDetails array, maintaining the element order.
     const elements = formLike.rootElement.querySelectorAll("iframe");
 
     let startIndex = 0;
@@ -320,6 +339,7 @@ export class FormAutofillHandler {
       if (FormAutofillUtils.isFieldVisible(element)) {
         const iframeFd = lazy.FieldDetail.create(element, formLike, "iframe");
 
+        // Insert <iframe> elements into the fieldDetails array, maintaining the element order.
         for (let index = startIndex; index < fieldDetails.length; index++) {
           let position = element.compareDocumentPosition(
             fieldDetails[index]?.element
@@ -344,7 +364,7 @@ export class FormAutofillHandler {
   }
 
   /**
-   * Resetting the state element's fieldDetail after it was removed from the form
+   * Resetting the filled state after an element was removed from the form
    * Todo: We'll need to update this.filledResult in FormAutofillParent (Bug 1948077).
    *
    * @param {HTMLElement} element that was removed
@@ -353,8 +373,7 @@ export class FormAutofillHandler {
     if (this.getFilledStateByElement(element) != FIELD_STATES.AUTO_FILLED) {
       return;
     }
-    const fieldDetail = this.getFieldDetailByElement(element);
-    this.#filledStateByElement.delete(fieldDetail);
+    this.#filledStateByElement.delete(element);
   }
 
   /**
@@ -414,7 +433,11 @@ export class FormAutofillHandler {
 
       let value = this.getFilledValueFromProfile(fieldDetail, profile);
       if (!value) {
-        this.changeFieldState(fieldDetail, FIELD_STATES.NORMAL);
+        // A field could have been filled by a previous fill, so only
+        // clear when in the preview state.
+        if (element.autofillState == FIELD_STATES.PREVIEW) {
+          this.changeFieldState(fieldDetail, FIELD_STATES.NORMAL);
+        }
         continue;
       }
 
@@ -428,7 +451,10 @@ export class FormAutofillHandler {
         // Unlike text input, select element is always previewed even if
         // the option is already selected.
         const option = this.matchSelectOptions(fieldDetail, profile);
-        value = option?.text ?? "";
+        if (!option) {
+          continue;
+        }
+        value = option.text ?? "";
       } else {
         continue;
       }
@@ -448,23 +474,37 @@ export class FormAutofillHandler {
    *        An array of IDs for the elements that should be autofilled.
    * @param {object} profile
    *        The data profile containing the values to be autofilled into the form fields.
+   * @param {boolean} isFormChange
+   *        True if this a fill caused by a form change.
    */
-  fillFields(focusedId, elementIds, profile) {
+  fillFields(focusedId, elementIds, profile, isFormChange) {
+    this.cancelRefillOnSiteClearingFieldsAction();
+
     this.#isAutofillInProgress = true;
     this.getAdaptedProfiles([profile]);
 
-    for (const fieldDetail of this.fieldDetails) {
-      const { element, elementId } = fieldDetail;
+    const filledValuesByElement = new Map();
+    for (let fieldDetail of this.fieldDetails) {
+      let { element, elementId } = fieldDetail;
 
       if (
         !elementIds.includes(elementId) ||
         !FormAutofillUtils.isFieldAutofillable(element)
       ) {
-        continue;
+        if (element.isConnected) {
+          continue;
+        }
+
+        element = this.getReplacedFormElement(element);
+        if (!element) {
+          continue;
+        }
+        fieldDetail = this.#replaceFieldDetail(fieldDetail, element);
       }
 
       element.previewValue = "";
 
+      let filledValue;
       if (FormAutofillUtils.isTextControl(element)) {
         // Bug 1687679: Since profile appears to be presentation ready data, we need to utilize the "x-formatted" field
         // that is generated when presentation ready data doesn't fit into the autofilling element.
@@ -488,11 +528,28 @@ export class FormAutofillHandler {
           element.autofillState == FIELD_STATES.AUTO_FILLED
         ) {
           FormAutofillHandler.fillFieldValue(element, value);
-          this.changeFieldState(fieldDetail, FIELD_STATES.AUTO_FILLED);
+          filledValue = this.verifyFilledValue(
+            fieldDetail,
+            element,
+            value,
+            profile
+          );
+        } else if (isFormChange && element.value == value) {
+          // If this was a fill caused by a form change, and the value is
+          // identical to the expected filled value, highlight it anyway.
+          filledValue = value;
         }
       } else if (HTMLSelectElement.isInstance(element)) {
         const option = this.matchSelectOptions(fieldDetail, profile);
         if (!option) {
+          if (
+            this.getFilledStateByElement(element) == FIELD_STATES.AUTO_FILLED
+          ) {
+            // The select element was previously autofilled, but there
+            // is no matching option under the current set of options anymore.
+            // Changing the state will also remove the highlighting from the element
+            this.changeFieldState(fieldDetail, FIELD_STATES.NORMAL);
+          }
           continue;
         }
 
@@ -503,9 +560,12 @@ export class FormAutofillHandler {
           FormAutofillHandler.fillFieldValue(element, option.value);
         }
         // Autofill highlight appears regardless if value is changed or not
+        filledValue = option.value;
+      }
+
+      if (filledValue) {
         this.changeFieldState(fieldDetail, FIELD_STATES.AUTO_FILLED);
-      } else {
-        continue;
+        filledValuesByElement.set(element, filledValue);
       }
     }
 
@@ -513,6 +573,8 @@ export class FormAutofillHandler {
     this.#isAutofillInProgress = false;
 
     this.registerFormChangeHandler();
+
+    this.reassignValuesIfModified(filledValuesByElement, false);
   }
 
   registerFormChangeHandler() {
@@ -527,6 +589,7 @@ export class FormAutofillHandler {
         return;
       }
       if (e.type == "reset") {
+        this.cancelRefillOnSiteClearingFieldsAction();
         for (const fieldDetail of this.fieldDetails) {
           const element = fieldDetail.element;
           element.removeEventListener("input", this, { mozSystemGroup: true });
@@ -567,6 +630,112 @@ export class FormAutofillHandler {
     });
   }
 
+  verifyFilledValue(fieldDetail, element, value, profile) {
+    if (fieldDetail?.fieldName != "cc-exp" || element.value == value) {
+      return value;
+    }
+
+    // Handle a case where the form uses manual input verification to limit
+    // the expiry field and takes the first two characters of the year rather
+    // than the last two.
+    const month = profile["cc-exp-month"].toString().padStart(2, "0");
+    const year = profile["cc-exp-year"].toString().padStart(4, "0");
+
+    let str = element.value;
+    let match = str.match(
+      new RegExp(`^(${month}\\s*[\\-\\/]?\\s*)${year.substring(0, 2)}\\b`)
+    );
+    if (match) {
+      element.value = match[1] + year.substring(2);
+    } else {
+      match = str.match(
+        new RegExp(`^${year.substring(0, 2)}(\\s*[\\-\\/]?\\s*${month})\\b`)
+      );
+      if (match) {
+        element.value = year.substring(2) + match[1];
+      }
+    }
+
+    return element.value;
+  }
+
+  // If an element is in a form that has been removed, check if there is an
+  // element with the same id and consider that to be a replacement element.
+  // This is done rather than using a mutation observer as an ancestor
+  // element from the form can often be the one removed, and we don't want to
+  // listen to the entire document for changes.
+  getReplacedFormElement(element) {
+    let form = element.form;
+    if (form && !form.isConnected) {
+      let newElement = element.ownerDocument.getElementById(element.id);
+      if (newElement && newElement != element) {
+        return newElement;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * After a refill or clear action, the website might adjust the value of an
+   * element immediately afterwards. If this happens, fill or clear the value
+   * a second time to avoid having elements that are empty but highlighted, or
+   * vice versa.
+   *
+   * @param {Map<HTMLElement,string>} filledValuesByElement
+   * @param {boolean} onClear true for a clear action
+   */
+  reassignValuesIfModified(filledValuesByElement, onClear) {
+    if (!FormAutofill.refillOnSiteClearingFields) {
+      return;
+    }
+
+    this.#refillTimeoutId = lazy.setTimeout(() => {
+      for (let [e, v] of filledValuesByElement) {
+        // If the element is no longer in the document and its form was just removed, check if there
+        // is another element with the same id, as the entire form may have been replaced.
+        if (!e.isConnected && e.id && !e.form?.isConnected) {
+          e = this.getReplacedFormElement(e);
+          if (!e) {
+            continue;
+          }
+        } else if (onClear) {
+          if (e.autofillState != FIELD_STATES.NORMAL || e.value !== v) {
+            // Only reclear if the value was changed back to the original value.
+            continue;
+          }
+        } else if (e.autofillState == FIELD_STATES.NORMAL || e.value) {
+          // Nothing to do if the autofilled value wasn't cleared or the
+          // element's autofill state has changed to NORMAL in the meantime
+          continue;
+        }
+
+        this.#isAutofillInProgress = true;
+        FormAutofillHandler.fillFieldValue(e, onClear ? "" : v, {
+          ignoreFocus: true,
+        });
+        // Although the field should already be in the autofilled state at this point,
+        // still setting autofilled state to re-highlight the element.
+        e.autofillState = onClear
+          ? FIELD_STATES.NORMAL
+          : FIELD_STATES.AUTO_FILLED;
+        this.#isAutofillInProgress = false;
+      }
+
+      this.#refillTimeoutId = null;
+    }, FormAutofill.refillOnSiteClearingFieldsTimeout);
+  }
+
+  cancelRefillOnSiteClearingFieldsAction() {
+    if (!FormAutofill.refillOnSiteClearingFields) {
+      return;
+    }
+    if (this.#refillTimeoutId) {
+      lazy.clearTimeout(this.#refillTimeoutId);
+      this.#refillTimeoutId = null;
+    }
+  }
+
   /**
    * Listens for dynamic form changes by setting up two observer types:
    *      1. IntersectionObserver(s) that observe(s) intersections between
@@ -586,87 +755,93 @@ export class FormAutofillHandler {
     this.setUpFormNodesMutationObserver();
   }
 
-  /**
-   * Iterates through handler.form.elements and sets up an IntersectionObserver for each (in-)visible
-   * address/cc input element that is not observed yet (see handler.#visibilityStateObserverByElement).
-   * The observer notifies of intersections between the (in-)visible element and the intersection target (handler.form).
-   * This is the case if e.g. a visible element becomes invisible or an invisible element becomes visible.
-   * If a visibility state change is observed, a "form-changes" event is dispatched.
-   */
-  setUpElementVisibilityObserver() {
-    const VISIBILITY_STATE = {
-      VISIBLE: true,
-      INVISIBLE: false,
-    };
+  #initializeIntersectionObserver() {
+    this.#visibilityObserver ??= new this.window.IntersectionObserver(
+      (entries, _observer) => {
+        const nowVisible = [];
+        const nowInvisible = [];
+        entries.forEach(entry => {
+          let observedElement = entry.target;
+
+          let oldState =
+            this.#visibilityStateObserverByElement.get(observedElement);
+          let newState = FormAutofillUtils.isFieldVisible(observedElement);
+          if (oldState == newState) {
+            return;
+          }
 
-    // Setting up an observer for an element's changing visibility state
-    const setUpIntersectionObserver = (element, visibilityState) => {
-      const visibilityStateObserver = new this.window.IntersectionObserver(
-        (entries, observer) => {
-          entries.forEach(entry => {
-            if (entry.isIntersecting != visibilityState) {
-              return;
-            }
-            if (
-              entry.target.checkVisibility({
-                checkOpacity: true,
-                checkVisibilityCSS: true,
-              }) != visibilityState
-            ) {
-              // The observer notified that the element reached the intersection threshold
-              // (meaning the element's visibility state changed to either visible or invisible.
-              // But checkVisibility doesn't confirm that.
-              // For these mismatches we disconnect the observer to avoid an infinite loop.
-              observer.disconnect();
-              return;
-            }
-            const changes = {};
-            const reason =
-              visibilityState == VISIBILITY_STATE.VISIBLE
-                ? FORM_CHANGE_REASON.ELEMENT_VISIBLE
-                : FORM_CHANGE_REASON.ELEMENT_INVISIBLE;
-            changes[reason] = [entry.target];
-
-            const formChangedEvent = new CustomEvent("form-changed", {
-              detail: {
-                form: this.form.rootElement,
-                changes,
-              },
-              bubbles: true,
-            });
-            this.form.ownerDocument.dispatchEvent(formChangedEvent);
-
-            this.clearVisibilityStateObserverByElement(element);
-            observer.disconnect();
-          });
-        },
-        {
-          root: this.form.rootElement,
-          // intersection reatio between 0.0 (invisible element) and 1.0 (visible element)
-          threshold: visibilityState === VISIBILITY_STATE.INVISIBLE ? 0 : 1,
+          if (newState) {
+            nowVisible.push(observedElement);
+          } else {
+            nowInvisible.push(observedElement);
+          }
+        });
+
+        if (!nowVisible.length && !nowInvisible.length) {
+          return;
         }
-      );
-      visibilityStateObserver.observe(element);
-      this.setVisibilityStateObserverByElement(
-        element,
-        visibilityStateObserver
-      );
-    };
 
+        let changes = {};
+        if (nowVisible.length) {
+          changes[FORM_CHANGE_REASON.ELEMENT_VISIBLE] = nowVisible;
+        }
+        if (nowInvisible.length) {
+          changes[FORM_CHANGE_REASON.ELEMENT_INVISIBLE] = nowInvisible;
+        }
+
+        // Clear all of the observer state. The notification will add a new
+        // observer if needed.
+        this.#clearVisibilityObserver();
+
+        const formChangedEvent = new CustomEvent("form-changed", {
+          detail: {
+            form: this.form.rootElement,
+            changes,
+          },
+          bubbles: true,
+        });
+        this.form.ownerDocument.dispatchEvent(formChangedEvent);
+      },
+      {
+        root: this.form.rootElement,
+        // intersection ratio between 0.0 (invisible element) and 1.0 (visible element)
+        threshold: [0, 1],
+      }
+    );
+  }
+
+  /**
+   * Sets up an IntersectionObserver to handle each (in-)visible address/cc input element
+   * in a form. The observer notifies of intersections between the (in-)visible element and
+   * the intersection target (handler.form). This is the case if e.g. a visible element becomes
+   * invisible or an invisible element becomes visible. If a visibility state change is observed,
+   * a "form-changes" event is dispatched.
+   */
+  setUpElementVisibilityObserver() {
     for (let element of this.form.elements) {
       if (!FormAutofillUtils.isCreditCardOrAddressFieldType(element)) {
         continue;
       }
-      if (this.isVisiblityStateObserverSetUpByElement(element)) {
+
+      if (this.#visibilityStateObserverByElement.has(element)) {
         continue;
       }
-      if (FormAutofillUtils.isFieldVisible(element)) {
-        // Setting up an observer that notifies when the visible element becomes invisible
-        setUpIntersectionObserver(element, VISIBILITY_STATE.INVISIBLE);
-      } else {
-        // Setting up an observer that notifies when the invisible element becomes visible
-        setUpIntersectionObserver(element, VISIBILITY_STATE.VISIBLE);
+
+      let state = FormAutofillUtils.isFieldVisible(element);
+      if (state) {
+        // We don't care about visibility state changes for fields that are not recognized
+        // by our heuristics. We only handle this for visible fields because we currently
+        // don't run field detection heuristics for invisible fields.
+        const fieldDetail = this.getFieldDetailByElement(element);
+        if (!fieldDetail.fieldName) {
+          continue;
+        }
       }
+
+      this.#initializeIntersectionObserver();
+
+      this.#visibilityObserver.observe(element);
+      this.#visibilityStateObserverByElement.set(element, state);
     }
   }
 
@@ -684,18 +859,21 @@ export class FormAutofillHandler {
     const mutationObserver = new this.window.MutationObserver(
       (mutations, _) => {
         const collectMutatedNodes = mutations => {
-          let removedNodes = [];
-          let addedNodes = [];
+          let removedNodes = new Set();
+          let addedNodes = new Set();
+          let changedSelectElements = new Set();
           mutations.forEach(mutation => {
             if (mutation.type == "childList") {
-              if (mutation.addedNodes.length) {
-                addedNodes.push(...mutation.addedNodes);
+              if (HTMLSelectElement.isInstance(mutation.target)) {
+                changedSelectElements.add(mutation.target);
+              } else if (mutation.addedNodes.length) {
+                addedNodes.add(...mutation.addedNodes);
               } else if (mutation.removedNodes.length) {
-                removedNodes.push(...mutation.removedNodes);
+                removedNodes.add(...mutation.removedNodes);
               }
             }
           });
-          return [addedNodes, removedNodes];
+          return [addedNodes, removedNodes, changedSelectElements];
         };
 
         const collectAllSubtreeElements = node => {
@@ -715,22 +893,35 @@ export class FormAutofillHandler {
             );
         };
 
-        let [addedNodes, removedNodes] = collectMutatedNodes(mutations);
-        let relevantAddedElements = getCCAndAddressElements(addedNodes);
-        // We only care about removed elements that might change the
-        // currently detected fieldDetails
-        let relevantRemovedElements = getCCAndAddressElements(
-          removedNodes
-        ).filter(
+        const [addedNodes, removedNodes, changedSelectElements] =
+          collectMutatedNodes(mutations);
+        let relevantAddedElements = getCCAndAddressElements([...addedNodes]);
+        // We only care about removed elements and changed select options
+        // from the current set of detected fieldDetails
+        let relevantRemovedElements = getCCAndAddressElements([
+          ...removedNodes,
+        ]).filter(
+          element =>
+            this.#fieldDetails && !!this.getFieldDetailByElement(element)
+        );
+        let relevantChangedSelectElements = [...changedSelectElements].filter(
           element =>
             this.#fieldDetails && !!this.getFieldDetailByElement(element)
         );
 
-        if (!relevantRemovedElements.length && !relevantAddedElements.length) {
+        if (
+          !relevantRemovedElements.length &&
+          !relevantAddedElements.length &&
+          !relevantChangedSelectElements.length
+        ) {
           return;
         }
 
         let changes = {};
+        if (relevantChangedSelectElements.length) {
+          changes[FORM_CHANGE_REASON.SELECT_OPTIONS_CHANGED] =
+            relevantChangedSelectElements;
+        }
         if (relevantRemovedElements.length) {
           changes[FORM_CHANGE_REASON.NODES_REMOVED] = relevantRemovedElements;
         }
@@ -764,9 +955,7 @@ export class FormAutofillHandler {
       return;
     }
     // Disconnect intersection observers
-    for (let element of this.form.elements) {
-      this.clearVisibilityStateObserverByElement(element);
-    }
+    this.#clearVisibilityObserver();
     // Disconnect mutation observer
     this.#formMutationObserver.disconnect();
     this.#isObservingFormMutations = false;
@@ -825,29 +1014,6 @@ export class FormAutofillHandler {
     return value;
   }
 
-  /*
-   * Apply both address and credit card related transformers.
-   *
-   * @param {Object} profile
-   *        A profile for adjusting credit card related value.
-   * @override
-   */
-  applyTransformers(profile) {
-    this.addressTransformer(profile);
-    this.telTransformer(profile);
-    this.creditCardExpiryDateTransformer(profile);
-    this.creditCardExpMonthAndYearTransformer(profile);
-    this.creditCardNameTransformer(profile);
-    this.adaptFieldMaxLength(profile);
-  }
-
-  getAdaptedProfiles(originalProfiles) {
-    for (let profile of originalProfiles) {
-      this.applyTransformers(profile);
-    }
-    return originalProfiles;
-  }
-
   /**
    * Match the select option for a field if we autofill with the given profile.
    * This function caches the matching result in the `#matchingSelectionOption`
@@ -872,11 +1038,31 @@ export class FormAutofillHandler {
     }
 
     const cache = this.#matchingSelectOption.get(element) || {};
-    const value = profile[fieldName];
+
+    let value;
+    if (fieldName == "tel-country-code") {
+      // Since some telephone country codes are for multiple countries, search
+      // the options by the country name instead.
+      let countries = lazy.PhoneNumber.FindCountriesForCountryCode(
+        profile[fieldName]
+      );
+      if (countries.length > 1 && countries.includes(profile.country)) {
+        value = profile.country;
+      } else {
+        value = countries[0];
+      }
+    } else {
+      value = profile[fieldName];
+    }
 
     let option = cache[value]?.deref();
-    if (!option) {
-      option = FormAutofillUtils.findSelectOption(element, profile, fieldName);
+    if (!option || !option.isConnected) {
+      option = FormAutofillUtils.findSelectOption(
+        element,
+        profile,
+        fieldName,
+        value
+      );
 
       if (option) {
         cache[value] = new WeakRef(option);
@@ -890,8 +1076,270 @@ export class FormAutofillHandler {
     return option;
   }
 
-  adaptFieldMaxLength(profile) {
-    for (let key in profile) {
+  getAdaptedProfiles(originalProfiles) {
+    for (let profile of originalProfiles) {
+      let transformer = new ProfileTransformer(this, profile);
+      transformer.applyTransformers();
+    }
+    return originalProfiles;
+  }
+
+  /**
+   *
+   * @param {object} fieldDetail A fieldDetail of the related element.
+   * @param {object} profile The profile to fill.
+   * @returns {string} The value to fill for the given field.
+   */
+  getFilledValueFromProfile(fieldDetail, profile) {
+    let value =
+      profile[`${fieldDetail.fieldName}-formatted`] ||
+      profile[fieldDetail.fieldName];
+
+    if (fieldDetail.fieldName == "cc-number" && fieldDetail.part != null) {
+      const part = fieldDetail.part;
+      return value.slice((part - 1) * 4, part * 4);
+    }
+    return value;
+  }
+  /**
+   * Fills the provided element with the specified value.
+   *
+   * @param {HTMLElement} element - The form field element to be filled.
+   * @param {string} value - The value to be filled into the form field.
+   * @param {object} options
+   * @param {boolean} [options.ignoreFocus] - Whether to ignore focusing the field that is filled.
+   *                                          True  - When an autofilled field get's refilled after
+   *                                                  its value was cleared
+   *                                          False - Default
+   */
+  static fillFieldValue(element, value, { ignoreFocus = false } = {}) {
+    // Ignoring to focus the field if it gets refilled (after the site cleared its value),
+    // because it was already focused on the previous autofill action and we want to avoid
+    // re-triggering any event listener callbacks or autocomplete dropdowns
+    if (FormAutofillUtils.focusOnAutofill && !ignoreFocus) {
+      element.focus({ preventScroll: true });
+    }
+    if (FormAutofillUtils.isTextControl(element)) {
+      element.setUserInput(value);
+    } else if (HTMLSelectElement.isInstance(element)) {
+      // Set the value of the select element so that web event handlers can react accordingly
+      element.value = value;
+      element.dispatchEvent(
+        new element.ownerGlobal.Event("input", { bubbles: true })
+      );
+      element.dispatchEvent(
+        new element.ownerGlobal.Event("change", { bubbles: true })
+      );
+    }
+  }
+
+  clearPreviewedFields(elementIds) {
+    for (const elementId of elementIds) {
+      const fieldDetail = this.getFieldDetailByElementId(elementId);
+      const element = fieldDetail?.element;
+      if (!element) {
+        this.log.warn(fieldDetail.fieldName, "is unreachable");
+        continue;
+      }
+
+      element.previewValue = "";
+      if (element.autofillState == FIELD_STATES.AUTO_FILLED) {
+        continue;
+      }
+      this.changeFieldState(fieldDetail, FIELD_STATES.NORMAL);
+    }
+  }
+
+  clearFilledFields(focusedId, elementIds) {
+    this.cancelRefillOnSiteClearingFieldsAction();
+    this.#isAutofillInProgress = true;
+    const fieldDetails = elementIds.map(id =>
+      this.getFieldDetailByElementId(id)
+    );
+
+    const filledValuesByElement = new Map();
+
+    for (const fieldDetail of fieldDetails) {
+      const element = fieldDetail?.element;
+      if (!element) {
+        this.log.warn(fieldDetail?.fieldName, "is unreachable");
+        continue;
+      }
+
+      if (element.autofillState == FIELD_STATES.AUTO_FILLED) {
+        let value = "";
+        if (HTMLSelectElement.isInstance(element)) {
+          if (!element.options.length) {
+            continue;
+          }
+          // Resets a <select> element to its selected option or the first
+          // option if there is none selected.
+          const selected = [...element.options].find(option =>
+            option.hasAttribute("selected")
+          );
+          value = selected ? selected.value : element.options[0].value;
+        } else {
+          filledValuesByElement.set(element, element.value);
+        }
+
+        FormAutofillHandler.fillFieldValue(element, value);
+        this.changeFieldState(fieldDetail, FIELD_STATES.NORMAL);
+      }
+    }
+
+    this.focusPreviouslyFocusedElement(focusedId);
+    this.#isAutofillInProgress = false;
+
+    this.reassignValuesIfModified(filledValuesByElement, true);
+  }
+
+  focusPreviouslyFocusedElement(focusedId) {
+    let focusedElement = FormAutofillUtils.getElementByIdentifier(focusedId);
+    if (FormAutofillUtils.focusOnAutofill && focusedElement) {
+      focusedElement.focus({ preventScroll: true });
+    }
+  }
+
+  /**
+   * Return the record that is keyed by element id and value is the normalized value
+   * done by computeFillingValue
+   *
+   * @returns {object} An object keyed by element id, and the value is
+   *                   an object that includes the following properties:
+   * filledState: The autofill state of the element
+   * filledvalue: The value of the element
+   */
+  collectFormFilledData() {
+    const filledData = new Map();
+
+    for (const fieldDetail of this.fieldDetails) {
+      const element = fieldDetail.element;
+      filledData.set(fieldDetail.elementId, {
+        filledState: element.autofillState,
+        filledValue: this.computeFillingValue(fieldDetail),
+      });
+    }
+    return filledData;
+  }
+
+  isFieldAutofillable(fieldDetail, profile) {
+    if (FormAutofillUtils.isTextControl(fieldDetail.element)) {
+      return !!profile[fieldDetail.fieldName];
+    }
+    return !!this.matchSelectOptions(fieldDetail, profile);
+  }
+}
+
+/**
+ * Apply some transformations to the fields on the profile based
+ *  on the fields that appear in the form. The original values are
+ *  saved and used if the transformer is used again.
+ */
+class ProfileTransformer {
+  // The FormAutofillHandler
+  #handler = null;
+
+  // A profile for adjusting credit card and address related values.
+  #profile = null;
+
+  constructor(handler, profile) {
+    this.#handler = handler;
+    this.#profile = profile;
+  }
+
+  // Get the original unmodified value of a field if it exists.
+  getField(fieldName) {
+    if (this.#profile._original) {
+      let value = this.#profile._original[fieldName];
+      if (value) {
+        return value;
+      }
+    }
+
+    return this.#profile[fieldName];
+  }
+
+  // Get the modified value of a field if it exists, or the
+  // original value.
+  getUpdatedField(fieldName) {
+    return this.#profile[fieldName];
+  }
+
+  // Modify a field's value, but store the original value for
+  // use later.
+  setField(fieldName, value) {
+    let originalValue = this.#profile[fieldName];
+    if (originalValue) {
+      if (!this.#profile._original) {
+        this.#profile._original = {};
+      }
+      if (!this.#profile._original[fieldName]) {
+        this.#profile._original[fieldName] = originalValue;
+      }
+    }
+
+    this.#profile[fieldName] = value;
+  }
+
+  // Delete the modified value of a field, but leave the stored
+  // original value.
+  deleteField(fieldName) {
+    delete this.#profile[fieldName];
+  }
+
+  getFieldDetailByName(fieldName) {
+    return this.#handler.getFieldDetailByName(fieldName);
+  }
+
+  applyTransformers() {
+    this.#addressTransformer();
+    this.#telTransformer();
+    this.#creditCardExpiryDateTransformer();
+    this.#creditCardExpMonthAndYearTransformer();
+    this.#creditCardNameTransformer();
+    this.#addressLevelOneTransformer();
+    this.#adaptFieldMaxLength();
+  }
+
+  /**
+   * Replaces an abbreviated address-level1 code (e.g. "B") with the full
+   * region name (e.g. "Buenos Aires") if the target field is a text input.
+   */
+  #addressLevelOneTransformer() {
+    const fieldName = "address-level1";
+    const fieldDetail = this.getFieldDetailByName(fieldName);
+    if (!fieldDetail || !FormAutofillUtils.isTextControl(fieldDetail.element)) {
+      return;
+    }
+
+    const element = fieldDetail.element;
+    const abbreviatedValue = this.getField(fieldName);
+    const country = this.getField("country");
+
+    const fullSubregionName = FormAutofillUtils.getFullSubregionName(
+      abbreviatedValue,
+      country
+    );
+
+    if (!fullSubregionName || fullSubregionName === abbreviatedValue) {
+      return;
+    }
+
+    // No point in using full subregion name if allowed string length is too small.
+    if (
+      element.maxLength !== -1 &&
+      fullSubregionName.length > element.maxLength
+    ) {
+      return;
+    }
+
+    this.setField(fieldName, fullSubregionName);
+  }
+
+  // This function mostly uses getUpdatedField as it relies on the modified
+  // values of fields from the previous functions.
+  #adaptFieldMaxLength() {
+    for (let key in this.#profile) {
       let detail = this.getFieldDetailByName(key);
       if (!detail || detail.part) {
         continue;
@@ -906,13 +1354,13 @@ export class FormAutofillHandler {
       if (
         maxLength === undefined ||
         maxLength < 0 ||
-        profile[key].toString().length <= maxLength
+        this.getUpdatedField(key).toString().length <= maxLength
       ) {
         continue;
       }
 
       if (maxLength) {
-        switch (typeof profile[key]) {
+        switch (typeof this.getUpdatedField(key)) {
           case "string":
             // If this is an expiration field and our previous
             // adaptations haven't resulted in a string that is
@@ -922,20 +1370,24 @@ export class FormAutofillHandler {
             // form "MMYY" or "MM/YY".
             if (key == "cc-exp" && (maxLength == 4 || maxLength == 5)) {
               const month2Digits = (
-                "0" + profile["cc-exp-month"].toString()
+                "0" + this.getField("cc-exp-month").toString()
               ).slice(-2);
-              const year2Digits = profile["cc-exp-year"].toString().slice(-2);
+              const year2Digits = this.getField("cc-exp-year")
+                .toString()
+                .slice(-2);
               const separator = maxLength == 5 ? "/" : "";
-              profile[key] = `${month2Digits}${separator}${year2Digits}`;
+              this.setField(key, `${month2Digits}${separator}${year2Digits}`);
             } else if (key == "cc-number") {
               // We want to show the last four digits of credit card so that
               // the masked credit card previews correctly and appears correctly
               // in the autocomplete menu
-              profile[key] = profile[key].substr(
-                profile[key].length - maxLength
-              );
+              let value = this.getField(key);
+              this.setField(key, value.substr(value.length - maxLength));
             } else {
-              profile[key] = profile[key].substr(0, maxLength);
+              this.setField(
+                key,
+                this.getUpdatedField(key).substr(0, maxLength)
+              );
             }
             break;
           case "number":
@@ -947,13 +1399,18 @@ export class FormAutofillHandler {
             // The only numbers we store are expiration month/year,
             // and if they truncate, we want the final digits, not
             // the initial ones.
-            profile[key] = profile[key] % Math.pow(10, maxLength);
+            this.setField(
+              key,
+              this.getUpdatedField(key) % Math.pow(10, maxLength)
+            );
             break;
           default:
         }
       } else {
-        delete profile[key];
-        delete profile[`${key}-formatted`];
+        // This code only seems to run when maxlength = 0, an edge case which
+        // hardly seems worth handling.
+        this.deleteField(key);
+        this.deleteField(`${key}-formatted`);
       }
     }
   }
@@ -961,11 +1418,9 @@ export class FormAutofillHandler {
   /**
    * Handles credit card expiry date transformation when
    * the expiry date exists in a cc-exp field.
-   *
-   * @param {object} profile
    */
-  creditCardExpiryDateTransformer(profile) {
-    if (!profile["cc-exp"]) {
+  #creditCardExpiryDateTransformer() {
+    if (!this.getField("cc-exp")) {
       return;
     }
 
@@ -1018,8 +1473,8 @@ export class FormAutofillHandler {
     }
 
     let newExpiryString = null;
-    const month = profile["cc-exp-month"].toString();
-    const year = profile["cc-exp-year"].toString();
+    const month = this.getField("cc-exp-month").toString();
+    const year = this.getField("cc-exp-year").toString();
     if (element.localName == "input") {
       // Use the placeholder or label to determine the expiry string format.
       const possibleExpiryStrings = [];
@@ -1043,16 +1498,17 @@ export class FormAutofillHandler {
 
     // Bug 1688576: Change YYYY-MM to MM/YYYY since MM/YYYY is the
     // preferred presentation format for credit card expiry dates.
-    profile["cc-exp"] = newExpiryString ?? `${month.padStart(2, "0")}/${year}`;
+    this.setField(
+      "cc-exp",
+      newExpiryString ?? `${month.padStart(2, "0")}/${year}`
+    );
   }
 
   /**
    * Handles credit card expiry date transformation when the expiry date exists in
    * the separate cc-exp-month and cc-exp-year fields
-   *
-   * @param {object} profile
    */
-  creditCardExpMonthAndYearTransformer(profile) {
+  #creditCardExpMonthAndYearTransformer() {
     const getInputElementByField = (field, self) => {
       if (!field) {
         return null;
@@ -1067,9 +1523,10 @@ export class FormAutofillHandler {
     const month = getInputElementByField("cc-exp-month", this);
     if (month) {
       // Transform the expiry month to MM since this is a common format needed for filling.
-      profile["cc-exp-month-formatted"] = profile["cc-exp-month"]
-        ?.toString()
-        .padStart(2, "0");
+      this.setField(
+        "cc-exp-month-formatted",
+        this.getField("cc-exp-month")?.toString().padStart(2, "0")
+      );
     }
     const year = getInputElementByField("cc-exp-year", this);
     // If the expiration year element is an input,
@@ -1081,9 +1538,10 @@ export class FormAutofillHandler {
       // Checks for 'YY'|'AA'|'JJ'|'RR' placeholder and converts the year to a two digit string using the last two digits.
       const result = /\b(yy|aa|jj|rr)\b/i.test(placeholder);
       if (result) {
-        profile["cc-exp-year-formatted"] = profile["cc-exp-year"]
-          ?.toString()
-          .substring(2);
+        this.setField(
+          "cc-exp-year-formatted",
+          this.getField("cc-exp-year")?.toString().substring(2)
+        );
       }
     }
   }
@@ -1091,11 +1549,9 @@ export class FormAutofillHandler {
   /**
    * Handles credit card name transformation when the name exists in
    * the separate cc-given-name, cc-middle-name, and cc-family name fields
-   *
-   * @param {object} profile
    */
-  creditCardNameTransformer(profile) {
-    const name = profile["cc-name"];
+  #creditCardNameTransformer() {
+    const name = this.getField("cc-name");
     if (!name) {
       return;
     }
@@ -1106,37 +1562,43 @@ export class FormAutofillHandler {
     if (given || middle || family) {
       const nameParts = lazy.FormAutofillNameUtils.splitName(name);
       if (given && nameParts.given) {
-        profile["cc-given-name"] = nameParts.given;
+        this.setField("cc-given-name", nameParts.given);
       }
       if (middle && nameParts.middle) {
-        profile["cc-middle-name"] = nameParts.middle;
+        this.setField("cc-middle-name", nameParts.middle);
       }
       if (family && nameParts.family) {
-        profile["cc-family-name"] = nameParts.family;
+        this.setField("cc-family-name", nameParts.family);
       }
     }
   }
 
-  addressTransformer(profile) {
-    if (profile["street-address"]) {
+  #addressTransformer() {
+    let streetAddress = this.getField("street-address");
+    if (streetAddress) {
       // "-moz-street-address-one-line" is used by the labels in
       // ProfileAutoCompleteResult.
-      profile["-moz-street-address-one-line"] =
-        FormAutofillUtils.toOneLineAddress(profile["street-address"]);
+      this.setField(
+        "-moz-street-address-one-line",
+        FormAutofillUtils.toOneLineAddress(streetAddress)
+      );
       let streetAddressDetail = this.getFieldDetailByName("street-address");
       if (
         streetAddressDetail &&
         FormAutofillUtils.isTextControl(streetAddressDetail.element)
       ) {
-        profile["street-address"] = profile["-moz-street-address-one-line"];
+        this.setField(
+          "street-address",
+          this.getField("-moz-street-address-one-line")
+        );
       }
 
       let waitForConcat = [];
       for (let f of ["address-line3", "address-line2", "address-line1"]) {
-        waitForConcat.unshift(profile[f]);
+        waitForConcat.unshift(this.getField(f));
         if (this.getFieldDetailByName(f)) {
           if (waitForConcat.length > 1) {
-            profile[f] = FormAutofillUtils.toOneLineAddress(waitForConcat);
+            this.setField(f, FormAutofillUtils.toOneLineAddress(waitForConcat));
           }
           waitForConcat = [];
         }
@@ -1146,15 +1608,27 @@ export class FormAutofillHandler {
     // If a house number field exists, split the address up into house number
     // and street name.
     if (this.getFieldDetailByName("address-housenumber")) {
-      let address = lazy.AddressParser.parseStreetAddress(
-        profile["street-address"]
-      );
-      if (address) {
-        profile["address-housenumber"] = address.street_number;
+      streetAddress = this.getField("street-address");
+      let parsedAddress = lazy.AddressParser.parseStreetAddress(streetAddress);
+      if (parsedAddress) {
         let field = this.getFieldDetailByName("address-line1")
           ? "address-line1"
           : "street-address";
-        profile[field] = address.street_name;
+        this.setField(field, parsedAddress.street_name);
+
+        // If there is a suffix field, fill the house number prefix into the
+        // house number field and the suffix into the suffix field.
+        if (this.getFieldDetailByName("address-extra-housesuffix")) {
+          let houseNumber = this.getField("address-housenumber");
+          let suffix = this.getField("address-extra-housesuffix");
+          if (houseNumber.endsWith(suffix)) {
+            houseNumber = houseNumber.substring(
+              0,
+              houseNumber.length - suffix.length
+            );
+            this.setField("address-housenumber", houseNumber);
+          }
+        }
       }
     }
   }
@@ -1162,12 +1636,11 @@ export class FormAutofillHandler {
   /**
    * Replace tel with tel-national if tel violates the input element's
    * restriction.
-   *
-   * @param {object} profile
-   *        A profile to be converted.
    */
-  telTransformer(profile) {
-    if (!profile.tel || !profile["tel-national"]) {
+  #telTransformer() {
+    let tel = this.getField("tel");
+    let telNational = this.getField("tel-national");
+    if (!tel || !telNational) {
       return;
     }
 
@@ -1186,14 +1659,11 @@ export class FormAutofillHandler {
       return _pattern.test(str);
     };
     if (element.pattern) {
-      if (testPattern(profile.tel)) {
+      if (testPattern(tel)) {
         return;
       }
     } else if (element.maxLength) {
-      if (
-        detail.reason == "autocomplete" &&
-        profile.tel.length <= element.maxLength
-      ) {
+      if (detail.reason == "autocomplete" && tel.length <= element.maxLength) {
         return;
       }
     }
@@ -1205,143 +1675,15 @@ export class FormAutofillHandler {
       // determine which one is better.
       // TODO: [Bug 1407545] This should be improved once more countries are
       // supported.
-      profile.tel = profile["tel-national"];
+      this.setField("tel", telNational);
     } else if (element.pattern) {
-      if (testPattern(profile["tel-national"])) {
-        profile.tel = profile["tel-national"];
+      if (testPattern(telNational)) {
+        this.setField("tel", telNational);
       }
     } else if (element.maxLength) {
-      if (profile["tel-national"].length <= element.maxLength) {
-        profile.tel = profile["tel-national"];
-      }
-    }
-  }
-
-  /**
-   *
-   * @param {object} fieldDetail A fieldDetail of the related element.
-   * @param {object} profile The profile to fill.
-   * @returns {string} The value to fill for the given field.
-   */
-  getFilledValueFromProfile(fieldDetail, profile) {
-    let value =
-      profile[`${fieldDetail.fieldName}-formatted`] ||
-      profile[fieldDetail.fieldName];
-
-    if (fieldDetail.fieldName == "cc-number" && fieldDetail.part != null) {
-      const part = fieldDetail.part;
-      return value.slice((part - 1) * 4, part * 4);
-    }
-    return value;
-  }
-  /**
-   * Fills the provided element with the specified value.
-   *
-   * @param {HTMLElement} element - The form field element to be filled.
-   * @param {string} value - The value to be filled into the form field.
-   */
-  static fillFieldValue(element, value) {
-    if (FormAutofillUtils.focusOnAutofill) {
-      element.focus({ preventScroll: true });
-    }
-    if (FormAutofillUtils.isTextControl(element)) {
-      element.setUserInput(value);
-    } else if (HTMLSelectElement.isInstance(element)) {
-      // Set the value of the select element so that web event handlers can react accordingly
-      element.value = value;
-      element.dispatchEvent(
-        new element.ownerGlobal.Event("input", { bubbles: true })
-      );
-      element.dispatchEvent(
-        new element.ownerGlobal.Event("change", { bubbles: true })
-      );
-    }
-  }
-
-  clearPreviewedFields(elementIds) {
-    for (const elementId of elementIds) {
-      const fieldDetail = this.getFieldDetailByElementId(elementId);
-      const element = fieldDetail?.element;
-      if (!element) {
-        this.log.warn(fieldDetail.fieldName, "is unreachable");
-        continue;
-      }
-
-      element.previewValue = "";
-      if (element.autofillState == FIELD_STATES.AUTO_FILLED) {
-        continue;
-      }
-      this.changeFieldState(fieldDetail, FIELD_STATES.NORMAL);
-    }
-  }
-
-  clearFilledFields(focusedId, elementIds) {
-    this.#isAutofillInProgress = true;
-    const fieldDetails = elementIds.map(id =>
-      this.getFieldDetailByElementId(id)
-    );
-    for (const fieldDetail of fieldDetails) {
-      const element = fieldDetail?.element;
-      if (!element) {
-        this.log.warn(fieldDetail?.fieldName, "is unreachable");
-        continue;
-      }
-
-      if (element.autofillState == FIELD_STATES.AUTO_FILLED) {
-        let value = "";
-        if (HTMLSelectElement.isInstance(element)) {
-          if (!element.options.length) {
-            continue;
-          }
-          // Resets a <select> element to its selected option or the first
-          // option if there is none selected.
-          const selected = [...element.options].find(option =>
-            option.hasAttribute("selected")
-          );
-          value = selected ? selected.value : element.options[0].value;
-        }
-        FormAutofillHandler.fillFieldValue(element, value);
-        this.changeFieldState(fieldDetail, FIELD_STATES.NORMAL);
+      if (telNational.length <= element.maxLength) {
+        this.setField("tel", telNational);
       }
     }
-
-    this.focusPreviouslyFocusedElement(focusedId);
-    this.#isAutofillInProgress = false;
-  }
-
-  focusPreviouslyFocusedElement(focusedId) {
-    let focusedElement = FormAutofillUtils.getElementByIdentifier(focusedId);
-    if (FormAutofillUtils.focusOnAutofill && focusedElement) {
-      focusedElement.focus({ preventScroll: true });
-    }
-  }
-
-  /**
-   * Return the record that is keyed by element id and value is the normalized value
-   * done by computeFillingValue
-   *
-   * @returns {object} An object keyed by element id, and the value is
-   *                   an object that includes the following properties:
-   * filledState: The autofill state of the element
-   * filledvalue: The value of the element
-   */
-  collectFormFilledData() {
-    const filledData = new Map();
-
-    for (const fieldDetail of this.fieldDetails) {
-      const element = fieldDetail.element;
-      filledData.set(fieldDetail.elementId, {
-        filledState: element.autofillState,
-        filledValue: this.computeFillingValue(fieldDetail),
-      });
-    }
-    return filledData;
-  }
-
-  isFieldAutofillable(fieldDetail, profile) {
-    if (FormAutofillUtils.isTextControl(fieldDetail.element)) {
-      return !!profile[fieldDetail.fieldName];
-    }
-    return !!this.matchSelectOptions(fieldDetail, profile);
   }
 }
diff --git a/firefox-ios/Client/Assets/CC_Script/FormAutofillHeuristics.sys.mjs b/firefox-ios/Client/Assets/CC_Script/FormAutofillHeuristics.sys.mjs
index 0953b0e6703db..8f02cd4545a27 100644
--- a/firefox-ios/Client/Assets/CC_Script/FormAutofillHeuristics.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/FormAutofillHeuristics.sys.mjs
@@ -13,7 +13,6 @@ ChromeUtils.defineESModuleGetters(lazy, {
   FieldScanner: "resource://gre/modules/shared/FieldScanner.sys.mjs",
   FormAutofillUtils: "resource://gre/modules/shared/FormAutofillUtils.sys.mjs",
   LabelUtils: "resource://gre/modules/shared/LabelUtils.sys.mjs",
-  MLAutofill: "resource://autofill/MLAutofill.sys.mjs",
 });
 
 /**
@@ -38,6 +37,9 @@ export const FormAutofillHeuristics = {
 
   CREDIT_CARD_FIELDNAMES: [],
   ADDRESS_FIELDNAMES: [],
+
+  useTestYear: null, // set by tests to the current year to use
+
   /**
    * Try to find a contiguous sub-array within an array.
    *
@@ -105,7 +107,7 @@ export const FormAutofillHeuristics = {
     const options = [...element.options];
     // A normal expiration year select should contain at least the last three years
     // in the list.
-    const curYear = new Date().getFullYear();
+    const curYear = this.useTestYear || new Date().getFullYear();
     const desiredValues = Array(3)
       .fill(0)
       .map((v, i) => v + curYear + i);
@@ -122,6 +124,40 @@ export const FormAutofillHeuristics = {
     );
   },
 
+  /**
+   * Return a set of additonal attributes related to a field.
+   *
+   * @param {Element} element
+   *        Form element to examine.
+   * @param {list} fieldNames
+   *        String or list of field names for the element.
+   * @returns {map}
+   *        Returns a map of extra attributes.
+   */
+  parseAdditionalAttributes(element, fieldNames) {
+    let attributes = { isLookup: false };
+    const INTERESTED_FIELDS = [
+      "street-address",
+      "address-line1",
+      "address-line2",
+      "address-line3",
+      "postal-code",
+    ];
+
+    if (typeof fieldNames == "string") {
+      fieldNames = [fieldNames];
+    }
+
+    if (fieldNames?.some(fieldName => INTERESTED_FIELDS.includes(fieldName))) {
+      const regExpLookup = HeuristicsRegExp.getExtraRules("lookup");
+      if (this._matchRegexp(element, regExpLookup)) {
+        attributes.isLookup = true;
+      }
+    }
+
+    return attributes;
+  },
+
   /**
    * This function handles the case when two adjacent fields are incorrectly
    * identified with the same field name. Currently, only given-name and
@@ -160,6 +196,16 @@ export const FormAutofillHeuristics = {
           .length
       ) {
         scanner.updateFieldName(idx - 1, otherFieldName);
+      } else {
+        // If there are two given name or family name fields, yet only one
+        // of the other type of name field, assume that the second field
+        // is meant to be an additional name.
+        let fields = scanner.getFieldsMatching(
+          field => field.fieldName == otherFieldName
+        );
+        if (fields.length == 1) {
+          scanner.updateFieldName(idx, "additional-name");
+        }
       }
 
       scanner.parsingIndex++;
@@ -304,15 +350,25 @@ export const FormAutofillHeuristics = {
       }
     }
 
-    // If the previous parsed field is a "tel" field, run heuristic to see
-    // if the current field is a "tel-extension" field
     const field = scanner.getFieldDetailByIndex(scanner.parsingIndex);
-    if (field && field.reason != "autocomplete") {
+    if (field) {
       const prev = scanner.getFieldDetailByIndex(scanner.parsingIndex - 1);
+
+      // If there is a country code, then the next field should be
+      // 'tel-national' not 'tel'.
       if (
+        prev?.fieldName == "tel-country-code" &&
+        field.fieldName == "tel" &&
+        field.reason != "autocomplete"
+      ) {
+        scanner.updateFieldName(scanner.parsingIndex, "tel-national");
+        scanner.parsingIndex++;
+      } else if (
         prev &&
         lazy.FormAutofillUtils.getCategoryFromFieldName(prev.fieldName) == "tel"
       ) {
+        // If the previous parsed field is a "tel" field, run heuristic to see
+        // if the current field is a "tel-extension" field
         const regExpTelExtension = new RegExp(
           "\\bext|ext\\b|extension|ramal", // pt-BR, pt-PT
           "iug"
@@ -339,6 +395,14 @@ export const FormAutofillHeuristics = {
   _parseHouseNumberFields(scanner, fieldDetail) {
     if (fieldDetail?.fieldName == "address-housenumber") {
       const savedIndex = scanner.parsingIndex;
+
+      // A house number suffix immediately afterwards implies that this
+      // really is a house number field.
+      const detail = scanner.getFieldDetailByIndex(savedIndex + 1);
+      if (detail?.fieldName == "address-extra-housesuffix") {
+        return false;
+      }
+
       for (let idx = 0; !scanner.parsingFinished; idx++) {
         const detail = scanner.getFieldDetailByIndex(idx);
         if (!detail) {
@@ -378,20 +442,25 @@ export const FormAutofillHeuristics = {
     // Store the index of fields that are recognized as 'address-housenumber'
     let houseNumberFields = [];
 
+    // The number of address-related lookup fields found.
+    let lookupFieldsCount = 0;
+
     // We need to build a list of the address fields. A list of the indicies
     // is also needed as the fields with a given name can change positions
     // during the update.
     const fields = [];
     const fieldIndicies = [];
+
     for (let idx = scanner.parsingIndex; !scanner.parsingFinished; idx++) {
       const detail = scanner.getFieldDetailByIndex(idx);
 
       // Skip over any house number fields. There should only be zero or one,
-      // but we'll skip over them all anyway.
+      // but we'll skip over them all anyway. Only check the alternate field
+      // name if it wasn't already changed by an earlier step.
       if (
-        [detail?.fieldName, detail?.alternativeFieldName].includes(
-          "address-housenumber"
-        )
+        detail?.fieldName == "address-housenumber" ||
+        (detail?.reason == "regex-heuristic" &&
+          detail?.alternativeFieldName == "address-housenumber")
       ) {
         houseNumberFields.push(idx);
         continue;
@@ -400,6 +469,13 @@ export const FormAutofillHeuristics = {
       if (!INTERESTED_FIELDS.includes(detail?.fieldName)) {
         break;
       }
+
+      if (detail?.isLookup) {
+        lookupFieldsCount++;
+
+        continue; // Skip address lookup fields
+      }
+
       fields.push(detail);
       fieldIndicies.push(idx);
     }
@@ -444,7 +520,15 @@ export const FormAutofillHeuristics = {
             }
           }
 
-          if (canUpdate) {
+          // If the address-line1 field was not found, we promote `address-line2`
+          // to `address-line1`. If the address-line1 field is a lookup field, we don't
+          // want to promote another field since it does exist but is not fillable.
+          if (
+            canUpdate &&
+            !scanner.getFieldsMatching(
+              field => field.fieldName == "address-line1" && field.isLookup
+            ).length
+          ) {
             scanner.updateFieldName(fieldIndicies[0], "address-line1");
           }
         }
@@ -477,50 +561,51 @@ export const FormAutofillHeuristics = {
     for (const idx of houseNumberFields) {
       scanner.updateFieldName(idx, "address-housenumber");
     }
-    scanner.parsingIndex += fields.length + houseNumberFields.length;
+    scanner.parsingIndex +=
+      fields.length + houseNumberFields.length + lookupFieldsCount;
     return true;
   },
 
   _parseAddressFields(scanner, fieldDetail) {
-    const INTERESTED_FIELDS = ["address-level1", "address-level2"];
+    let fieldFound = false;
 
-    if (!INTERESTED_FIELDS.includes(fieldDetail.fieldName)) {
-      return false;
+    // If there is an address-level3 field but no address-level2 field,
+    // modify to be address-level2.
+    if (
+      fieldDetail.fieldName == "address-level3" &&
+      scanner.getFieldIndexByName("address-level2") == -1
+    ) {
+      scanner.updateFieldName(scanner.parsingIndex, "address-level2");
+      fieldFound = true;
     }
 
-    const fields = [];
-    for (let idx = scanner.parsingIndex; !scanner.parsingFinished; idx++) {
-      const detail = scanner.getFieldDetailByIndex(idx);
-      if (!INTERESTED_FIELDS.includes(detail?.fieldName)) {
-        break;
+    // State & City(address-level2)
+    if (
+      fieldDetail.fieldName == "address-level2" &&
+      scanner.getFieldIndexByName("address-level1") == -1
+    ) {
+      const prev = scanner.getFieldDetailByIndex(scanner.parsingIndex - 1);
+      if (prev && !prev.fieldName && prev.localName == "select") {
+        scanner.updateFieldName(scanner.parsingIndex - 1, "address-level1");
+        scanner.parsingIndex += 1;
+        return true;
+      }
+      const next = scanner.getFieldDetailByIndex(scanner.parsingIndex + 1);
+      if (next && !next.fieldName && next.localName == "select") {
+        scanner.updateFieldName(scanner.parsingIndex + 1, "address-level1");
+        scanner.parsingIndex += 2;
+        return true;
       }
-      fields.push(detail);
-    }
 
-    if (!fields.length) {
-      return false;
+      fieldFound = true;
     }
 
-    // State & City(address-level2)
-    if (fields.length == 1) {
-      if (fields[0].fieldName == "address-level2") {
-        const prev = scanner.getFieldDetailByIndex(scanner.parsingIndex - 1);
-        if (prev && !prev.fieldName && prev.localName == "select") {
-          scanner.updateFieldName(scanner.parsingIndex - 1, "address-level1");
-          scanner.parsingIndex += 1;
-          return true;
-        }
-        const next = scanner.getFieldDetailByIndex(scanner.parsingIndex + 1);
-        if (next && !next.fieldName && next.localName == "select") {
-          scanner.updateFieldName(scanner.parsingIndex + 1, "address-level1");
-          scanner.parsingIndex += 2;
-          return true;
-        }
-      }
+    if (fieldFound) {
+      scanner.parsingIndex++;
+      return true;
     }
 
-    scanner.parsingIndex += fields.length;
-    return true;
+    return false;
   },
 
   /**
@@ -786,13 +871,6 @@ export const FormAutofillHeuristics = {
       lazy.FormAutofillUtils.isCreditCardOrAddressFieldType(element)
     );
 
-    let closestHeaders;
-    let closestButtons;
-    if (FormAutofill.isMLExperimentEnabled && elements.length) {
-      closestHeaders = lazy.MLAutofill.closestHeaderAbove(elements);
-      closestButtons = lazy.MLAutofill.closestButtonBelow(elements);
-    }
-
     const fieldDetails = [];
     for (let idx = 0; idx < elements.length; idx++) {
       const element = elements[idx];
@@ -812,30 +890,14 @@ export const FormAutofillHeuristics = {
       }
 
       const [fieldName, inferInfo] = this.inferFieldInfo(element, elements);
-
-      // For cases where the heuristic has determined the field name without
-      // running Fathom, still run Fathom so we can compare the results between
-      // Fathom and the ML model. Note that this is only enabled when the ML experiment
-      // is enabled.
-      if (
-        FormAutofill.isMLExperimentEnabled &&
-        inferInfo.fathomConfidence == undefined
-      ) {
-        let fields = this._getPossibleFieldNames(element);
-        fields = fields.filter(r => lazy.CreditCardRulesets.types.includes(r));
-        const [label, score] = this.getFathomField(element, fields, elements);
-        inferInfo.fathomLabel = label;
-        inferInfo.fathomConfidence = score;
-      }
+      const attributes = this.parseAdditionalAttributes(element, fieldName);
 
       fieldDetails.push(
         lazy.FieldDetail.create(element, formLike, fieldName, {
           autocompleteInfo: inferInfo.autocompleteInfo,
-          fathomLabel: inferInfo.fathomLabel,
           fathomConfidence: inferInfo.fathomConfidence,
           isVisible,
-          mlHeaderInput: closestHeaders?.[idx] ?? null,
-          mlButtonInput: closestButtons?.[idx] ?? null,
+          isLookup: attributes.isLookup,
         })
       );
     }
@@ -974,7 +1036,7 @@ export const FormAutofillHeuristics = {
    * @returns {Array} - An array containing:
    *                    [0]the inferred field name
    *                    [1]information collected during the inference process. The possible values includes:
-   *                       'autocompleteInfo', 'fathomLabel', and 'fathomConfidence'.
+   *                       'autocompleteInfo' and 'fathomConfidence'.
    */
   inferFieldInfo(element, elements = []) {
     const inferredInfo = {};
@@ -984,7 +1046,8 @@ export const FormAutofillHeuristics = {
     // needs to find the field name.
     if (
       autocompleteInfo?.fieldName &&
-      !["on", "off"].includes(autocompleteInfo.fieldName)
+      !["on", "off"].includes(autocompleteInfo.fieldName) &&
+      !lazy.FormAutofillUtils.isUnsupportedField(autocompleteInfo.fieldName)
     ) {
       inferredInfo.autocompleteInfo = autocompleteInfo;
       return [autocompleteInfo.fieldName, inferredInfo];
@@ -1000,6 +1063,9 @@ export const FormAutofillHeuristics = {
       return ["email", inferredInfo];
     }
 
+    let fathomFoundType;
+    let matchedFieldNames = [];
+
     if (lazy.FormAutofillUtils.isFathomCreditCardsEnabled()) {
       // We don't care fields that are not supported by fathom
       const fathomFields = fields.filter(r =>
@@ -1011,12 +1077,18 @@ export const FormAutofillHeuristics = {
         elements
       );
       if (confidence != null) {
-        inferredInfo.fathomLabel = matchedFieldName;
         inferredInfo.fathomConfidence = confidence;
       }
       // At this point, use fathom's recommendation if it has one
       if (matchedFieldName) {
-        return [matchedFieldName, inferredInfo];
+        // If the name was matched, fall through and try to detect if the
+        // field also matches an address type, which may be a better match.
+        if (matchedFieldName != "cc-name") {
+          return [matchedFieldName, inferredInfo];
+        }
+
+        matchedFieldNames = [matchedFieldName];
+        fathomFoundType = CC_TYPE;
       }
 
       // Continue to run regex-based heuristics even when fathom doesn't recognize
@@ -1062,12 +1134,28 @@ export const FormAutofillHeuristics = {
               countryDisplayNames.includes(option.text)
           )
       ) {
-        return ["country", inferredInfo];
+        // Now that it is likely a country dropdown field, check if it is
+        // a telephone country prefix or a separate country field.
+        return this._findMatchedFieldNames(element, ["tel-country-code"])
+          ?.length
+          ? ["tel-country-code", inferredInfo]
+          : ["country", inferredInfo];
       }
     }
 
     // Find a matched field name using regexp-based heuristics
-    const matchedFieldNames = this._findMatchedFieldNames(element, fields);
+    const heuristicMatchedFieldNames = this._findMatchedFieldNames(
+      element,
+      fields,
+      fathomFoundType
+    );
+    matchedFieldNames.push(...heuristicMatchedFieldNames);
+
+    // If regular expression based heuristics doesn't find any matched field name,
+    // and the input type is "tel", just use "tel" as the field name.
+    if (!matchedFieldNames.length && element.type == "tel") {
+      return ["tel", inferredInfo];
+    }
 
     return [matchedFieldNames, inferredInfo];
   },
@@ -1218,6 +1306,12 @@ export const FormAutofillHeuristics = {
           yield* lazy.LabelUtils.extractLabelStrings(label);
         }
 
+        // If no labels were found, look for nearby text that could
+        // be used as a label.
+        if (!labels.length) {
+          yield lazy.LabelUtils.findNearbyText(element);
+        }
+
         const ariaLabels = element.getAttribute("aria-label");
         if (ariaLabels) {
           yield* [ariaLabels];
@@ -1269,7 +1363,7 @@ export const FormAutofillHeuristics = {
    * @param {Array<string>} fieldNames An array of field names to compare against.
    * @returns {Array} An array of the matching field names.
    */
-  _findMatchedFieldNames(element, fieldNames) {
+  _findMatchedFieldNames(element, fieldNames, foundType = "") {
     if (!fieldNames.length) {
       return [];
     }
@@ -1280,7 +1374,6 @@ export const FormAutofillHeuristics = {
       lazy.FormAutofillUtils.isCreditCardField(name) ? CC_TYPE : ADDR_TYPE,
     ]);
 
-    let foundType;
     let attribute = true;
     let matchedFieldNames = [];
 
diff --git a/firefox-ios/Client/Assets/CC_Script/FormAutofillSection.sys.mjs b/firefox-ios/Client/Assets/CC_Script/FormAutofillSection.sys.mjs
index 4bc28af326c08..350f2a6369807 100644
--- a/firefox-ios/Client/Assets/CC_Script/FormAutofillSection.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/FormAutofillSection.sys.mjs
@@ -83,35 +83,32 @@ export class FormAutofillSection {
     return this.fieldDetails.map(field => field.fieldName);
   }
 
-  /*
+  /**
    * Examine the section is a valid section or not based on its fieldDetails or
    * other information. This method must be overrided.
    *
    * @returns {boolean} True for a valid section, otherwise false
-   *
    */
   isValidSection() {
     throw new TypeError("isValidSection method must be overrided");
   }
 
-  /*
+  /**
    * Examine the section is an enabled section type or not based on its
    * preferences. This method must be overrided.
    *
    * @returns {boolean} True for an enabled section type, otherwise false
-   *
    */
   isEnabled() {
     throw new TypeError("isEnabled method must be overrided");
   }
 
-  /*
+  /**
    * Examine the section is createable for storing the profile. This method
    * must be overrided.
    *
-   * @param {Object} _record The record for examining createable
+   * @param {object} _record The record for examining createable
    * @returns {boolean} True for the record is createable, otherwise false
-   *
    */
   isRecordCreatable(_record) {
     throw new TypeError("isRecordCreatable method must be overridden");
@@ -217,6 +214,32 @@ export class FormAutofillSection {
    */
   static groupFields(fieldDetails) {
     let sections = [];
+
+    // If there is only one duplicate overall, don't split that one field into
+    // a separate section.
+    let foundSectionName = false;
+    let dontAddToNewSections = false;
+    let numDuplicates = 0;
+    let fieldTypes = new Set();
+    for (let i = 0; i < fieldDetails.length; i++) {
+      const cur = fieldDetails[i];
+      // If any field has a section name specified, we should always add to
+      // new sections.
+      if (cur.sectionName) {
+        foundSectionName = true;
+        break;
+      }
+
+      if (cur.isVisible && fieldTypes.has(cur.fieldName)) {
+        numDuplicates++;
+      }
+      fieldTypes.add(cur.fieldName);
+    }
+
+    if (!foundSectionName && numDuplicates <= 1) {
+      dontAddToNewSections = true;
+    }
+
     for (let i = 0; i < fieldDetails.length; i++) {
       const cur = fieldDetails[i];
       const [currentSection] = sections.slice(-1);
@@ -241,36 +264,43 @@ export class FormAutofillSection {
       }
 
       if (candidateSection) {
-        // The field will still be placed in a new section if it is a duplicate of
-        // an existing field, unless it is a duplicate of the previous field. This
-        // allows for fields that might commonly appear twice such as a verification
-        // email field, an invisible field that appears next to the user-visible field,
-        // and simple cases where a page error where a field name is reused twice.
-        let dupIndex = candidateSection.fieldDetails.findIndex(
-          f => f.fieldName == cur.fieldName && f.isVisible && cur.isVisible
-        );
-        let isDuplicate = dupIndex != -1;
-
-        if (isDuplicate) {
-          const [last] = candidateSection.fieldDetails.slice(-1);
-          if (last.fieldName == cur.fieldName) {
-            isDuplicate = false;
-          } else if (
-            lazy.FormAutofillUtils.getCategoryFromFieldName(cur.fieldName) ==
-            "name"
-          ) {
-            // If the duplicate field is in the "name" category (e.g., family-name, given-name),
-            // we check whether all fields starting from the first duplicate also belong to the
-            // name category. If they do, we don't consider the field a duplicate, since name
-            // fields often appear in groups like family-name + given-name.
-            isDuplicate = !candidateSection.fieldDetails
-              .slice(dupIndex)
-              .every(
-                f =>
-                  lazy.FormAutofillUtils.getCategoryFromFieldName(
-                    f.fieldName
-                  ) === "name"
-              );
+        let isDuplicate = false;
+        if (!dontAddToNewSections) {
+          // The field will still be placed in a new section if it is a duplicate of
+          // an existing field, unless it is a duplicate of the previous field. This
+          // allows for fields that might commonly appear twice such as a verification
+          // email field, an invisible field that appears next to the user-visible field,
+          // and simple cases where a page error where a field name is reused twice.
+          let dupIndex = candidateSection.fieldDetails.findIndex(
+            f =>
+              f.fieldName == cur.fieldName &&
+              f.isVisible &&
+              cur.isVisible &&
+              !f.isLookup
+          );
+          isDuplicate = dupIndex != -1;
+
+          if (isDuplicate) {
+            const [last] = candidateSection.fieldDetails.slice(-1);
+            if (last.fieldName == cur.fieldName) {
+              isDuplicate = false;
+            } else if (
+              lazy.FormAutofillUtils.getCategoryFromFieldName(cur.fieldName) ==
+              "name"
+            ) {
+              // If the duplicate field is in the "name" category (e.g., family-name, given-name),
+              // we check whether all fields starting from the first duplicate also belong to the
+              // name category. If they do, we don't consider the field a duplicate, since name
+              // fields often appear in groups like family-name + given-name.
+              isDuplicate = !candidateSection.fieldDetails
+                .slice(dupIndex)
+                .every(
+                  f =>
+                    lazy.FormAutofillUtils.getCategoryFromFieldName(
+                      f.fieldName
+                    ) === "name"
+                );
+            }
           }
         }
 
@@ -333,27 +363,63 @@ export class FormAutofillSection {
     return data;
   }
 
+  shouldAutofillField(fieldDetail) {
+    // We don't save security code, but if somehow the profile has securty code,
+    // make sure we don't autofill it.
+    if (fieldDetail.fieldName == "cc-csc") {
+      return false;
+    }
+
+    // When both visible and invisible elements exist, we only autofill the
+    // visible element.
+    if (!fieldDetail.isVisible) {
+      return !this.fieldDetails.some(
+        field => field.fieldName == fieldDetail.fieldName && field.isVisible
+      );
+    }
+
+    // Only fill a street address lookup field if it is the only street
+    // address related field in this section. Similarly, for postal code
+    // fields.
+    if (fieldDetail.isLookup) {
+      const STREET_FIELDS = [
+        "street-address",
+        "address-line1",
+        "address-line2",
+        "address-line3",
+      ];
+
+      let INTERESTED_FIELDS = [];
+      if (STREET_FIELDS.includes(fieldDetail.fieldName)) {
+        INTERESTED_FIELDS = STREET_FIELDS;
+      } else if (fieldDetail.fieldName == "postal-code") {
+        INTERESTED_FIELDS = ["postal-code"];
+      }
+
+      if (
+        INTERESTED_FIELDS.length &&
+        this.fieldDetails.some(
+          field =>
+            INTERESTED_FIELDS.includes(field.fieldName) &&
+            field.isVisible &&
+            !field.isLookup
+        )
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   /**
    * Heuristics to determine which fields to autofill when a section contains
    * multiple fields of the same type.
    */
   getAutofillFields() {
-    return this.fieldDetails.filter(fieldDetail => {
-      // We don't save security code, but if somehow the profile has securty code,
-      // make sure we don't autofill it.
-      if (fieldDetail.fieldName == "cc-csc") {
-        return false;
-      }
-
-      // When both visible and invisible elements exist, we only autofill the
-      // visible element.
-      if (!fieldDetail.isVisible) {
-        return !this.fieldDetails.some(
-          field => field.fieldName == fieldDetail.fieldName && field.isVisible
-        );
-      }
-      return true;
-    });
+    return this.fieldDetails.filter(fieldDetail =>
+      this.shouldAutofillField(fieldDetail)
+    );
   }
 
   /*
@@ -458,8 +524,7 @@ export class FormAutofillSection {
 
 export class FormAutofillAddressSection extends FormAutofillSection {
   isValidSection() {
-    const fields = new Set(this.fieldDetails.map(f => f.fieldName));
-    return fields.size >= lazy.FormAutofillUtils.AUTOFILL_FIELDS_THRESHOLD;
+    return lazy.FormAutofillUtils.isValidSection(this.fieldDetails);
   }
 
   isEnabled() {
@@ -505,22 +570,16 @@ export class FormAutofillCreditCardSection extends FormAutofillSection {
   /**
    * Determine whether a set of cc fields identified by our heuristics form a
    * valid credit card section.
-   * There are 4 different cases when a field is considered a credit card field
+   * There are 3 different cases when a field is considered a credit card field
    * 1. Identified by autocomplete attribute. ex <input autocomplete="cc-number">
-   * 2. Identified by fathom and fathom is pretty confident (when confidence
-   *    value is higher than `highConfidenceThreshold`)
-   * 3. Identified by fathom. Confidence value is between `fathom.confidenceThreshold`
-   *    and `fathom.highConfidenceThreshold`
-   * 4. Identified by regex-based heurstic. There is no confidence value in thise case.
+   * 2. Identified by fathom.
+   * 3. Identified by regex-based heurstic. There is no confidence value in thise case.
    *
    * A form is considered a valid credit card form when one of the following condition
    * is met:
-   * A. One of the cc field is identified by autocomplete (case 1)
+   * A. One of the cc field is identified by autocomplete (case 1).
    * B. One of the cc field is identified by fathom (case 2 or 3), and there is also
-   *    another cc field found by any of our heuristic (case 2, 3, or 4)
-   * C. Only one cc field is found in the section, but fathom is very confident (Case 2).
-   *    Currently we add an extra restriction to this rule to decrease the false-positive
-   *    rate. See comments below for details.
+   *    another cc field found by any of our heuristic (case 2, 3).
    *
    * @returns {boolean} True for a valid section, otherwise false
    */
@@ -571,14 +630,6 @@ export class FormAutofillCreditCardSection extends FormAutofillSection {
       }
     }
 
-    // Condition C.
-    if (
-      ccNumberDetail?.isOnlyVisibleFieldWithHighConfidence ||
-      ccNameDetail?.isOnlyVisibleFieldWithHighConfidence
-    ) {
-      return true;
-    }
-
     return false;
   }
 
@@ -645,7 +696,6 @@ export class FormAutofillCreditCardSection extends FormAutofillSection {
         result = decrypted ? "success" : "fail_user_canceled";
       } catch (ex) {
         result = "fail_error";
-        throw ex;
       } finally {
         Glean.formautofill.promptShownOsReauth.record({
           trigger: "autofill",
@@ -662,31 +712,10 @@ export class FormAutofillCreditCardSection extends FormAutofillSection {
   }
 
   async getDecryptedString(cipherText, reauth) {
-    if (
-      !lazy.FormAutofillUtils.getOSAuthEnabled(
-        lazy.FormAutofill.AUTOFILL_CREDITCARDS_REAUTH_PREF
-      )
-    ) {
+    if (!lazy.FormAutofillUtils.getOSAuthEnabled()) {
       this.log.debug("Reauth is disabled");
       reauth = false;
     }
-    let string;
-    let errorResult = 0;
-    try {
-      string = await lazy.OSKeyStore.decrypt(cipherText, reauth);
-    } catch (e) {
-      errorResult = e.result;
-      if (e.result != Cr.NS_ERROR_ABORT) {
-        throw e;
-      }
-      this.log.warn("User canceled encryption login");
-    } finally {
-      Glean.creditcard.osKeystoreDecrypt.record({
-        isDecryptSuccess: errorResult === 0,
-        errorResult,
-        trigger: "autofill",
-      });
-    }
-    return string;
+    return await lazy.OSKeyStore.decrypt(cipherText, "formautofill_cc", reauth);
   }
 }
diff --git a/firefox-ios/Client/Assets/CC_Script/FormAutofillUtils.sys.mjs b/firefox-ios/Client/Assets/CC_Script/FormAutofillUtils.sys.mjs
index 2951e720fac6d..277990b9f8b45 100644
--- a/firefox-ios/Client/Assets/CC_Script/FormAutofillUtils.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/FormAutofillUtils.sys.mjs
@@ -27,19 +27,12 @@ ChromeUtils.defineLazyGetter(
     )
 );
 
-XPCOMUtils.defineLazyServiceGetter(
-  lazy,
-  "Crypto",
-  "@mozilla.org/login-manager/crypto/SDR;1",
-  "nsILoginManagerCrypto"
-);
-
 export let FormAutofillUtils;
 
 const ADDRESSES_COLLECTION_NAME = "addresses";
 const CREDITCARDS_COLLECTION_NAME = "creditCards";
-const AUTOFILL_CREDITCARDS_REAUTH_PREF =
-  FormAutofill.AUTOFILL_CREDITCARDS_REAUTH_PREF;
+const AUTOFILL_CREDITCARDS_OS_AUTH_LOCKED_PREF =
+  FormAutofill.AUTOFILL_CREDITCARDS_OS_AUTH_LOCKED_PREF;
 const MANAGE_ADDRESSES_L10N_IDS = [
   "autofill-add-address-title",
   "autofill-manage-addresses-title",
@@ -88,6 +81,10 @@ const EDIT_CREDITCARD_L10N_IDS = [
   "autofill-card-expires-month",
   "autofill-card-expires-year",
   "autofill-card-network",
+
+  // This string isn't ever displayed, but is used to make the payment methods
+  // section easier to find via the search input in about:settings.
+  "autofill-card-search-term-credit-cards",
 ];
 const FIELD_STATES = {
   NORMAL: "",
@@ -122,7 +119,7 @@ FormAutofillUtils = {
 
   ADDRESSES_COLLECTION_NAME,
   CREDITCARDS_COLLECTION_NAME,
-  AUTOFILL_CREDITCARDS_REAUTH_PREF,
+  AUTOFILL_CREDITCARDS_OS_AUTH_LOCKED_PREF,
   MANAGE_ADDRESSES_L10N_IDS,
   EDIT_ADDRESS_L10N_IDS,
   MANAGE_CREDITCARDS_L10N_IDS,
@@ -150,6 +147,9 @@ FormAutofillUtils = {
     // combined they form address-line1
     "address-streetname": "address",
     "address-housenumber": "address",
+    // NL forms often split the suffix from the house number;
+    // for example 35B becomes '35' as the number and 'B' as the suffix.
+    "address-extra-housesuffix": "address",
     "postal-code": "address",
     country: "address",
     "country-name": "address",
@@ -174,6 +174,13 @@ FormAutofillUtils = {
     "cc-csc": "creditCard",
   },
 
+  // This list includes autocomplete attributes that indicate that the field
+  // is an address or credit-card field, but the field name is not one we
+  // currently support for autofill. In these cases, we ignore the field
+  // name so that our heuristic can still classify the field using a
+  // supported field name.
+  _unsupportedFieldNameInfo: ["address-level4"],
+
   _collators: {},
   _reAlternativeCountryNames: {},
 
@@ -187,6 +194,12 @@ FormAutofillUtils = {
     return this._fieldNameInfo?.[fieldName] == "creditCard";
   },
 
+  // Returns true if the field is one we don't fill handle via the autocomplete
+  // attribute. It should be identified using heuristics.
+  isUnsupportedField(fieldName) {
+    return this._unsupportedFieldNameInfo.includes(fieldName);
+  },
+
   isCCNumber(ccNumber) {
     return ccNumber && lazy.CreditCard.isValidNumber(ccNumber);
   },
@@ -198,7 +211,18 @@ FormAutofillUtils = {
     );
   },
 
-  queryEligibleElements(element, includeIframe = false) {
+  isValidSection(fieldDetails) {
+    // If one of the fields has the autocomplete reason, the section is valid.
+    if (fieldDetails.some(f => f.reason == "autocomplete")) {
+      return true;
+    }
+
+    // Otherwise, there must be a minimum number of fields.
+    const fields = new Set(fieldDetails.map(f => f.fieldName));
+    return fields.size >= this.AUTOFILL_FIELDS_THRESHOLD;
+  },
+
+  queryEligibleElements(element, includeIframe = true) {
     const types = includeIframe
       ? [...ELIGIBLE_ELEMENT_TYPES, "iframe"]
       : ELIGIBLE_ELEMENT_TYPES;
@@ -206,65 +230,35 @@ FormAutofillUtils = {
   },
 
   /**
-   * Get the decrypted value for a string pref.
+   * Get whether the OSAuth is enabled or not.
    *
-   * @param {string} prefName -> The pref whose value is needed.
-   * @param {string} safeDefaultValue -> Value to be returned incase the pref is not yet set.
-   * @returns {string}
+   * @returns {boolean} Whether or not OS Auth is enabled.
    */
-  getSecurePref(prefName, safeDefaultValue) {
-    if (Services.prefs.getBoolPref("security.nocertdb", false)) {
+  getOSAuthEnabled() {
+    if (!lazy.OSKeyStore.canReauth()) {
       return false;
     }
-    try {
-      const encryptedValue = Services.prefs.getStringPref(prefName, "");
-      return encryptedValue === ""
-        ? safeDefaultValue
-        : lazy.Crypto.decrypt(encryptedValue);
-    } catch {
-      return safeDefaultValue;
-    }
-  },
 
-  /**
-   * Set the pref to the encrypted form of the value.
-   *
-   * @param {string} prefName -> The pref whose value is to be set.
-   * @param {string} value -> The value to be set in its encrypted form.
-   */
-  setSecurePref(prefName, value) {
-    if (Services.prefs.getBoolPref("security.nocertdb", false)) {
-      return;
-    }
-    if (value) {
-      const encryptedValue = lazy.Crypto.encrypt(value);
-      Services.prefs.setStringPref(prefName, encryptedValue);
-    } else {
-      Services.prefs.clearUserPref(prefName);
-    }
-  },
+    // We need to unlock the pref here to retrieve it's true value, otherwise
+    // the default (false) will be returned.
+    const prefName = AUTOFILL_CREDITCARDS_OS_AUTH_LOCKED_PREF;
+    Services.prefs.unlockPref(prefName);
+    const isEnabled = Services.prefs.getBoolPref(prefName, true);
+    Services.prefs.lockPref(prefName);
 
-  /**
-   * Get whether the OSAuth is enabled or not.
-   *
-   * @param {string} prefName -> The name of the pref (creditcards or addresses)
-   * @returns {boolean}
-   */
-  getOSAuthEnabled(prefName) {
-    return (
-      lazy.OSKeyStore.canReauth() &&
-      this.getSecurePref(prefName, "") !== "opt out"
-    );
+    return isEnabled;
   },
 
   /**
    * Set whether the OSAuth is enabled or not.
    *
-   * @param {string} prefName -> The pref to encrypt.
    * @param {boolean} enable -> Whether the pref is to be enabled.
    */
-  setOSAuthEnabled(prefName, enable) {
-    this.setSecurePref(prefName, enable ? null : "opt out");
+  setOSAuthEnabled(enable) {
+    const prefName = AUTOFILL_CREDITCARDS_OS_AUTH_LOCKED_PREF;
+    Services.prefs.setBoolPref(prefName, enable);
+    Services.prefs.lockPref(prefName);
+    Services.obs.notifyObservers(null, "OSAuthEnabledChange");
   },
 
   async verifyUserOSAuth(
@@ -308,17 +302,6 @@ FormAutofillUtils = {
     return this._fieldNameInfo[fieldName];
   },
 
-  getCategoriesFromFieldNames(fieldNames) {
-    let categories = new Set();
-    for (let fieldName of fieldNames) {
-      let info = this.getCategoryFromFieldName(fieldName);
-      if (info) {
-        categories.add(info);
-      }
-    }
-    return Array.from(categories);
-  },
-
   getCollectionNameFromFieldName(fieldName) {
     return this.isCreditCardField(fieldName)
       ? CREDITCARDS_COLLECTION_NAME
@@ -456,7 +439,9 @@ FormAutofillUtils = {
    * @returns {boolean} true if the element can be autofilled
    */
   isFieldAutofillable(element) {
-    return element && !element.readOnly && !element.disabled;
+    return (
+      element && !element.readOnly && !element.disabled && element.isConnected
+    );
   },
 
   /**
@@ -684,16 +669,26 @@ FormAutofillUtils = {
    */
   buildRegionMapIfAvailable(subKeys, subIsoids, subNames, subLnames) {
     // Not all regions have sub_keys. e.g. DE
-    if (
-      !subKeys ||
-      !subKeys.length ||
-      (!subNames && !subLnames) ||
-      (subNames && subKeys.length != subNames.length) ||
-      (subLnames && subKeys.length != subLnames.length)
-    ) {
+    if (!subKeys?.length) {
       return null;
     }
 
+    let names;
+    if (!subNames && !subLnames) {
+      // Use the keys if sub_names does not exist
+      names = [...subKeys];
+    } else {
+      if (
+        (subNames && subKeys.length != subNames.length) ||
+        (subLnames && subKeys.length != subLnames.length)
+      ) {
+        return null;
+      }
+
+      // Apply sub_lnames if sub_names does not exist
+      names = subNames || subLnames;
+    }
+
     // Overwrite subKeys with subIsoids, when available
     if (subIsoids && subIsoids.length && subIsoids.length == subKeys.length) {
       for (let i = 0; i < subIsoids.length; i++) {
@@ -703,8 +698,6 @@ FormAutofillUtils = {
       }
     }
 
-    // Apply sub_lnames if sub_names does not exist
-    let names = subNames || subLnames;
     return new Map(subKeys.map((key, index) => [key, names[index]]));
   },
 
@@ -796,9 +789,14 @@ FormAutofillUtils = {
     return null;
   },
 
-  findSelectOption(selectEl, record, fieldName) {
+  findSelectOption(selectEl, record, fieldName, value) {
     if (this.isAddressField(fieldName)) {
-      return this.findAddressSelectOption(selectEl.options, record, fieldName);
+      return this.findAddressSelectOption(
+        selectEl.options,
+        record,
+        fieldName,
+        value || record[fieldName]
+      );
     }
     if (this.isCreditCardField(fieldName)) {
       return this.findCreditCardSelectOption(selectEl, record, fieldName);
@@ -831,7 +829,7 @@ FormAutofillUtils = {
         continue;
       }
       // Apply sub_lnames if sub_names does not exist
-      subNames = subNames || subLnames;
+      subNames = subNames || subLnames || subKeys;
 
       let speculatedSubIndexes = [];
       for (const val of values) {
@@ -867,6 +865,53 @@ FormAutofillUtils = {
     return null;
   },
 
+  /**
+   * Attempts to find the full sub-region name from an abbreviated / ISO code,
+   * using the address metadata for the specified country.
+   *
+   * @param   {string} abbreviatedValue A short sub-region code (e.g. "B").
+   * @param   {string} country The country code (e.g. "AR").
+   * @returns {string|null} The full sub-region name (e.g. "Buenos Aires") or null.
+   */
+  getFullSubregionName(abbreviatedValue, country) {
+    if (!abbreviatedValue || !country) {
+      return null;
+    }
+
+    const collators = this.getSearchCollators(country);
+    for (const metadata of this.getCountryAddressDataWithLocales(country)) {
+      const {
+        sub_keys: subKeys,
+        sub_names: subNames,
+        sub_lnames: subLnames,
+        sub_isoids: subIsoids,
+      } = metadata;
+      if (!subKeys) {
+        continue;
+      }
+
+      // Use latin names if available, otherwise use native names.
+      const targetNames = subLnames || subNames || subKeys;
+
+      // Check if the abbreviatedValue matches an ISO ID (e.g. "B") or a key (which may also be an ISO ID).
+      let matchIndex = subKeys.findIndex(key =>
+        this.strCompare(abbreviatedValue, key, collators)
+      );
+
+      if (matchIndex === -1 && subIsoids) {
+        matchIndex = subIsoids.findIndex(isoid =>
+          this.strCompare(abbreviatedValue, isoid, collators)
+        );
+      }
+
+      if (matchIndex !== -1 && targetNames.length > matchIndex) {
+        // Return the full or latin name from the targetNames list at the matching index.
+        return targetNames[matchIndex];
+      }
+    }
+    return null;
+  },
+
   /**
    * Find the option element from select element.
    * 1. Try to find the locale using the country from address.
@@ -877,18 +922,15 @@ FormAutofillUtils = {
    * @param   {Array<{text: string, value: string}>} options
    * @param   {object} address
    * @param   {string} fieldName
+   * @param   {string} value
    * @returns {DOMElement}
    */
-  findAddressSelectOption(options, address, fieldName) {
-    if (options.length > 512) {
+  findAddressSelectOption(options, address, fieldName, value) {
+    if (!value || options.length > 512) {
       // Allow enough space for all countries (roughly 300 distinct values) and all
       // timezones (roughly 400 distinct values), plus some extra wiggle room.
       return null;
     }
-    let value = address[fieldName];
-    if (!value) {
-      return null;
-    }
 
     let collators = this.getSearchCollators(address.country);
 
@@ -919,7 +961,8 @@ FormAutofillUtils = {
             continue;
           }
           // Apply sub_lnames if sub_names does not exist
-          let names = dataset.sub_names || dataset.sub_lnames;
+          let names =
+            dataset.sub_names || dataset.sub_lnames || dataset.sub_keys;
           let isoids = dataset.sub_isoids;
 
           // Go through options one by one to find a match.
@@ -955,6 +998,7 @@ FormAutofillUtils = {
         }
         break;
       }
+      case "tel-country-code":
       case "country": {
         if (this.getCountryAddressData(value)) {
           for (const option of options) {
@@ -965,6 +1009,20 @@ FormAutofillUtils = {
               return option;
             }
           }
+
+          // If the country name was not found, look for an option that
+          // matches the telephone country code next.
+          const countryCode = address["tel-country-code"];
+          if (fieldName == "tel-country-code" && countryCode) {
+            for (const option of options) {
+              if (
+                option.text.includes(countryCode) ||
+                option.value.includes(countryCode)
+              ) {
+                return option;
+              }
+            }
+          }
         }
         break;
       }
@@ -996,7 +1054,12 @@ FormAutofillUtils = {
       menuitem,
     }));
 
-    return this.findAddressSelectOption(options, address, fieldName)?.menuitem;
+    return this.findAddressSelectOption(
+      options,
+      address,
+      fieldName,
+      address[fieldName]
+    )?.menuitem;
   },
 
   findCreditCardSelectOption(selectEl, creditCard, fieldName) {
@@ -1119,7 +1182,7 @@ FormAutofillUtils = {
         ? this.strInclude(value, name, collators)
         : this.strCompare(value, name, collators)
     );
-    if (index === -1) {
+    if (index === -1 && isoids) {
       index = isoids.findIndex(isoid =>
         inexactMatch
           ? this.strInclude(value, isoid, collators)
@@ -1271,7 +1334,8 @@ FormAutofillUtils = {
       ? this.findAddressSelectOption(
           addressLevel1Options,
           record,
-          "address-level1"
+          "address-level1",
+          record["address-level1"]
         )?.value
       : record["address-level1"];
 
@@ -1463,15 +1527,6 @@ XPCOMUtils.defineLazyPreferenceGetter(
   pref => parseFloat(pref)
 );
 
-XPCOMUtils.defineLazyPreferenceGetter(
-  FormAutofillUtils,
-  "ccFathomHighConfidenceThreshold",
-  "extensions.formautofill.creditCards.heuristics.fathom.highConfidenceThreshold",
-  null,
-  null,
-  pref => parseFloat(pref)
-);
-
 XPCOMUtils.defineLazyPreferenceGetter(
   FormAutofillUtils,
   "ccFathomTestConfidence",
diff --git a/firefox-ios/Client/Assets/CC_Script/FormLikeFactory.sys.mjs b/firefox-ios/Client/Assets/CC_Script/FormLikeFactory.sys.mjs
index 3da14260a8bde..6716469824aeb 100644
--- a/firefox-ios/Client/Assets/CC_Script/FormLikeFactory.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/FormLikeFactory.sys.mjs
@@ -80,7 +80,7 @@ export let FormLikeFactory = {
    * "forms" (e.g. registration and login) on one page with a <form>.
    *
    * @param {HTMLElement} aDocumentRoot
-   * @param {Object} aOptions
+   * @param {object} aOptions
    * @param {boolean} [aOptions.ignoreForm = false]
    *        True to always use owner document as the `form`
    * @return {formLike}
@@ -136,7 +136,7 @@ export let FormLikeFactory = {
    *
    * @param {HTMLInputElement|HTMLSelectElement} aField
    *        an <input>, <select> or <iframe> field in a document
-   * @param {Object} aOptions
+   * @param {object} aOptions
    * @param {boolean} [aOptions.ignoreForm = false]
    *        True to always use owner document as the `form`
    * @return {FormLike}
diff --git a/firefox-ios/Client/Assets/CC_Script/Helpers.ios.mjs b/firefox-ios/Client/Assets/CC_Script/Helpers.ios.mjs
index 686c8e2a98395..24832f0bc2ab5 100644
--- a/firefox-ios/Client/Assets/CC_Script/Helpers.ios.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/Helpers.ios.mjs
@@ -5,8 +5,6 @@
 import { IOSAppConstants } from "resource://gre/modules/shared/Constants.ios.mjs";
 import Overrides from "resource://gre/modules/Overrides.ios.js";
 
-const EMPTY_MODULE_PATH = "EmptyModule.sys.mjs";
-
 /* eslint mozilla/use-isInstance: 0 */
 HTMLSelectElement.isInstance = element => element instanceof HTMLSelectElement;
 HTMLInputElement.isInstance = element => element instanceof HTMLInputElement;
@@ -30,13 +28,6 @@ Object.defineProperty(HTMLInputElement.prototype, "hasBeenTypePassword", {
   configurable: true,
 });
 
-Object.defineProperty(HTMLInputElement.prototype, "nodePrincipal", {
-  get() {
-    return { isNullPrincipal: false };
-  },
-  configurable: true,
-});
-
 function setUserInput(value) {
   this.value = value;
 
@@ -109,15 +100,13 @@ const internalModuleResolvers = {
     const moduleName = moduleURI.split("/").pop();
     const modulePath =
       "./" + (Overrides.ModuleOverrides[moduleName] ?? moduleName);
-    return { module: moduleResolver(modulePath), path: modulePath };
+    return moduleResolver(modulePath);
   },
 
   resolveModules(obj, modules) {
     for (const [exportName, moduleURI] of Object.entries(modules)) {
       const resolvedModule = this.resolveModule(moduleURI);
-      obj[exportName] = resolvedModule.path.includes(EMPTY_MODULE_PATH)
-        ? resolvedModule.module?.default
-        : resolvedModule.module?.[exportName];
+      obj[exportName] = resolvedModule?.[exportName];
     }
   },
 };
@@ -158,7 +147,7 @@ export const ChromeUtils = withNotImplementedError({
     internalModuleResolvers.resolveModules(obj, modules);
   },
   importESModule(moduleURI) {
-    return internalModuleResolvers.resolveModule(moduleURI)?.module;
+    return internalModuleResolvers.resolveModule(moduleURI);
   },
 });
 window.ChromeUtils = ChromeUtils;
diff --git a/firefox-ios/Client/Assets/CC_Script/HeuristicsRegExp.sys.mjs b/firefox-ios/Client/Assets/CC_Script/HeuristicsRegExp.sys.mjs
index 054d772cc3573..2bf60d32d90f9 100644
--- a/firefox-ios/Client/Assets/CC_Script/HeuristicsRegExp.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/HeuristicsRegExp.sys.mjs
@@ -7,8 +7,9 @@
 export const HeuristicsRegExp = {
   RULES: {
     email: undefined,
-    tel: undefined,
     "tel-country-code" : undefined,
+    tel: undefined,
+    "address-extra-housesuffix": undefined,
     "address-housenumber": undefined,
     "street-address": undefined,
     "address-line1": undefined,
@@ -49,19 +50,45 @@ export const HeuristicsRegExp = {
     //=========================================================================
     // Firefox-specific rules
     {
-      "address-line1": "addrline1|address_1|addl1",
+      "street-address":
+        "ulica(.*(numer|nr))?" + // pl-PL
+        "|straat", // nl
+      "address-line1": "addrline1|address_1|addl1" +
+        // TODO: Bug 1829583
+        "|(?<neg>nome.*)|endereço", // es
       "address-line2":
         "addrline2|address_2|addl2" +
-        "|landmark", // common in IN
-      "address-line3": "addrline3|address_3|addl3",
-      "address-level2": "città", // it-IT
+		"|landmark" + // common in IN
+		"|complement|interior|interno|dpto", // es-MX
+      "address-line3": "addrline3|address_3|addl3" +
+		"|complement|interior|interno|dpto", // es-MX
+      "address-level2":
+        "città" + // it-IT
+        "|miasto|miejscowosc|miejscowość" + //pl-PL
+        "|\\bstad|woonplaats|plaats" + // nl
+		"|ciudad", // es-MX
       "address-housenumber":
-        "house\\s*number|hausnummer|haus|house[a-z\-]*n(r|o)",
+        "(house|building|street1?)[\\s\\-_]*number|hausnummer|haus|house[a-z\-]*n(r|o)" +
+		"|n[úu]mero(?!\\s*int)|exterior" +
+        "|domu" + // pl-PL
+        "|huisnummer", // nl
+      "address-extra-housesuffix":
+        "toevoeging|toev.?", // nl
       "address-level3":
         "(^address-?level-?3$)" +
         "|neighbou*rhood|barrio|bairro|colonia|suburb", // en/es/pt/mx/au/nz
-      "postal-code": "^PLZ(\\b|\\*)", // de-DE
-      "additional-name": "apellido.?materno|lastlastname",
+      "postal-code":
+        "^PLZ(\\b|\\*)" + // de-DE
+        "|kod.?pocztowy", // pl-PL
+      "given-name":
+        "imię" + // pl-PL
+        "|voornaam", // nl
+      "additional-name":
+        "apellido.?materno|lastlastname" +
+        "|voorletters?|tussenvoegsel", // nl
+      "family-name":
+        "nazwisko" +
+        "|achternaam", // nl
       "cc-name":
         "accountholdername" +
         "|titulaire", // fr-FR
@@ -94,7 +121,12 @@ export const HeuristicsRegExp = {
         "(\\bcvn\\b|\\bcvv\\b|\\bcvc\\b|\\bcsc\\b|\\bcvd\\b|\\bcid\\b|\\bccv\\b)",
       "tel-country-code":
         "phone.*country|country.*phone" +
-        "tel.*country|country.*tel",
+        "|tel.*country|country.*tel" +
+        "|phone(?!-local).*prefix|tel(?!-local).*prefix" +
+        "|prefix.*phone|prefix.*tel",
+      "tel":
+        "(numer|nr)?\\.?telefonu" + //pl-PL
+        "|telefoon", // nl
     },
 
     //=========================================================================
@@ -146,7 +178,7 @@ export const HeuristicsRegExp = {
         "|(^street-?3$)",
 
       "address-level2":
-        "(^city$)" +
+		"(^city$)" +
         "|(^town$)" +
         "|(^address-?level-?2$)" +
         "|(^address-?city$)" +
@@ -367,7 +399,8 @@ export const HeuristicsRegExp = {
 
       // ==== Telephone ====
       tel:
-        "phone|mobile|contact.?number" +
+        "(?<neg>phonetic)" +
+        "|phone|mobile|contact.?number" +
         "|telefonnummer" + // de-DE
         "|telefono|teléfono" + // es
         "|telfixe" + // fr-FR
@@ -421,7 +454,7 @@ export const HeuristicsRegExp = {
       "address-line2":
         "address[_-]?line(2|two)|address2|addr2|street|suite|unit(?!e)" + // Firefox adds `(?!e)` to unit to skip `United State`
         "|adresszusatz|ergänzende.?angaben" + // de-DE
-        "|direccion2|colonia|adicional" + // es
+        "|direccion2|adicional" + // es
         "|addresssuppl|complementnom|appartement" + // fr-FR
         "|indirizzo2" + // it-IT
         "|住所2" + // ja-JP
@@ -433,7 +466,7 @@ export const HeuristicsRegExp = {
       "address-line3":
         "address[_-]?line(3|three)|address3|addr3|street|suite|unit(?!e)" + // Firefox adds `(?!e)` to unit to skip `United State`
         "|adresszusatz|ergänzende.?angaben" + // de-DE
-        "|direccion3|colonia|adicional" + // es
+        "|direccion3|adicional" + // es
         "|addresssuppl|complementnom|appartement" + // fr-FR
         "|indirizzo3" + // it-IT
         "|住所3" + // ja-JP
@@ -446,7 +479,7 @@ export const HeuristicsRegExp = {
         "city|town" +
         "|\\bort\\b|stadt" + // de-DE
         "|suburb" + // en-AU
-        "|ciudad|provincia|localidad|poblacion" + // es
+        "|ciudad|localidad|poblacion" + // es
         "|ville|commune" + // fr-FR
         "|localita" + // it-IT
         "|市区町村" + // ja-JP
@@ -540,7 +573,7 @@ export const HeuristicsRegExp = {
         "|vorname" + // de-DE
         "|nombre" + // es
         "|forename|prénom|prenom" + // fr-FR
-        "|名" + // ja-JP
+        "|(^|[^\\p{L}\\p{N}])名([^\\p{L}\\p{N}]|$)" + // ja-JP
         "|nome" + // pt-BR, pt-PT
         "|Имя" + // ru
         "|نام" + // fa
@@ -597,7 +630,7 @@ export const HeuristicsRegExp = {
         "|月", // zh-CN
 
       "cc-exp-year":
-        "exp|^/|(add)?year" +
+        "exp(?![a-hj-z])|^/|(add)?year" +
         "|ablaufdatum|gueltig|gültig|jahr" + // de-DE
         "|fecha" + // es
         "|scadenza" + // it-IT
@@ -653,13 +686,20 @@ export const HeuristicsRegExp = {
       "address-line2":
         "address|line" +
         "|house|building|apartment|floor" +    // de-DE
-        "|adresse" +      // fr-FR
+        "|apartamento" +    // pt
+        "|adresse|maison|bâtiment|immeuble|appartement|étage" +      // fr-FR
         "|indirizzo" +    // it-IT
         "|地址" +         // zh-CN
-        "|주소",          // ko-KR
+        "|주소" +         // ko-KR
+        "|mieszkan(ie|ia)",         // pl-PL
     },
   ],
 
+  EXTRA_RULES: {
+    "lookup":
+      "lookup|search|suchen",
+  },
+
   _getRules(rules, rulesets) {
     function computeRule(name) {
       let regexps = [];
@@ -670,7 +710,14 @@ export const HeuristicsRegExp = {
           // lower-cased field name and get a rough equivalent of a case-insensitive
           // match. This avoids a performance cliff with the "iu" flag on regular
           // expressions.
-          regexps.push(`(${set[name].toLowerCase()})`.normalize("NFKC"));
+          let pattern = `(${set[name].toLowerCase()})`.normalize("NFKC");
+
+          // We should not lower case the \p{L} & \p{N} parts of the pattern,
+          // revert them back.
+          pattern = pattern.replaceAll("\\p{l}", "\\p{L}");
+          pattern = pattern.replaceAll("\\p{n}", "\\p{N}");
+
+          regexps.push(pattern);
         }
       });
 
@@ -699,6 +746,10 @@ export const HeuristicsRegExp = {
   getRules() {
     return this._getRules(this.RULES, this.RULE_SETS);
   },
+
+  getExtraRules(fieldName) {
+    return new RegExp(this.EXTRA_RULES[fieldName], "iug");
+  }
 };
 
 export default HeuristicsRegExp;
diff --git a/firefox-ios/Client/Assets/CC_Script/LabelUtils.sys.mjs b/firefox-ios/Client/Assets/CC_Script/LabelUtils.sys.mjs
index 50ea73f9b800b..9790e29f6db4e 100644
--- a/firefox-ios/Client/Assets/CC_Script/LabelUtils.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/LabelUtils.sys.mjs
@@ -23,10 +23,9 @@ export const LabelUtils = {
   // @type {Map<string, array>}
   _mappedLabels: null,
 
-  // An array consisting of label elements whose correponding form field doesn't
-  // have an id attribute.
-  // @type {Array<[HTMLLabelElement, HTMLElement]>}
-  _unmappedLabelControls: null,
+  // A map of elements that don't have associated <label> elements but there
+  // is nearby text that can form a label. The values in this map are the text.
+  _mappedText: null,
 
   // A weak map consisting of label element and extracted strings pairs.
   // @type {WeakMap<HTMLLabelElement, array>}
@@ -121,98 +120,157 @@ export const LabelUtils = {
    *           map of form controls that have already potentially matched
    */
   findNextFormControl(element, reverse, potentialLabels) {
-    // Ignore elements and stop searching for elements that are already potentially
-    // labelled or are form elements that cannot be autofilled.
-    while ((element = this.nextElementInOrder(element, reverse))) {
-      if (potentialLabels.has(element)) {
-        break;
-      } else if (
-        lazy.FormAutofillUtils.isCreditCardOrAddressFieldType(element)
-      ) {
-        return element;
-      } else if (
-        [
-          "button",
-          "input",
-          "label",
-          "meter",
-          "output",
-          "progress",
-          "select",
-          "textarea",
-        ].includes(element.localName)
-      ) {
-        break;
+    let filter = e => {
+      // Ignore elements and stop searching for elements that are already
+      // potentially labelled or are form elements that cannot be autofilled.
+      if (e.nodeType == Node.ELEMENT_NODE) {
+        if (potentialLabels.has(e)) {
+          return null;
+        } else if (lazy.FormAutofillUtils.isCreditCardOrAddressFieldType(e)) {
+          // Return this form element.
+          return e;
+        }
+      }
+
+      return false;
+    };
+
+    return this.iterateNodes(element, reverse, filter);
+  },
+
+  /**
+   * Iterate over the nodes in a tree and call the filter on each one. We
+   * don't use an existing iterator (such as a TreeWalker) because we want
+   * to traverse the tree by visting the parents along the way first. The
+   * filter should return exactly false if the node is not accepted and
+   * iteration should continue. Otherwise, the value returned by the filter
+   * is returned. The iteration also stops and returns null if
+   * shouldStopIterating returns true for an element.
+   */
+  iterateNodes(element, reverse, filter) {
+    while (element) {
+      let next = reverse ? element.previousSibling : element.nextSibling;
+      if (!next) {
+        element = element.parentNode;
+        if (element && this.shouldStopIterating(element)) {
+          return null;
+        }
+      } else {
+        let child = next;
+        while (child) {
+          if (filter) {
+            let filterResult = filter(child);
+            if (filterResult !== false) {
+              return filterResult;
+            }
+          }
+
+          if (
+            child.nodeType == Node.ELEMENT_NODE &&
+            this.shouldStopIterating(child)
+          ) {
+            return null;
+          }
+
+          element = child;
+          child = reverse ? child.lastChild : child.firstChild;
+        }
       }
     }
 
     return null;
   },
 
-  nextElementInOrder(element, reverse) {
-    let result = reverse ? element.lastElementChild : element.firstElementChild;
-    if (result) {
-      return result;
+  // Return true if this is a form control or other element where iterating
+  // should stop.
+  shouldStopIterating(element) {
+    return [
+      "button",
+      "input",
+      "label",
+      "meter",
+      "output",
+      "progress",
+      "select",
+      "textarea",
+      "form",
+      "fieldset",
+      "script",
+      "style",
+    ].includes(element.localName);
+  },
+
+  /**
+   * Given an element that doesn't have an associated label, iterate backwards
+   * and find inline text nearby that likely serves as the label.
+   */
+  findNearbyText(element) {
+    if (this._mappedText.has(element)) {
+      return this._mappedText.get(element);
     }
 
-    while (element) {
-      result = reverse
-        ? element.previousElementSibling
-        : element.nextElementSibling;
-      if (result) {
-        return result;
-      }
+    let txt = "";
+    let current = element;
+
+    // A simple guard to prevent searching too far.
+    let count = 10;
 
-      element = element.parentNode;
+    let returnTextNode = node => {
+      // As a shortcut, if text was already found, stop iterating when a
+      // div element was found.
       if (
-        !element ||
-        element.localName == "form" ||
-        element.localName == "fieldset"
+        !count-- ||
+        (current.nodeType == Node.ELEMENT_NODE &&
+          current.localName == "div" &&
+          txt.length)
       ) {
-        break;
+        return null;
+      }
+
+      return node.nodeType == Node.TEXT_NODE ? node : false;
+    };
+
+    while ((current = this.iterateNodes(current, true, returnTextNode))) {
+      let textContent = current.nodeValue;
+      if (textContent) {
+        // Prepend the found text.
+        txt = textContent + txt;
       }
     }
 
-    return null;
+    // Always add the element even where there is no text, so that it isn't
+    // searched for again.
+    txt = txt.replace(/\s{2,}/g, " ").trim(); // Collapse duplicate whitespaces
+    this._mappedText.set(element, txt);
+    return txt;
   },
 
   generateLabelMap(doc) {
     this._mappedLabels = new Map();
-    this._unmappedLabelControls = [];
+    this._mappedText = new Map();
     this._labelStrings = new WeakMap();
 
     // A map of potential label -> control for labels that don't have an id or
     // control associated with them. Labels that have ids or associated controls
     // will be placed in _mappedLabels.
     let potentialLabels = new Map();
-
     for (let label of doc.querySelectorAll("label")) {
-      let id = label.htmlFor;
-      let control;
-      if (!id) {
-        control = label.control;
-        if (!control) {
-          // If the label has no control, look for the next input or select
-          // element in the document and add that to the potentialLabels list.
-          control = this.findAdjacentControl(label, potentialLabels);
-          if (control) {
-            potentialLabels.set(control, label);
-          } else {
-            continue;
-          }
-        }
-        id = control.id;
-      }
-      if (id) {
-        let labels = this._mappedLabels.get(id);
+      let control = label.control;
+      if (control) {
+        const controlId = lazy.FormAutofillUtils.getElementIdentifier(control);
+        let labels = this._mappedLabels.get(controlId);
         if (labels) {
           labels.push(label);
         } else {
-          this._mappedLabels.set(id, [label]);
+          this._mappedLabels.set(controlId, [label]);
         }
       } else {
-        // control must be non-empty here
-        this._unmappedLabelControls.push({ label, control });
+        // If the label has no control, look for the next input or select
+        // element in the document and add that to the potentialLabels list.
+        control = this.findAdjacentControl(label, potentialLabels);
+        if (control) {
+          potentialLabels.set(control, label);
+        }
       }
     }
 
@@ -221,14 +279,9 @@ export const LabelUtils = {
     // control that is nearby even when it has no for attribute or doesn't match an id.
     if (potentialLabels.size) {
       for (let label of potentialLabels) {
-        if (
-          !this._unmappedLabelControls.some(e => e.control == label[0]) &&
-          (!label[1].id || !this._mappedLabels.has(label[1].id))
-        ) {
-          this._unmappedLabelControls.push({
-            label: label[1],
-            control: label[0],
-          });
+        const elementId = lazy.FormAutofillUtils.getElementIdentifier(label[0]);
+        if (!this._mappedLabels.has(elementId)) {
+          this._mappedLabels.set(elementId, [label[1]]);
         }
       }
     }
@@ -236,7 +289,7 @@ export const LabelUtils = {
 
   clearLabelMap() {
     this._mappedLabels = null;
-    this._unmappedLabelControls = null;
+    this._mappedText = null;
     this._labelStrings = null;
   },
 
@@ -245,12 +298,7 @@ export const LabelUtils = {
       this.generateLabelMap(element.ownerDocument);
     }
 
-    let id = element.id;
-    if (!id) {
-      return this._unmappedLabelControls
-        .filter(lc => lc.control == element)
-        .map(lc => lc.label);
-    }
+    let id = lazy.FormAutofillUtils.getElementIdentifier(element);
     return this._mappedLabels.get(id) || [];
   },
 };
diff --git a/firefox-ios/Client/Assets/CC_Script/LoginManager.shared.sys.mjs b/firefox-ios/Client/Assets/CC_Script/LoginManager.shared.sys.mjs
index 049b1d22be6cd..e35d75d7bacbd 100644
--- a/firefox-ios/Client/Assets/CC_Script/LoginManager.shared.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/LoginManager.shared.sys.mjs
@@ -35,107 +35,6 @@ class Logic {
     return placeholder && regex.test(placeholder);
   }
 
-  /**
-   * Infer whether a form is a sign-in form by searching keywords
-   * in its attributes
-   *
-   * @param {Element} element
-   *                  the form we want to check.
-   *
-   * @returns {boolean} True if any of the rules matches
-   */
-  static isInferredLoginForm(formElement) {
-    // This is copied from 'loginFormAttrRegex' in NewPasswordModel.sys.mjs
-    const loginExpr =
-      /login|log in|log on|log-on|sign in|sigin|sign\/in|sign-in|sign on|sign-on/i;
-
-    if (Logic.elementAttrsMatchRegex(formElement, loginExpr)) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Search for keywords that indicates the input field is not likely a
-   * field of a username login form.
-   *
-   * @param {Element} element
-   *                  the input field we want to check.
-   *
-   * @returns {boolean} True if any of the rules matches
-   */
-  static isInferredNonUsernameField(element) {
-    const expr = /\b(search|code|add)\b/i;
-
-    if (
-      Logic.elementAttrsMatchRegex(element, expr) ||
-      Logic.hasLabelMatchingRegex(element, expr)
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Infer whether an input field is a username field by searching
-   * 'username' keyword in its attributes
-   *
-   * @param {Element} element
-   *                  the field we want to check.
-   *
-   * @returns {boolean} True if any of the rules matches
-   */
-  static isInferredUsernameField(element) {
-    const expr = /username/i;
-
-    let ac = element.getAutocompleteInfo()?.fieldName;
-    if (ac && ac == "username") {
-      return true;
-    }
-
-    if (
-      Logic.elementAttrsMatchRegex(element, expr) ||
-      Logic.hasLabelMatchingRegex(element, expr)
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Infer whether an input field is an email field by searching
-   * 'email' keyword in its attributes.
-   *
-   * @param {Element} element
-   *                  the field we want to check.
-   *
-   * @returns {boolean} True if any of the rules matches
-   */
-  static isInferredEmailField(element) {
-    const expr = /email|邮箱/i;
-
-    if (element.type == "email") {
-      return true;
-    }
-
-    let ac = element.getAutocompleteInfo()?.fieldName;
-    if (ac && ac == "email") {
-      return true;
-    }
-
-    if (
-      Logic.elementAttrsMatchRegex(element, expr) ||
-      Logic.hasLabelMatchingRegex(element, expr)
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
   /**
    * Test whether associated labels of the element have the keyword.
    * This is a simplified rule of hasLabelMatchingRegex in NewPasswordModel.sys.mjs
@@ -144,6 +43,10 @@ class Logic {
     return regex.test(element.labels?.[0]?.textContent);
   }
 
+  static hasTextContentMatchingRegex(element, regex) {
+    return regex.test(element.textContent);
+  }
+
   /**
    * Get the parts of the URL we want for identification.
    * Strip out things like the userPass portion and handle javascript:.
@@ -189,11 +92,11 @@ class Logic {
    *
    * @param {Element} element
    *                  the field we want to check.
-   * @param {Object} options
+   * @param {object} options
    * @param {bool} [options.ignoreConnect] - Whether to ignore checking isConnected
    *                                         of the element.
    *
-   * @returns {Boolean} true if the field type is one
+   * @returns {boolean} true if the field type is one
    *                    of the username types.
    */
   static isUsernameFieldType(element, { ignoreConnect = false } = {}) {
@@ -239,11 +142,11 @@ class Logic {
    *
    * @param {Element} element
    *                  the field we want to check.
-   * @param {Object} options
+   * @param {object} options
    * @param {bool} [options.ignoreConnect] - Whether to ignore checking isConnected
    *                                         of the element.
    *
-   * @returns {Boolean} true if the field can
+   * @returns {boolean} true if the field can
    *                    be treated as a password input
    */
   static isPasswordFieldType(element, { ignoreConnect = false } = {}) {
@@ -354,10 +257,11 @@ class Logic {
   /**
    * Transforms the parsed rules returned from PasswordRulesParser into a Map for easier access.
    * The returned Map could have the following keys: "allowed", "required", "maxlength", "minlength", and "max-consecutive"
+   *
    * @example
    * // Returns a Map with a key-value pair of "allowed": "ascii-printable"
    * transformRulesToMap([{ _name: "allowed", value: [{ _name: "ascii-printable" }] }])
-   * @param {Object[]} rules rules from PasswordRulesParser.parsePasswordRules
+   * @param {object[]} rules rules from PasswordRulesParser.parsePasswordRules
    * @return {Map} mapped rules
    */
   static transformRulesToMap(rules) {
diff --git a/firefox-ios/Client/Assets/CC_Script/NewPasswordModel.sys.mjs b/firefox-ios/Client/Assets/CC_Script/NewPasswordModel.sys.mjs
index 142b2e166278b..48b64ea310279 100644
--- a/firefox-ios/Client/Assets/CC_Script/NewPasswordModel.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/NewPasswordModel.sys.mjs
@@ -678,4 +678,7 @@ function makeRuleset(coeffs, biases) {
 export const NewPasswordModel = {
   type: "new",
   rules: makeRuleset([...coefficients.new], biases),
+
+  LoginRegex: loginRegex,
+  LoginFormAttrRegex: loginFormAttrRegex,
 };
diff --git a/firefox-ios/Client/Assets/CC_Script/Overrides.ios.js b/firefox-ios/Client/Assets/CC_Script/Overrides.ios.js
index 0ffbe2a67362d..4ba81d9bd6ad8 100644
--- a/firefox-ios/Client/Assets/CC_Script/Overrides.ios.js
+++ b/firefox-ios/Client/Assets/CC_Script/Overrides.ios.js
@@ -15,9 +15,6 @@ const ModuleOverrides = {
   "FormAutofill.sys.mjs": "FormAutofill.ios.sys.mjs",
   "EntryFile.sys.mjs": "FormAutofillChild.ios.sys.mjs",
   "LoginHelper.sys.mjs": "EmptyModule.sys.mjs",
-  "MLAutofill.sys.mjs": "EmptyModule.sys.mjs",
-  "LoginRecipes.sys.mjs": "EmptyModule.sys.mjs",
-  "Timer.sys.mjs": "TranslationsHelpers.mjs",
 };
 
 // We need this because not all webpack libraries used in iOS are ES Modules
diff --git a/firefox-ios/Client/Assets/CC_Script/PasswordGenerator.sys.mjs b/firefox-ios/Client/Assets/CC_Script/PasswordGenerator.sys.mjs
index 0f2a407cea94e..6ea482a3a9e7b 100644
--- a/firefox-ios/Client/Assets/CC_Script/PasswordGenerator.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/PasswordGenerator.sys.mjs
@@ -43,7 +43,7 @@ DEFAULT_RULES.set(REQUIRED, [UPPER, LOWER, DIGIT, SPECIAL]);
 
 export const PasswordGenerator = {
   /**
-   * @param {Object} options
+   * @param {object} options
    * @param {number} options.length - length of the generated password if there are no rules that override the length
    * @param {Map} options.rules - map of password rules
    * @returns {string} password that was generated
@@ -126,6 +126,7 @@ export const PasswordGenerator = {
 
   /**
    * Adds special characters and/or other required characters to the requiredCharacters array.
+   *
    * @param {Map} rules
    * @param {string[]} requiredClasses
    */
@@ -171,6 +172,7 @@ export const PasswordGenerator = {
 
   /**
    * Shuffle the order of characters in a string.
+   *
    * @param {string} str to shuffle
    * @returns {string} shuffled string
    */
@@ -193,6 +195,7 @@ export const PasswordGenerator = {
    * Determine the number of consecutive characters in a string.
    * This is primarily used to validate the "max-consecutive" rule
    * of a generated password.
+   *
    * @param {string} generatedPassword
    * @param {number} value the number of consecutive characters allowed
    * @return {boolean} `true` if the generatePassword has less than the value argument number of characters, `false` otherwise
diff --git a/firefox-ios/Client/Assets/CC_Script/PhoneNumber.sys.mjs b/firefox-ios/Client/Assets/CC_Script/PhoneNumber.sys.mjs
index 5288765181ab4..53dd91b5b8c37 100644
--- a/firefox-ios/Client/Assets/CC_Script/PhoneNumber.sys.mjs
+++ b/firefox-ios/Client/Assets/CC_Script/PhoneNumber.sys.mjs
@@ -140,6 +140,28 @@ export var PhoneNumber = (function (dataBase) {
     }
   }
 
+  // Given a telephone country code, optionally prefixed with +, return an
+  // array of two-character country codes that use that telephone country
+  // code. For example, '+590' returns ["GP", "BL", "MF"].
+  function FindCountriesForCountryCode(countryCode) {
+    if (countryCode[0] === "+") {
+      countryCode = countryCode.substring(1);
+    }
+
+    let entry = dataBase[countryCode];
+    if (entry) {
+      if (Array.isArray(entry)) {
+        return entry.map(i => i.substr(2, 2));
+      }
+
+      if (typeof entry == "string") {
+        return [entry.substr(2, 2)];
+      }
+    }
+
+    return [];
+  }
+
   // Format a national number for a given region. The boolean flag "intl"
   // indicates whether we want the national or international format.
   function FormatNumber(regionMetaData, number, intl) {
@@ -470,5 +492,6 @@ export var PhoneNumber = (function (dataBase) {
     IsValid: IsValidNumber,
     Parse: ParseNumber,
     FindMetaDataForRegion,
+    FindCountriesForCountryCode,
   };
 })(PHONE_NUMBER_META_DATA);