diff --git a/src/collections/componentSet.ts b/src/collections/componentSet.ts
index 6bb3e28130..bea09a5346 100644
--- a/src/collections/componentSet.ts
+++ b/src/collections/componentSet.ts
@@ -34,6 +34,7 @@ import {
   PackageTypeMembers,
 } from './types';
 import { LazyCollection } from './lazyCollection';
+import { DecodeableMap } from './decodeableMap';
 
 Messages.importMessagesDirectory(__dirname);
 const messages = Messages.loadMessages('@salesforce/source-deploy-retrieve', 'sdr');
@@ -73,14 +74,14 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
   public forceIgnoredPaths?: Set<string>;
   private logger: Logger;
   private registry: RegistryAccess;
-  private components = new Map<string, Map<string, SourceComponent>>();
+  private components = new DecodeableMap<string, DecodeableMap<string, SourceComponent>>();
 
   // internal component maps used by this.getObject() when building manifests.
   private destructiveComponents = {
-    [DestructiveChangesType.PRE]: new Map<string, Map<string, SourceComponent>>(),
-    [DestructiveChangesType.POST]: new Map<string, Map<string, SourceComponent>>(),
+    [DestructiveChangesType.PRE]: new DecodeableMap<string, DecodeableMap<string, SourceComponent>>(),
+    [DestructiveChangesType.POST]: new DecodeableMap<string, DecodeableMap<string, SourceComponent>>(),
   };
-  private manifestComponents = new Map<string, Map<string, SourceComponent>>();
+  private manifestComponents = new DecodeableMap<string, DecodeableMap<string, SourceComponent>>();
 
   private destructiveChangesType = DestructiveChangesType.POST;
 
@@ -112,11 +113,11 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
     return size;
   }
 
-  public get destructiveChangesPre(): Map<string, Map<string, SourceComponent>> {
+  public get destructiveChangesPre(): DecodeableMap<string, DecodeableMap<string, SourceComponent>> {
     return this.destructiveComponents[DestructiveChangesType.PRE];
   }
 
-  public get destructiveChangesPost(): Map<string, Map<string, SourceComponent>> {
+  public get destructiveChangesPost(): DecodeableMap<string, DecodeableMap<string, SourceComponent>> {
     return this.destructiveComponents[DestructiveChangesType.POST];
   }
 
@@ -485,7 +486,7 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
   public add(component: ComponentLike, deletionType?: DestructiveChangesType): void {
     const key = simpleKey(component);
     if (!this.components.has(key)) {
-      this.components.set(key, new Map<string, SourceComponent>());
+      this.components.set(key, new DecodeableMap<string, SourceComponent>());
     }
 
     if (!(component instanceof SourceComponent)) {
@@ -502,12 +503,12 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
       this.logger.debug(`Marking component for delete: ${component.fullName}`);
       const deletions = this.destructiveComponents[deletionType];
       if (!deletions.has(key)) {
-        deletions.set(key, new Map<string, SourceComponent>());
+        deletions.set(key, new DecodeableMap<string, SourceComponent>());
       }
       deletions.get(key)?.set(sourceKey(component), component);
     } else {
       if (!this.manifestComponents.has(key)) {
-        this.manifestComponents.set(key, new Map<string, SourceComponent>());
+        this.manifestComponents.set(key, new DecodeableMap<string, SourceComponent>());
       }
       this.manifestComponents.get(key)?.set(sourceKey(component), component);
     }
@@ -542,10 +543,8 @@ export class ComponentSet extends LazyCollection<MetadataComponent> {
    * @returns `true` if the component is in the set
    */
   public has(component: ComponentLike): boolean {
-    // Compare the component key as is and decoded. Decoding the key before comparing can solve some edge cases
-    // in component fullNames such as Layouts. See: https://github.com/forcedotcom/cli/issues/1683
     const key = simpleKey(component);
-    if (this.components.has(key) || this.components.has(decodeURIComponent(key))) {
+    if (this.components.has(key)) {
       return true;
     }
 
diff --git a/src/collections/decodeableMap.ts b/src/collections/decodeableMap.ts
new file mode 100644
index 0000000000..c73701d0b1
--- /dev/null
+++ b/src/collections/decodeableMap.ts
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2023, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+/**
+ * This is an extension of the Map class that can match keys whether they are encoded or decoded.
+ * Decoding the key can solve some edge cases in component fullNames such as Layouts and Profiles.
+ * See: https://github.com/forcedotcom/cli/issues/1683
+ *
+ * Examples:
+ *
+ * Given a map with entries:
+ * ```javascript
+ * 'layout#Layout__Broker__c-v1.1 Broker Layout' : {...}
+ * 'layout#Layout__Broker__c-v9%2E2 Broker Layout' : {...}
+ * ```
+ *
+ * `decodeableMap.has('layout#Layout__Broker__c-v1%2E1 Broker Layout')` --> returns `true`
+ * `decodeableMap.has('layout#Layout__Broker__c-v9.2 Broker Layout')` --> returns `true`
+ */
+export class DecodeableMap<K extends string, V> extends Map<string, V> {
+  // Internal map of decoded keys to encoded keys.
+  // E.g., { 'foo-v1.3 Layout': 'foo-v1%2E3 Layout' }
+  // This is initialized in the `keysMap` getter due to the constructor calling
+  // `super` before the initialization happens, and it needs to be initialized
+  // before `this.set()` is called or `TypeErrors` will be thrown.
+  private internalkeysMap!: Map<string, string>;
+
+  private get keysMap(): Map<string, string> {
+    if (!this.internalkeysMap) {
+      this.internalkeysMap = new Map();
+    }
+    return this.internalkeysMap;
+  }
+
+  /**
+   * boolean indicating whether an element with the specified key (matching decoded) exists or not.
+   */
+  public has(key: K): boolean {
+    return !!this.getExistingKey(key);
+  }
+
+  /**
+   * Returns a specified element from the Map object. If the value that is associated to
+   * the provided key (matching decoded) is an object, then you will get a reference to
+   * that object and any change made to that object will effectively modify it inside the Map.
+   */
+  public get(key: K): V | undefined {
+    const existingKey = this.getExistingKey(key);
+    return existingKey ? super.get(existingKey) : undefined;
+  }
+
+  /**
+   * Adds a new element with a specified key and value to the Map. If an element with the
+   * same key (encoded or decoded) already exists, the element will be updated.
+   */
+  public set(key: K, value: V): this {
+    return super.set(this.getExistingKey(key, true) ?? key, value);
+  }
+
+  /**
+   * true if an element in the Map existed (matching encoded or decoded key) and has been
+   * removed, or false if the element does not exist.
+   */
+  public delete(key: K): boolean {
+    const existingKey = this.getExistingKey(key);
+    return existingKey ? super.delete(existingKey) : false;
+  }
+
+  // Optimistically looks for an existing key. If the key is not found, detect if the
+  // key is encoded. If encoded, try using the decoded key. If decoded, look for an
+  // encoded entry in the internal map to use for the lookup.
+  private getExistingKey(key: K, setInKeysMap = false): string | undefined {
+    if (super.has(key)) {
+      return key;
+    } else {
+      const decodedKey = decodeURIComponent(key);
+      if (key !== decodedKey) {
+        // The key is encoded; If this is part of a set operation,
+        // set the { decodedKey : encodedKey } in the internal map.
+        if (setInKeysMap) {
+          this.keysMap.set(decodedKey, key);
+        }
+        if (super.has(decodedKey)) {
+          return decodedKey;
+        }
+      } else {
+        const encodedKey = this.keysMap.get(decodedKey);
+        if (encodedKey && super.has(encodedKey)) {
+          return encodedKey;
+        }
+      }
+    }
+  }
+}
diff --git a/test/collections/decodeableMap.test.ts b/test/collections/decodeableMap.test.ts
new file mode 100644
index 0000000000..94dd1ea5ef
--- /dev/null
+++ b/test/collections/decodeableMap.test.ts
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { DecodeableMap } from '../../src/collections/decodeableMap';
+
+describe('DecodeableMap', () => {
+  let dMap: DecodeableMap<string, string>;
+  const layout1_key_encoded = 'Layout-v1%2E1 Layout';
+  const layout1_key_decoded = 'Layout-v1.1 Layout';
+  const layout1_value = 'layout1.1-value';
+  const layout9_key_encoded = 'Layout-v9%2E2 Layout';
+  const layout9_key_decoded = 'Layout-v9.2 Layout';
+  const layout9_value = 'layout9.2-value';
+  const nonExistent_key_decoded = 'Layout-v3.3-MISSING Layout';
+  const nonExistent_key_encoded = 'Layout-v3%2E3-MISSING Layout';
+
+  const sandbox = sinon.createSandbox();
+  let hasMapSpy: sinon.SinonSpy;
+  let getMapSpy: sinon.SinonSpy;
+  let setMapSpy: sinon.SinonSpy;
+  let deleteMapSpy: sinon.SinonSpy;
+
+  beforeEach(() => {
+    dMap = new DecodeableMap([
+      [layout1_key_encoded, layout1_value],
+      [layout9_key_decoded, layout9_value],
+    ]);
+    hasMapSpy = sandbox.spy(Map.prototype, 'has');
+    getMapSpy = sandbox.spy(Map.prototype, 'get');
+    setMapSpy = sandbox.spy(Map.prototype, 'set');
+    deleteMapSpy = sandbox.spy(Map.prototype, 'delete');
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('has()', () => {
+    it('should match an encoded key with a decoded key', () => {
+      expect(dMap.has(layout1_key_decoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout1_key_decoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout1_key_encoded)).to.be.true;
+    });
+
+    it('should match an encoded key with an encoded key', () => {
+      expect(dMap.has(layout1_key_encoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout1_key_encoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout1_key_decoded)).to.be.false;
+    });
+
+    it('should match a decoded key with a decoded key', () => {
+      expect(dMap.has(layout9_key_decoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout9_key_decoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout9_key_encoded)).to.be.false;
+    });
+
+    it('should match a decoded key with an encoded key', () => {
+      expect(dMap.has(layout9_key_encoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout9_key_encoded)).to.be.true;
+      expect(hasMapSpy.calledWith(layout9_key_decoded)).to.be.true;
+    });
+
+    it('should not match on decoded nonexistent key', () => {
+      expect(dMap.has(nonExistent_key_decoded)).to.be.false;
+      expect(hasMapSpy.calledWith(nonExistent_key_decoded)).to.be.true;
+      expect(hasMapSpy.calledWith(nonExistent_key_encoded)).to.be.false;
+    });
+
+    it('should not match on encoded nonexistent key', () => {
+      expect(dMap.has(nonExistent_key_encoded)).to.be.false;
+      expect(hasMapSpy.calledWith(nonExistent_key_encoded)).to.be.true;
+      expect(hasMapSpy.calledWith(nonExistent_key_decoded)).to.be.true;
+    });
+  });
+
+  describe('get()', () => {
+    it('should get value from an encoded key with a decoded key', () => {
+      expect(dMap.get(layout1_key_decoded)).to.equal(layout1_value);
+      expect(getMapSpy.calledWith(layout1_key_decoded)).to.be.true;
+      expect(getMapSpy.calledWith(layout1_key_encoded)).to.be.true;
+    });
+
+    it('should get value from an encoded key with an encoded key', () => {
+      expect(dMap.get(layout1_key_encoded)).to.equal(layout1_value);
+      expect(getMapSpy.calledWith(layout1_key_encoded)).to.be.true;
+      expect(getMapSpy.calledWith(layout1_key_decoded)).to.be.false;
+    });
+
+    it('should get value from a decoded key with a decoded key', () => {
+      expect(dMap.get(layout9_key_decoded)).to.equal(layout9_value);
+      expect(getMapSpy.calledWith(layout9_key_decoded)).to.be.true;
+      expect(getMapSpy.calledWith(layout9_key_encoded)).to.be.false;
+    });
+
+    it('should get value from a decoded key with an encoded key', () => {
+      expect(dMap.get(layout9_key_encoded)).to.equal(layout9_value);
+      expect(getMapSpy.calledWith(layout9_key_encoded)).to.be.false;
+      expect(getMapSpy.calledWith(layout9_key_decoded)).to.be.true;
+    });
+
+    it('should return undefined on decoded nonexistent key', () => {
+      expect(dMap.get(nonExistent_key_decoded)).to.be.undefined;
+      // This is true since it gets from the internal map.
+      expect(getMapSpy.calledWith(nonExistent_key_decoded)).to.be.true;
+      expect(getMapSpy.calledWith(nonExistent_key_encoded)).to.be.false;
+    });
+
+    it('should return undefined on encoded nonexistent key', () => {
+      expect(dMap.get(nonExistent_key_encoded)).to.be.undefined;
+      expect(getMapSpy.calledWith(nonExistent_key_encoded)).to.be.false;
+      expect(getMapSpy.calledWith(nonExistent_key_decoded)).to.be.false;
+    });
+  });
+
+  describe('set()', () => {
+    const NEW_VALUE = 'new value from set';
+
+    it('should update value of decoded key using decoded key', () => {
+      expect(dMap.set(layout9_key_decoded, NEW_VALUE)).to.equal(dMap);
+      expect(setMapSpy.called).to.be.true;
+      expect(setMapSpy.lastCall.args[0]).to.equal(layout9_key_decoded);
+      expect(setMapSpy.lastCall.args[1]).to.equal(NEW_VALUE);
+      expect(dMap.size).to.equal(2);
+      expect(dMap.get(layout9_key_decoded)).to.equal(NEW_VALUE);
+      // @ts-ignore testing private map. expect 1 for initial map creation
+      expect(dMap.keysMap.size).to.equal(1);
+    });
+
+    it('should update value of decoded key using encoded key', () => {
+      expect(dMap.set(layout9_key_encoded, NEW_VALUE)).to.equal(dMap);
+      expect(setMapSpy.called).to.be.true;
+      expect(setMapSpy.lastCall.args[0]).to.equal(layout9_key_decoded);
+      expect(setMapSpy.lastCall.args[1]).to.equal(NEW_VALUE);
+      expect(dMap.size).to.equal(2);
+      expect(dMap.get(layout9_key_encoded)).to.equal(NEW_VALUE);
+      // @ts-ignore testing private map. expect 2 for initial map creation and addition
+      expect(dMap.keysMap.size).to.equal(2);
+      // @ts-ignore testing private map
+      expect(dMap.keysMap.get(layout9_key_decoded)).to.equal(layout9_key_encoded);
+    });
+
+    it('should update value of encoded key using encoded key', () => {
+      expect(dMap.set(layout1_key_encoded, NEW_VALUE)).to.equal(dMap);
+      expect(setMapSpy.called).to.be.true;
+      expect(setMapSpy.lastCall.args[0]).to.equal(layout1_key_encoded);
+      expect(setMapSpy.lastCall.args[1]).to.equal(NEW_VALUE);
+      expect(dMap.size).to.equal(2);
+      expect(dMap.get(layout1_key_encoded)).to.equal(NEW_VALUE);
+      // @ts-ignore testing private map. expect 1 for initial map creation
+      expect(dMap.keysMap.size).to.equal(1);
+    });
+
+    it('should update value of encoded key using decoded key', () => {
+      expect(dMap.set(layout1_key_decoded, NEW_VALUE)).to.equal(dMap);
+      expect(setMapSpy.called).to.be.true;
+      expect(setMapSpy.lastCall.args[0]).to.equal(layout1_key_encoded);
+      expect(setMapSpy.lastCall.args[1]).to.equal(NEW_VALUE);
+      expect(dMap.size).to.equal(2);
+      expect(dMap.get(layout1_key_encoded)).to.equal(NEW_VALUE);
+      // @ts-ignore testing private map. expect 1 for initial map creation
+      expect(dMap.keysMap.size).to.equal(1);
+    });
+
+    it('should set new entry on decoded nonexistent key', () => {
+      expect(dMap.set(nonExistent_key_decoded, NEW_VALUE)).to.equal(dMap);
+      expect(setMapSpy.called).to.be.true;
+      expect(setMapSpy.lastCall.args[0]).to.equal(nonExistent_key_decoded);
+      expect(setMapSpy.lastCall.args[1]).to.equal(NEW_VALUE);
+      expect(dMap.size).to.equal(3);
+      expect(dMap.get(nonExistent_key_decoded)).to.equal(NEW_VALUE);
+      // @ts-ignore testing private map. expect 1 for initial map creation
+      expect(dMap.keysMap.size).to.equal(1);
+    });
+
+    it('should set new entry on encoded nonexistent key', () => {
+      expect(dMap.set(nonExistent_key_encoded, NEW_VALUE)).to.equal(dMap);
+      expect(setMapSpy.called).to.be.true;
+      expect(setMapSpy.lastCall.args[0]).to.equal(nonExistent_key_encoded);
+      expect(setMapSpy.lastCall.args[1]).to.equal(NEW_VALUE);
+      expect(dMap.size).to.equal(3);
+      expect(dMap.get(nonExistent_key_encoded)).to.equal(NEW_VALUE);
+      // @ts-ignore testing private map. expect 2 for initial map creation and addition
+      expect(dMap.keysMap.size).to.equal(2);
+      // @ts-ignore testing private map
+      expect(dMap.keysMap.get(nonExistent_key_decoded)).to.equal(nonExistent_key_encoded);
+    });
+  });
+
+  describe('delete()', () => {
+    it('should delete an encoded key with a decoded key', () => {
+      expect(dMap.delete(layout1_key_decoded)).to.be.true;
+      expect(deleteMapSpy.calledOnce).to.be.true;
+      expect(deleteMapSpy.firstCall.args[0]).to.equal(layout1_key_encoded);
+      expect(dMap.size).to.equal(1);
+      expect(dMap.has(layout1_key_decoded)).to.be.false;
+    });
+
+    it('should delete an encoded key with an encoded key', () => {
+      expect(dMap.delete(layout1_key_encoded)).to.be.true;
+      expect(deleteMapSpy.calledOnce).to.be.true;
+      expect(deleteMapSpy.firstCall.args[0]).to.equal(layout1_key_encoded);
+      expect(dMap.size).to.equal(1);
+      expect(dMap.has(layout1_key_encoded)).to.be.false;
+    });
+
+    it('should delete a decoded key with a decoded key', () => {
+      expect(dMap.delete(layout9_key_decoded)).to.be.true;
+      expect(deleteMapSpy.calledOnce).to.be.true;
+      expect(deleteMapSpy.firstCall.args[0]).to.equal(layout9_key_decoded);
+      expect(dMap.size).to.equal(1);
+      expect(dMap.has(layout9_key_decoded)).to.be.false;
+    });
+
+    it('should delete a decoded key with an encoded key', () => {
+      expect(dMap.delete(layout9_key_encoded)).to.be.true;
+      expect(deleteMapSpy.calledOnce).to.be.true;
+      expect(deleteMapSpy.firstCall.args[0]).to.equal(layout9_key_decoded);
+      expect(dMap.size).to.equal(1);
+      expect(dMap.has(layout9_key_encoded)).to.be.false;
+    });
+
+    it('should not delete a decoded nonexistent key', () => {
+      expect(dMap.delete(nonExistent_key_decoded)).to.be.false;
+      expect(deleteMapSpy.called).to.be.false;
+      expect(dMap.size).to.equal(2);
+      expect(dMap.has(nonExistent_key_decoded)).to.be.false;
+    });
+
+    it('should not delete an encoded nonexistent key', () => {
+      expect(dMap.delete(nonExistent_key_encoded)).to.be.false;
+      expect(deleteMapSpy.called).to.be.false;
+      expect(dMap.size).to.equal(2);
+      expect(dMap.has(nonExistent_key_encoded)).to.be.false;
+    });
+  });
+});