diff --git a/button/internal/button.ts b/button/internal/button.ts
index a07e922d85..70469e3411 100644
--- a/button/internal/button.ts
+++ b/button/internal/button.ts
@@ -14,14 +14,17 @@ import {html as staticHtml, literal} from 'lit/static-html.js';
 
 import {ARIAMixinStrict} from '../../internal/aria/aria.js';
 import {requestUpdateOnAriaChange} from '../../internal/aria/delegate.js';
-import {dispatchActivationClick, isActivationClick, redispatchEvent} from '../../internal/controller/events.js';
+import {internals} from '../../internal/controller/element-internals.js';
+import {dispatchActivationClick, isActivationClick} from '../../internal/controller/events.js';
+import {FormSubmitter, FormSubmitterType, setupFormSubmitter} from '../../internal/controller/form-submitter.js';
 
 /**
  * A button component.
  */
-export abstract class Button extends LitElement {
+export abstract class Button extends LitElement implements FormSubmitter {
   static {
     requestUpdateOnAriaChange(Button);
+    setupFormSubmitter(Button);
   }
 
   /** @nocollapse */
@@ -62,28 +65,17 @@ export abstract class Button extends LitElement {
    */
   @property({type: Boolean, attribute: 'has-icon'}) hasIcon = false;
 
-  /**
-   * A string indicating the behavior of the button.
-   *
-   * - submit: The button submits the form. This is the default value if the
-   * attribute is not specified, or if it is dynamically changed to an empty or
-   * invalid value.
-   * - reset: The button resets the form.
-   * - button: The button does nothing.
-   */
-  @property() type: 'button'|'submit'|'reset' = 'submit';
+  @property() type: FormSubmitterType = 'submit';
 
   @query('.button') private readonly buttonElement!: HTMLElement|null;
 
   @queryAssignedElements({slot: 'icon', flatten: true})
   private readonly assignedIcons!: HTMLElement[];
 
-  private readonly internals =
+  /** @private */
+  [internals] =
       (this as HTMLElement /* needed for closure */).attachInternals();
 
-  // flag to avoid processing redispatched event.
-  private isRedispatchingEvent = false;
-
   constructor() {
     super();
     if (!isServer) {
@@ -115,7 +107,6 @@ export abstract class Button extends LitElement {
         aria-expanded="${ariaExpanded || nothing}"
         href=${this.href || nothing}
         target=${this.target || nothing}
-        @click="${this.handleClick}"
       >
         ${this.renderFocusRing()}
         ${this.renderElevation()}
@@ -183,43 +174,6 @@ export abstract class Button extends LitElement {
         this.handleSlotChange}"></slot>`;
   }
 
-  private handleClick(event: MouseEvent) {
-    if (this.isRedispatchingEvent) {
-      return;
-    }
-    // based on type, trigger form action.
-    const {type, internals: {form}} = this;
-    if (!form || type === 'button') {
-      return;
-    }
-
-    this.isRedispatchingEvent = true;
-    const prevented = !redispatchEvent(this, event);
-    this.isRedispatchingEvent = false;
-    if (prevented) {
-      return;
-    }
-
-    if (type === 'reset') {
-      form.reset();
-      return;
-    }
-
-    // form.requestSubmit(submitter) does not work with form associated custom
-    // elements. This patches the dispatched submit event to add the correct
-    // `submitter`.
-    // See https://github.com/WICG/webcomponents/issues/814
-    form.addEventListener('submit', submitEvent => {
-      Object.defineProperty(submitEvent, 'submitter', {
-        configurable: true,
-        enumerable: true,
-        get: () => this,
-      });
-    }, {capture: true, once: true});
-
-    form.requestSubmit();
-  }
-
   private handleSlotChange() {
     this.hasIcon = this.assignedIcons.length > 0;
   }
diff --git a/button/internal/button_test.ts b/button/internal/button_test.ts
deleted file mode 100644
index 7cac337d69..0000000000
--- a/button/internal/button_test.ts
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- * @license
- * Copyright 2023 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-// import 'jasmine'; (google3-only)
-
-import {html} from 'lit';
-
-import {Environment} from '../../testing/environment.js';
-import {ButtonHarness} from '../harness.js';
-
-import {Button} from './button.js';
-
-customElements.define('test-button', class extends Button {});
-
-describe('Button', () => {
-  const env = new Environment();
-  describe('form associated', () => {
-    async function setupTest() {
-      const root = env.render(html`<form><test-button></test-button></form>`);
-      const element = root.querySelector<Button>('test-button');
-      if (!element) {
-        throw new Error(`Could not query rendered <test-button>`);
-      }
-      const form = root.querySelector('form');
-      if (!form) throw new Error(`Could not query form`);
-
-      await env.waitForStability();
-
-      return {harness: new ButtonHarness(element), form};
-    }
-
-    it('button is submit type by default', async () => {
-      const {harness} = await setupTest();
-      expect(harness.element.type).toBe('submit');
-    });
-
-    it('button with type submit can submit a form', async () => {
-      const {harness, form} = await setupTest();
-      harness.element.type = 'submit';
-
-      spyOn(form, 'requestSubmit');
-      spyOn(form, 'reset');
-      await harness.clickWithMouse();
-
-      expect(form.requestSubmit).toHaveBeenCalled();
-      expect(form.reset).not.toHaveBeenCalled();
-    });
-
-    it('button with type reset can reset a form', async () => {
-      const {harness, form} = await setupTest();
-      harness.element.type = 'reset';
-
-      spyOn(form, 'requestSubmit');
-      spyOn(form, 'reset');
-      await harness.clickWithMouse();
-
-      expect(form.requestSubmit).not.toHaveBeenCalled();
-      expect(form.reset).toHaveBeenCalled();
-    });
-
-    it('submit can be cancelled with preventDefault', async () => {
-      const {harness, form} = await setupTest();
-      harness.element.type = 'submit';
-
-      spyOn(form, 'requestSubmit');
-
-      harness.element.addEventListener('click', (event: Event) => {
-        event.preventDefault();
-      }, {once: true});
-
-      await harness.clickWithMouse();
-
-      expect(form.requestSubmit).not.toHaveBeenCalled();
-    });
-
-    it('should set the button as the SubmitEvent submitter', async () => {
-      const {harness, form} = await setupTest();
-      const submitListener =
-          jasmine.createSpy('submitListener').and.callFake((event: Event) => {
-            event.preventDefault();
-          });
-
-      form.addEventListener('submit', submitListener);
-
-      await harness.clickWithMouse();
-
-      expect(submitListener).toHaveBeenCalled();
-      const event = submitListener.calls.argsFor(0)[0] as SubmitEvent;
-      expect(event.submitter)
-          .withContext('event.submitter')
-          .toBe(harness.element);
-    });
-  });
-});
diff --git a/iconbutton/internal/icon-button.ts b/iconbutton/internal/icon-button.ts
index 5ac459c0ac..0fedd043bd 100644
--- a/iconbutton/internal/icon-button.ts
+++ b/iconbutton/internal/icon-button.ts
@@ -14,14 +14,22 @@ import {html as staticHtml, literal} from 'lit/static-html.js';
 
 import {ARIAMixinStrict} from '../../internal/aria/aria.js';
 import {requestUpdateOnAriaChange} from '../../internal/aria/delegate.js';
+import {internals} from '../../internal/controller/element-internals.js';
+import {FormSubmitter, FormSubmitterType, setupFormSubmitter} from '../../internal/controller/form-submitter.js';
 import {isRtl} from '../../internal/controller/is-rtl.js';
 
 type LinkTarget = '_blank'|'_parent'|'_self'|'_top';
 
 // tslint:disable-next-line:enforce-comments-on-exported-symbols
-export class IconButton extends LitElement {
+export class IconButton extends LitElement implements FormSubmitter {
   static {
     requestUpdateOnAriaChange(IconButton);
+    setupFormSubmitter(IconButton);
+  }
+
+  /** @nocollapse */
+  static get formAssociated() {
+    return true;
   }
 
   /** @nocollapse */
@@ -68,8 +76,14 @@ export class IconButton extends LitElement {
    */
   @property({type: Boolean, reflect: true}) selected = false;
 
+  @property() type: FormSubmitterType = 'submit';
+
   @state() private flipIcon = isRtl(this, this.flipIconInRtl);
 
+  /** @private */
+  [internals] =
+      (this as HTMLElement /* needed for closure */).attachInternals();
+
   /**
    * Link buttons cannot be disabled.
    */
diff --git a/internal/controller/element-internals.ts b/internal/controller/element-internals.ts
new file mode 100644
index 0000000000..3cdc3ca59c
--- /dev/null
+++ b/internal/controller/element-internals.ts
@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * A unique symbol used for protected access to an instance's
+ * `ElementInternals`.
+ *
+ * @example
+ * ```ts
+ * class MyElement extends LitElement {
+ *   static formAssociated = true;
+ *
+ *   [internals] = this.attachInternals();
+ * }
+ *
+ * function getForm(element: MyElement) {
+ *   return element[internals].form;
+ * }
+ * ```
+ */
+export const internals = Symbol('internals');
+
+/**
+ * An instance with `ElementInternals`.
+ *
+ * Use this when protected access is needed for an instance's `ElementInternals`
+ * from other files. A unique symbol is used to access the internals.
+ */
+export interface WithInternals {
+  /**
+   * An instance's `ElementInternals`.
+   */
+  [internals]: ElementInternals;
+}
diff --git a/internal/controller/form-submitter.ts b/internal/controller/form-submitter.ts
new file mode 100644
index 0000000000..a2ff01bc3d
--- /dev/null
+++ b/internal/controller/form-submitter.ts
@@ -0,0 +1,108 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {isServer, ReactiveElement} from 'lit';
+
+import {internals, WithInternals} from './element-internals.js';
+
+/**
+ * A string indicating the form submission behavior of the element.
+ *
+ * - submit: The element submits the form. This is the default value if the
+ * attribute is not specified, or if it is dynamically changed to an empty or
+ * invalid value.
+ * - reset: The element resets the form.
+ * - button: The element does nothing.
+ */
+export type FormSubmitterType = 'button'|'submit'|'reset';
+
+/**
+ * An element that can submit or reset a `<form>`, similar to
+ * `<button type="submit">`.
+ */
+export interface FormSubmitter extends ReactiveElement, WithInternals {
+  /**
+   * A string indicating the form submission behavior of the element.
+   *
+   * - submit: The element submits the form. This is the default value if the
+   * attribute is not specified, or if it is dynamically changed to an empty or
+   * invalid value.
+   * - reset: The element resets the form.
+   * - button: The element does nothing.
+   */
+  type: FormSubmitterType;
+}
+
+type FormSubmitterConstructor =
+    (new () => FormSubmitter)|(abstract new () => FormSubmitter);
+
+/**
+ * Sets up an element's constructor to enable form submission. The element
+ * instance should be form associated and have a `type` property.
+ *
+ * A click listener is added to each element instance. If the click is not
+ * default prevented, it will submit the element's form, if any.
+ *
+ * @example
+ * ```ts
+ * class MyElement extends LitElement {
+ *   static {
+ *     setupFormSubmitter(MyElement);
+ *   }
+ *
+ *   static formAssociated = true;
+ *
+ *   type: FormSubmitterType = 'submit';
+ *
+ *   [internals] = this.attachInternals();
+ * }
+ * ```
+ *
+ * @param ctor The form submitter element's constructor.
+ */
+export function setupFormSubmitter(ctor: FormSubmitterConstructor) {
+  if (isServer) {
+    return;
+  }
+
+  (ctor as unknown as typeof ReactiveElement).addInitializer(instance => {
+    const submitter = instance as FormSubmitter;
+    submitter.addEventListener('click', async event => {
+      const {type, [internals]: {form}} = submitter;
+      if (!form || type === 'button') {
+        return;
+      }
+
+      // Wait a microtask for event bubbling to complete.
+      await new Promise<void>(resolve => {
+        resolve();
+      });
+
+      if (event.defaultPrevented) {
+        return;
+      }
+
+      if (type === 'reset') {
+        form.reset();
+        return;
+      }
+
+      // form.requestSubmit(submitter) does not work with form associated custom
+      // elements. This patches the dispatched submit event to add the correct
+      // `submitter`.
+      // See https://github.com/WICG/webcomponents/issues/814
+      form.addEventListener('submit', submitEvent => {
+        Object.defineProperty(submitEvent, 'submitter', {
+          configurable: true,
+          enumerable: true,
+          get: () => submitter,
+        });
+      }, {capture: true, once: true});
+
+      form.requestSubmit();
+    });
+  });
+}
diff --git a/internal/controller/form-submitter_test.ts b/internal/controller/form-submitter_test.ts
new file mode 100644
index 0000000000..d5d85e52b4
--- /dev/null
+++ b/internal/controller/form-submitter_test.ts
@@ -0,0 +1,119 @@
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// import 'jasmine'; (google3-only)
+
+import {html, LitElement} from 'lit';
+import {customElement} from 'lit/decorators.js';
+
+import {Environment} from '../../testing/environment.js';
+import {Harness} from '../../testing/harness.js';
+
+import {internals} from './element-internals.js';
+import {FormSubmitterType, setupFormSubmitter} from './form-submitter.js';
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'test-form-submitter-button': FormSubmitterButton;
+  }
+}
+
+@customElement('test-form-submitter-button')
+class FormSubmitterButton extends LitElement {
+  static {
+    setupFormSubmitter(FormSubmitterButton);
+  }
+
+  static formAssociated = true;
+
+  type: FormSubmitterType = 'submit';
+
+  [internals] = this.attachInternals();
+}
+
+
+describe('setupFormSubmitter()', () => {
+  const env = new Environment();
+
+  async function setupTest() {
+    const root = env.render(
+        html`<form><test-form-submitter-button></test-form-submitter-button></form>`);
+    const submitter = root.querySelector('test-form-submitter-button');
+    if (!submitter) {
+      throw new Error(`Could not query rendered <test-form-submitter-button>`);
+    }
+    const form = root.querySelector('form');
+    if (!form) {
+      throw new Error(`Could not query rendered <form>`);
+    }
+
+    await env.waitForStability();
+
+    return {harness: new Harness(submitter), form};
+  }
+
+  it('button is submit type by default', async () => {
+    const {harness} = await setupTest();
+    expect(harness.element.type).toBe('submit');
+  });
+
+  it('button with type submit can submit a form', async () => {
+    const {harness, form} = await setupTest();
+    harness.element.type = 'submit';
+
+    spyOn(form, 'requestSubmit');
+    spyOn(form, 'reset');
+    await harness.clickWithMouse();
+
+    expect(form.requestSubmit).toHaveBeenCalled();
+    expect(form.reset).not.toHaveBeenCalled();
+  });
+
+  it('button with type reset can reset a form', async () => {
+    const {harness, form} = await setupTest();
+    harness.element.type = 'reset';
+
+    spyOn(form, 'requestSubmit');
+    spyOn(form, 'reset');
+    await harness.clickWithMouse();
+
+    expect(form.requestSubmit).not.toHaveBeenCalled();
+    expect(form.reset).toHaveBeenCalled();
+  });
+
+  it('submit can be cancelled with preventDefault', async () => {
+    const {harness, form} = await setupTest();
+    harness.element.type = 'submit';
+
+    spyOn(form, 'requestSubmit');
+
+    harness.element.addEventListener('click', (event: Event) => {
+      event.preventDefault();
+    }, {once: true});
+
+    await harness.clickWithMouse();
+
+    expect(form.requestSubmit).not.toHaveBeenCalled();
+  });
+
+  it('should set the button as the SubmitEvent submitter', async () => {
+    const {harness, form} = await setupTest();
+    const submitListener =
+        jasmine.createSpy('submitListener').and.callFake((event: Event) => {
+          event.preventDefault();
+        });
+
+    form.addEventListener('submit', submitListener);
+
+    await harness.clickWithMouse();
+
+    expect(submitListener).toHaveBeenCalled();
+    const event = submitListener.calls.argsFor(0)[0] as SubmitEvent;
+    expect(event.submitter)
+        .withContext('event.submitter')
+        .toBe(harness.element);
+  });
+});