From bd9b54e8c35d80fa4887ffdad000bd35592bdb6a Mon Sep 17 00:00:00 2001 From: Stephanie Zhang Date: Thu, 2 Oct 2025 15:25:22 -0500 Subject: [PATCH 1/7] very rough draft --- source | 120 ++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 106 insertions(+), 14 deletions(-) diff --git a/source b/source index a92d86863c1..319c2a74f37 100644 --- a/source +++ b/source @@ -50075,18 +50075,22 @@ interface HTMLInputElement : HTMLElement {

  • Invoke the value sanitization algorithm, if one is defined for the type attribute's new state.

    • -

  • Let previouslySelectable be true if setRangeText() previously applied to the element, and false otherwise.

    • +

  • Let previouslySelectable be true if setRangeText() previously applied to the element, and false otherwise.

    • -

  • Let nowSelectable be true if setRangeText() now applies to the element, and false otherwise.

    • +

  • Let nowSelectable be true if setRangeText() now applies to the element, and false otherwise.

    • -

  • If previouslySelectable is false and nowSelectable is true, set the - element's text entry cursor position to the - beginning of the text control, and set its selection - direction to "none".

    • +

  • If previouslySelectable is true and nowSelectable is false, then for + each FormControlRange whose control is this element, set its + control to null and set both its start offset and end offset to 0.

    • + +

  • If previouslySelectable is false and nowSelectable is true, set the + element's text entry cursor position to the + beginning of the text control, and set its selection + direction to "none".

    • @@ -54799,6 +54803,12 @@ You cannot submit this form when the field is incorrect.

  • Invoke the value sanitization algorithm, if the element's type attribute's current state defines one.

    • +

  • If the element's value is different from + oldValue, then run adjust form-control + ranges for this element, given a change offset of 0, a deleted length of the + length of oldValue, and an inserted length of the length + of the element's current value.

    • +

  • If the element's value (after applying the value sanitization algorithm) is different from oldValue, and the element has a text entry cursor position, @@ -54807,6 +54817,13 @@ You cannot submit this form when the field is incorrect. direction">resetting the selection direction to "none".

    • + +

    Integration with FormControlRange:

    +

    After setting the new value, run + adjust form-control ranges for this control. Treat the + entire old value as deleted and the entire new value as inserted, so that all associated ranges + update according to the rules in that section.

    +
    default @@ -57830,8 +57847,13 @@ interface HTMLTextAreaElement : HTMLElement {

  • Set this element's raw value to the new value.

    • -

  • Set this element's dirty value flag to - true.

    • +

  • Set this element's dirty value flag to + true.

    • + +

  • Run adjust form-control ranges for this element, + given a change offset of 0, a deleted length of the length of + oldAPIValue, and an inserted length of the length of this element's new + API value.

  • If the new API value is different from oldAPIValue, then move the text entry @@ -57841,6 +57863,12 @@ interface HTMLTextAreaElement : HTMLElement { +

    Integration with FormControlRange:

    +

    After setting the new value, run + adjust form-control ranges for this control. Treat the + entire old value as deleted and the entire new value as inserted, so that all associated ranges + update according to the rules in that section.

    +

    The textLength IDL attribute must return the @@ -61687,7 +61715,12 @@ MIT Room 32-G524

    -

    APIs for the text control selections

    +

    APIs for the text control selections

    + +

    + Text-entry controls support FormControlRange. Liveness is maintained by HTML's + form-control range adjustment algorithm, and the algorithms + in this section invoke it whenever they modify a control's value string.

    @@ -62137,7 +62170,13 @@ MIT Room 32-G524

  • Let new length be the length of the value of the first argument.

    • -

  • Let new end be the sum of start and new length.

    • +

  • Let new end be the sum of start and new length.

    • + +

  • Let deleted count be max(0, end minus start).

    • + +

  • Run adjust form-control ranges for this element, + given start as the change offset, deleted count as the deleted length, and + new length as the inserted length.

  • Run the appropriate set of substeps from the following list:

    @@ -62247,6 +62286,59 @@ control.setSelectionRange(oldStart + prefix.length, oldEnd + prefix.length, oldD +
    Form control range liveness
    + + + + +

    Some DOM APIs expose FormControlRange objects whose boundary points are defined over the + UTF-16 code units of a text control's value string rather than over the node tree. HTML is + responsible for keeping those ranges live when a control's value changes.

    + +
    Adjusting form-control ranges for a value change
    + +
    +

    To adjust form-control ranges for a control + |control| given a change offset, a deleted length, and an inserted length, run these steps:

    + +
      +

    1. For each FormControlRange |r| such that |r|’s + control is |control|, update each boundary (start and end) using + these plain rules:

      +
        +

      • Before the change: if the boundary comes before where the edit begins, leave it as + is.

        • +

      • Inside the removed or replaced text: if the boundary is at the edit point or falls + anywhere within the text that was removed or replaced (including exactly at its end), move + it to the edit point.

        • +

      • After the change: if the boundary comes after the edited text, move it left or right + to account for the overall change in length — insertions move it to the right, deletions + move it to the left, by the corresponding amount.

        • +
      +
      2. +

    2. Clamp both boundaries so they do not go past the end of the new value.

      3. +

    3. If the start ends up after the end, collapse the range by setting the end to match the + start.

      4. +
    +
    + +
    Where adjustments are invoked
    +

    Whenever a text control's value changes, user agents must run + adjust form-control ranges for that control. This occurs + (including but not limited to) for:

    +
      +

    • User typing, deletion, and paste that produce an input event.

      • +

    • The setRangeText() method.

      • +

    • Setting value or value (including form reset, + autofill, drag-and-drop text insertion, and undo/redo that mutate the control's value).

      • +
    + +

    If an input element's type is changed to a state that does not + support the selection APIs (see selection + applicability), then for each FormControlRange whose + control is that element, set its control to + null and set both its start offset and end offset to 0.

    +

    Constraints

    From accbe23052f355d9ebb10c13b333feff282f6acf Mon Sep 17 00:00:00 2001 From: Stephanie Zhang Date: Thu, 2 Oct 2025 15:41:31 -0500 Subject: [PATCH 2/7] undo whitespace --- source | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/source b/source index 319c2a74f37..63e341daa29 100644 --- a/source +++ b/source @@ -50075,22 +50075,18 @@ interface HTMLInputElement : HTMLElement {

  • Invoke the value sanitization algorithm, if one is defined for the type attribute's new state.

    • -

  • Let previouslySelectable be true if setRangeText() previously applied to the element, and false otherwise.

    • +

  • Let previouslySelectable be true if setRangeText() previously applied to the element, and false otherwise.

    • -

  • Let nowSelectable be true if setRangeText() now applies to the element, and false otherwise.

    • +

  • Let nowSelectable be true if setRangeText() now applies to the element, and false otherwise.

    • -

  • If previouslySelectable is true and nowSelectable is false, then for - each FormControlRange whose control is this element, set its - control to null and set both its start offset and end offset to 0.

    • - -

  • If previouslySelectable is false and nowSelectable is true, set the - element's text entry cursor position to the - beginning of the text control, and set its selection - direction to "none".

    • +

  • If previouslySelectable is false and nowSelectable is true, set the + element's text entry cursor position to the + beginning of the text control, and set its selection + direction to "none".

    • @@ -61715,7 +61711,7 @@ MIT Room 32-G524 -

    APIs for the text control selections

    +

    APIs for the text control selections

    Text-entry controls support FormControlRange. Liveness is maintained by HTML's @@ -62170,7 +62166,7 @@ MIT Room 32-G524

  • Let new length be the length of the value of the first argument.

    • -

  • Let new end be the sum of start and new length.

    • +

  • Let new end be the sum of start and new length.

  • Let deleted count be max(0, end minus start).

    • From 4fbc2544e10338ab4cc3282c795819d0524ca01b Mon Sep 17 00:00:00 2001 From: Stephanie Y Zhang Date: Mon, 6 Oct 2025 14:46:57 -0700 Subject: [PATCH 3/7] additional hooks --- source | 216 +++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 148 insertions(+), 68 deletions(-) diff --git a/source b/source index 63e341daa29..ed3ee6982a2 100644 --- a/source +++ b/source @@ -49827,10 +49827,13 @@ interface HTMLInputElement : HTMLElement { attribute gives the default value of the input element. When the value content attribute is added, set, or removed, if the control's dirty value flag - is false, the user agent must set the value of the element - to the value of the value content attribute, if there is - one, or the empty string otherwise, and then run the current value sanitization - algorithm, if one is defined.

    + is false, the user agent must:

    +
      +

    1. Let oldValue be the element's current value.

      2. +

    2. Set the value of the element to the value of the value content attribute, if there is one, or the empty string otherwise.

      3. +

    3. Run the current value sanitization algorithm, if one is defined.

      4. +

    4. If the element supports form control range and oldValue and the element's new value differ, then run the form control range full replacement steps with the element, the length of oldValue, and the length of the new value.

      5. +
    @@ -49866,17 +49869,16 @@ interface HTMLInputElement : HTMLElement {

    The reset algorithm for input - elements is to set its user validity, - dirty value flag, and - dirty checkedness flag - back to false, set the value of the element to the value - of the value content attribute, if there is one, or the - empty string otherwise, set the checkedness of the - element to true if the element has a checked content - attribute and false if it does not, empty the list of selected files, and then invoke the value - sanitization algorithm, if the type attribute's - current state defines one.

    + elements is to:

    +
      +

    1. Set its user validity, dirty value flag, and dirty checkedness flag back to false.

      2. +

    2. Let oldValue be the element's current value.

      3. +

    3. Set the value of the element to the value of the value content attribute, if there is one, or the empty string otherwise.

      4. +

    4. Set the checkedness of the element to true if the element has a checked content attribute and false if it does not.

      5. +

    5. Empty the list of selected files.

      6. +

    6. Invoke the value sanitization algorithm, if the type attribute's current state defines one.

      7. +

    7. If the element supports form control range and oldValue and the element's new value differ, then run the form control range full replacement steps with the element, the length of oldValue, and the length of the new value.

      8. +

    Each input element can be mutable. Except where @@ -50087,6 +50089,11 @@ interface HTMLInputElement : HTMLElement { element's text entry cursor position to the beginning of the text control, and set its selection direction to "none".

    + +

  • If previouslySelectable is true and nowSelectable is false, then for + each FormControlRange object whose control is this + element, set that object's control to null and set both its start offset and end offset to 0.

    • @@ -50153,6 +50160,87 @@ interface HTMLInputElement : HTMLElement { form, and name IDL attributes are part of the element's forms API.

    +

    The following concepts and algorithms integrate the {{FormControlRange}} interface (defined in + the DOM Standard) with HTML form controls.

    + +

    A {{FormControlRange}} object is associated + with an element if its control is that element. An element's form control ranges are the {{FormControlRange}} objects + associated with it.

    + +
    +

    The form control range value mutation algorithm +updates each {{FormControlRange}} associated with a supported +text control when a contiguous substring of its value string +is replaced. It is passed an element el, non‑negative integers start, +oldLength (removed length), and newLength (inserted length). Let delta = +newLength − oldLength. For each {{FormControlRange}} object range in +el's form control ranges:

    +
      +

    1. Let rs be range's start offset; let re + be its end offset.

      2. + +

    2. Let editStart be start; let editEnd be start + + oldLength.

      3. + +

    3. If editEnd ≤ rs, then (edit strictly before range) set rs = + rs + delta and re = re + delta and jump to step + Clamp.

      4. + +

    4. If editStart ≥ re, then (edit strictly after range) jump to step + Clamp.

      5. + +

    5. (Overlapping removal) If oldLength > 0, then:

      +
        +

      1. If rs ≥ editStart and rs < editEnd, set + rs = editStart.

        2. + +

      2. If re ≥ editStart and re < editEnd, set + re = editStart.

        3. +
      +
      6. + +

    6. (Replacement insertion remap) If oldLength > 0 and newLength > 0 + and editStart ≤ rs ≤ re ≤ editEnd, then for each boundary + (rs then re): let offsetWithin be that boundary's original value − + editStart; set boundary = editStart + min(offsetWithin, + newLength).

      7. + +

    7. (Pure insertion) If oldLength = 0 and newLength > 0 and + editStart is within [rs, re] then:

      +
        +

      1. If rs = re (collapsed), set rs = re = rs + + newLength.

        2. + +

      2. Otherwise, if editStart = rs, set re = re + + newLength. (Insertion at start expands.)

        3. + +

      3. Otherwise, if editStart = re, do nothing. (Insertion at end does not + expand.)

        4. +
      +
      8. + +

    8. Clamp: Let valueLen be the length of + el's current value string. Set rs = + min(rs, valueLen) and re = min(re, valueLen). If + rs > re, then set re = rs.

      9. + +

    9. Set range's start offset to rs and its end offset to re.

      10. +
    +

    This algorithm mirrors {{Range}} boundary adjustment rules, operating instead on the +UTF-16 code unit indices of a form control's value string.

    +

    +
    + +

    The form control range full replacement steps + for an element el with previous value length oldLength and new value length + newLength are to run the form control range value + mutation algorithm with el, 0, oldLength, and newLength.

    + +

    User agents must call the algorithm explicitly at each value mutation point; it is not + implicitly invoked by unspecified text modifications.

    + @@ -54799,11 +54887,8 @@ You cannot submit this form when the field is incorrect.

  • Invoke the value sanitization algorithm, if the element's type attribute's current state defines one.

    • -

  • If the element's value is different from - oldValue, then run adjust form-control - ranges for this element, given a change offset of 0, a deleted length of the - length of oldValue, and an inserted length of the length - of the element's current value.

    • +

  • If the element's value is different from + oldValue and the element supports form control range, then run the form control range full replacement steps with the element, the length of oldValue, and the length of the element's current value.

  • If the element's value (after applying the value sanitization algorithm) is different from oldValue, and the @@ -57542,6 +57627,7 @@ interface HTMLTextAreaElement : HTMLElement { interaction before queuing the task; for example, a user agent could wait for the user to have not hit a key for 100ms, so as to only fire the event when the user pauses, instead of continuously for each keystroke.

    +

    Additionally, before queuing that task, the user agent must run the form control range value mutation steps with the change characterized by the edit (offset, deleted length, inserted length) for this element.

    @@ -57562,7 +57648,7 @@ interface HTMLTextAreaElement : HTMLElement {

    The children changed steps for textarea elements must, if the element's dirty value flag is false, set the element's raw value to its child text - content.

    + content. If this changes the element's raw value, then run the form control range value mutation steps with a change offset of 0, a deleted length of the length of the previous API value, and an inserted length of the length of the new API value.

    @@ -57570,7 +57656,7 @@ interface HTMLTextAreaElement : HTMLElement { elements is to set the user validity to false, the dirty value flag back to false, and the raw value to its child text - content.

    + content. If this changes the element's API value, then run the form control range value mutation steps with a change offset of 0, a deleted length of the length of the old API value, and an inserted length of the length of the new API value.

    @@ -57827,7 +57913,7 @@ interface HTMLTextAreaElement : HTMLElement {

    The defaultValue attribute's setter must - string replace all with the given value within this element.

    + string replace all with the given value within this element. If the element's dirty value flag is false and this causes the element's raw value (and thus its API value) to change, then run the form control range value mutation steps with a change offset of 0, a deleted length of the length of the old API value, and an inserted length of the length of the new API value.

    @@ -57846,10 +57932,7 @@ interface HTMLTextAreaElement : HTMLElement {

  • Set this element's dirty value flag to true.

    • -

  • Run adjust form-control ranges for this element, - given a change offset of 0, a deleted length of the length of - oldAPIValue, and an inserted length of the length of this element's new - API value.

    • +

  • Run the form control range value mutation steps with this element, a change offset of 0, a deleted length of the length of oldAPIValue, and an inserted length of the length of this element's new API value.

  • If the new API value is different from oldAPIValue, then move the text entry @@ -62170,9 +62253,9 @@ MIT Room 32-G524

  • Let deleted count be max(0, end minus start).

    • -

  • Run adjust form-control ranges for this element, - given start as the change offset, deleted count as the deleted length, and - new length as the inserted length.

    • +

  • If this element supports form control range, + then run the form control range value mutation algorithm + with this element, start, deleted count, and new length.

  • Run the appropriate set of substeps from the following list:

    @@ -62287,53 +62370,50 @@ control.setSelectionRange(oldStart + prefix.length, oldEnd + prefix.length, oldD -

    Some DOM APIs expose FormControlRange objects whose boundary points are defined over the - UTF-16 code units of a text control's value string rather than over the node tree. HTML is +

    Some DOM APIs expose FormControlRange objects whose boundary points are defined over + the UTF-16 code units of a text control's value string rather than over the node tree. HTML is responsible for keeping those ranges live when a control's value changes.

    Adjusting form-control ranges for a value change
    -
    -

    To adjust form-control ranges for a control - |control| given a change offset, a deleted length, and an inserted length, run these steps:

    - -
      -

    1. For each FormControlRange |r| such that |r|’s - control is |control|, update each boundary (start and end) using - these plain rules:

      -
        -

      • Before the change: if the boundary comes before where the edit begins, leave it as - is.

        • -

      • Inside the removed or replaced text: if the boundary is at the edit point or falls - anywhere within the text that was removed or replaced (including exactly at its end), move - it to the edit point.

        • -

      • After the change: if the boundary comes after the edited text, move it left or right - to account for the overall change in length — insertions move it to the right, deletions - move it to the left, by the corresponding amount.

        • -
      -
      2. -

    2. Clamp both boundaries so they do not go past the end of the new value.

      3. -

    3. If the start ends up after the end, collapse the range by setting the end to match the - start.

      4. -
    -
    +

    The algorithm to adjust form-control ranges + for a control is defined earlier as the form control + range value mutation algorithm. This section only summarizes its purpose: to keep + FormControlRange objects live by updating their boundary offsets after each value + mutation.

    Where adjustments are invoked
    -

    Whenever a text control's value changes, user agents must run - adjust form-control ranges for that control. This occurs - (including but not limited to) for:

    -
      -

    • User typing, deletion, and paste that produce an input event.

      • -

    • The setRangeText() method.

      • -

    • Setting value or value (including form reset, - autofill, drag-and-drop text insertion, and undo/redo that mutate the control's value).

      • -
    + +

    User agents must invoke the form control range value + mutation algorithm each time a supported text control's value + string is mutated by replacing a contiguous substring (including insertions and deletions). This + includes, but is not limited to:

    +
      +

    • User editing operations (typing, confirmed IME composition, deletion, paste, drag-and-drop + text insertion, spellcheck or autocorrect replacements, undo/redo) that modify the value and dispatch + an input event.

      • + +

    • Calls to setRangeText().

      • + +

    • Scripted assignment to HTMLInputElement.value or + HTMLTextAreaElement.value, including during form reset, + autofill, session/history restoration, and drag-and-drop insertion producing a programmatic value + change.

      • + +

    • Value changes produced by sanitization algorithms that actually alter the stored value (e.g., + newline stripping, whitespace trimming).

      • +
    + +

    Selection changes alone (via setSelectionRange(), + setting selectionStart/selectionEnd, or changing selectionDirection) do not invoke the + algorithm because they do not modify the control's value string.

    If an input element's type is changed to a state that does not support the selection APIs (see selection - applicability), then for each FormControlRange whose - control is that element, set its control to - null and set both its start offset and end offset to 0.

    + applicability), then for each FormControlRange whose control is that element, set its + control to null and set both its start offset and end offset to 0.

    Constraints

    From 96d51de6fe2fda0307219a625c0a0ebfa2bff60f Mon Sep 17 00:00:00 2001 From: Stephanie Zhang Date: Thu, 16 Oct 2025 15:47:28 -0700 Subject: [PATCH 4/7] keep original formatting --- source | 46 +++++++++++++++++++++++++++------------------- 1 file changed, 27 insertions(+), 19 deletions(-) diff --git a/source b/source index ed3ee6982a2..252e7815adb 100644 --- a/source +++ b/source @@ -49827,13 +49827,14 @@ interface HTMLInputElement : HTMLElement { attribute gives the default value of the input element. When the value content attribute is added, set, or removed, if the control's dirty value flag - is false, the user agent must:

    -
      -

    1. Let oldValue be the element's current value.

      2. -

    2. Set the value of the element to the value of the value content attribute, if there is one, or the empty string otherwise.

      3. -

    3. Run the current value sanitization algorithm, if one is defined.

      4. -

    4. If the element supports form control range and oldValue and the element's new value differ, then run the form control range full replacement steps with the element, the length of oldValue, and the length of the new value.

      5. -
    + is false, the user agent must set the value of the element + to the value of the value content attribute, if there is + one, or the empty string otherwise, and then run the current value sanitization + algorithm, if one is defined. If the element + supports form control range and this operation changes its value, then run the form control range full replacement steps with the + element, the old value's length, and the new value's length.

    @@ -49869,16 +49870,23 @@ interface HTMLInputElement : HTMLElement {

    The reset algorithm for input - elements is to:

    -
      -

    1. Set its user validity, dirty value flag, and dirty checkedness flag back to false.

      2. -

    2. Let oldValue be the element's current value.

      3. -

    3. Set the value of the element to the value of the value content attribute, if there is one, or the empty string otherwise.

      4. -

    4. Set the checkedness of the element to true if the element has a checked content attribute and false if it does not.

      5. -

    5. Empty the list of selected files.

      6. -

    6. Invoke the value sanitization algorithm, if the type attribute's current state defines one.

      7. -

    7. If the element supports form control range and oldValue and the element's new value differ, then run the form control range full replacement steps with the element, the length of oldValue, and the length of the new value.

      8. -
    + elements is to set its user validity, + dirty value flag, and + dirty checkedness flag + back to false, set the value of the element to the value + of the value content attribute, if there is one, or the + empty string otherwise, set the checkedness of the + element to true if the element has a checked content + attribute and false if it does not, empty the list of selected files, and then invoke the value + sanitization algorithm, if the type attribute's + current state defines one.

    + +

    If the element supports form control range and its + value has changed as a result of this algorithm, then run the + form control range full replacement steps with the + element, the old value's length, and the new + value's length.

    Each input element can be mutable. Except where @@ -50171,7 +50179,7 @@ interface HTMLInputElement : HTMLElement {

    The form control range value mutation algorithm updates each {{FormControlRange}} associated with a supported -text control when a contiguous substring of its value string +text control when a contiguous substring of its {{FormControlRange/value string}} is replaced. It is passed an element el, non‑negative integers start, oldLength (removed length), and newLength (inserted length). Let delta = newLength − oldLength. For each {{FormControlRange}} object range in @@ -50221,7 +50229,7 @@ is replaced. It is passed an element el, non‑negative integers

  • Clamp: Let valueLen be the length of - el's current value string. Set rs = + el's current {{FormControlRange/value string}}. Set rs = min(rs, valueLen) and re = min(re, valueLen). If rs > re, then set re = rs.

    • From 3155a15f82fa8b1a2eec3269b654703efa4d1843 Mon Sep 17 00:00:00 2001 From: Stephanie Zhang Date: Thu, 16 Oct 2025 15:57:42 -0700 Subject: [PATCH 5/7] cleaning up textarea hooks --- source | 41 ++++++++++++++++++++++++++--------------- 1 file changed, 26 insertions(+), 15 deletions(-) diff --git a/source b/source index 252e7815adb..77ffbed87fd 100644 --- a/source +++ b/source @@ -50246,9 +50246,8 @@ UTF-16 code unit indices of a form control's value string.

    newLength are to run the form control range value mutation algorithm with el, 0, oldLength, and newLength.

    -

    User agents must call the algorithm explicitly at each value mutation point; it is not +

    User agents typically call the algorithm explicitly at each value mutation point; it is not implicitly invoked by unspecified text modifications.

    - @@ -54895,8 +54894,11 @@ You cannot submit this form when the field is incorrect.

  • Invoke the value sanitization algorithm, if the element's type attribute's current state defines one.

    • -

  • If the element's value is different from - oldValue and the element supports form control range, then run the form control range full replacement steps with the element, the length of oldValue, and the length of the element's current value.

    • +

  • If the element's value is different from + oldValue, and the element supports form control + range, then run the form control range full + replacement steps with element, oldValue's length, and the + current value's length.

  • If the element's value (after applying the value sanitization algorithm) is different from oldValue, and the @@ -54906,13 +54908,6 @@ You cannot submit this form when the field is incorrect. direction">resetting the selection direction to "none".

    • - -

    Integration with FormControlRange:

    -

    After setting the new value, run - adjust form-control ranges for this control. Treat the - entire old value as deleted and the entire new value as inserted, so that all associated ranges - update according to the rules in that section.

    -
    default @@ -57635,7 +57630,10 @@ interface HTMLTextAreaElement : HTMLElement { interaction before queuing the task; for example, a user agent could wait for the user to have not hit a key for 100ms, so as to only fire the event when the user pauses, instead of continuously for each keystroke.

    -

    Additionally, before queuing that task, the user agent must run the form control range value mutation steps with the change characterized by the edit (offset, deleted length, inserted length) for this element.

    +

    Before queuing that task, the user agent must run the + form control range value mutation algorithm for this + element, using the edit's offset, deleted length, and inserted length + to describe the change.

    @@ -57656,7 +57654,11 @@ interface HTMLTextAreaElement : HTMLElement {

    The children changed steps for textarea elements must, if the element's dirty value flag is false, set the element's raw value to its child text - content. If this changes the element's raw value, then run the form control range value mutation steps with a change offset of 0, a deleted length of the length of the previous API value, and an inserted length of the length of the new API value.

    + content. If this changes the element's raw value, + then run the form control range value mutation algorithm + for the element, with a change offset of 0, a deleted length equal to the length of the previous + API value, and an inserted length equal to the length + of the new API value.

    @@ -57664,7 +57666,11 @@ interface HTMLTextAreaElement : HTMLElement { elements is to set the user validity to false, the dirty value flag back to false, and the raw value to its child text - content. If this changes the element's API value, then run the form control range value mutation steps with a change offset of 0, a deleted length of the length of the old API value, and an inserted length of the length of the new API value.

    + content. If this changes the element's API value, + then run the form control range value mutation algorithm + for the element, with a change offset of 0, a deleted length equal to the length of the previous + API value, and an inserted length equal to the length + of the new API value.

    @@ -57921,7 +57927,12 @@ interface HTMLTextAreaElement : HTMLElement {

    The defaultValue attribute's setter must - string replace all with the given value within this element. If the element's dirty value flag is false and this causes the element's raw value (and thus its API value) to change, then run the form control range value mutation steps with a change offset of 0, a deleted length of the length of the old API value, and an inserted length of the length of the new API value.

    + string replace all with the given value within this element. + If this changes the element's raw value, + then run the form control range value mutation algorithm + for the element, with a change offset of 0, a deleted length equal to the length of the previous + API value, and an inserted length equal to the length + of the new API value.

    From 90163c4a8a89134812a0c01d94c485ae4f13db3b Mon Sep 17 00:00:00 2001 From: Stephanie Zhang Date: Thu, 16 Oct 2025 16:08:35 -0700 Subject: [PATCH 6/7] remove unnecessary text control block --- source | 65 ++++++---------------------------------------------------- 1 file changed, 6 insertions(+), 59 deletions(-) diff --git a/source b/source index 77ffbed87fd..ed34e174f2e 100644 --- a/source +++ b/source @@ -57948,10 +57948,13 @@ interface HTMLTextAreaElement : HTMLElement {

  • Set this element's raw value to the new value.

    • -

  • Set this element's dirty value flag to - true.

    • +

  • Set this element's dirty value flag to true.

    • -

  • Run the form control range value mutation steps with this element, a change offset of 0, a deleted length of the length of oldAPIValue, and an inserted length of the length of this element's new API value.

    • +

  • If this changes the element's API value, then run the + form control range value mutation algorithm for this + element, with a change offset of 0, a deleted length equal to the length of + oldAPIValue, and an inserted length equal to the length of the element's new + API value.

  • If the new API value is different from oldAPIValue, then move the text entry @@ -57961,12 +57964,6 @@ interface HTMLTextAreaElement : HTMLElement {

    • -

    Integration with FormControlRange:

    -

    After setting the new value, run - adjust form-control ranges for this control. Treat the - entire old value as deleted and the entire new value as inserted, so that all associated ranges - update according to the rules in that section.

    -

    The textLength IDL attribute must return the @@ -62384,56 +62381,6 @@ control.setSelectionRange(oldStart + prefix.length, oldEnd + prefix.length, oldD -

    Form control range liveness
    - - - - -

    Some DOM APIs expose FormControlRange objects whose boundary points are defined over - the UTF-16 code units of a text control's value string rather than over the node tree. HTML is - responsible for keeping those ranges live when a control's value changes.

    - -
    Adjusting form-control ranges for a value change
    - -

    The algorithm to adjust form-control ranges - for a control is defined earlier as the form control - range value mutation algorithm. This section only summarizes its purpose: to keep - FormControlRange objects live by updating their boundary offsets after each value - mutation.

    - -
    Where adjustments are invoked
    - -

    User agents must invoke the form control range value - mutation algorithm each time a supported text control's value - string is mutated by replacing a contiguous substring (including insertions and deletions). This - includes, but is not limited to:

    -
      -

    • User editing operations (typing, confirmed IME composition, deletion, paste, drag-and-drop - text insertion, spellcheck or autocorrect replacements, undo/redo) that modify the value and dispatch - an input event.

      • - -

    • Calls to setRangeText().

      • - -

    • Scripted assignment to HTMLInputElement.value or - HTMLTextAreaElement.value, including during form reset, - autofill, session/history restoration, and drag-and-drop insertion producing a programmatic value - change.

      • - -

    • Value changes produced by sanitization algorithms that actually alter the stored value (e.g., - newline stripping, whitespace trimming).

      • -
    - -

    Selection changes alone (via setSelectionRange(), - setting selectionStart/selectionEnd, or changing selectionDirection) do not invoke the - algorithm because they do not modify the control's value string.

    - -

    If an input element's type is changed to a state that does not - support the selection APIs (see selection - applicability), then for each FormControlRange whose control is that element, set its - control to null and set both its start offset and end offset to 0.

    -

    Constraints

    From 7ed3fb77b0792de64da3616122de9ab84ab80794 Mon Sep 17 00:00:00 2001 From: Stephanie Zhang Date: Thu, 23 Oct 2025 08:38:36 -0700 Subject: [PATCH 7/7] update mutation alg --- source | 124 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 62 insertions(+), 62 deletions(-) diff --git a/source b/source index ed34e174f2e..4e696cffb3d 100644 --- a/source +++ b/source @@ -50168,86 +50168,86 @@ interface HTMLInputElement : HTMLElement { form, and name IDL attributes are part of the element's forms API.

    -

    The following concepts and algorithms integrate the {{FormControlRange}} interface (defined in - the DOM Standard) with HTML form controls.

    - -

    A {{FormControlRange}} object is associated - with an element if its control is that element. An element's form control ranges are the {{FormControlRange}} objects +

    A {{FormControlRange}} object is associated + with an element if its control is that element. An element's + form control ranges are the {{FormControlRange}} objects associated with it.

    -

    The form control range value mutation algorithm -updates each {{FormControlRange}} associated with a supported -text control when a contiguous substring of its {{FormControlRange/value string}} -is replaced. It is passed an element el, non‑negative integers start, -oldLength (removed length), and newLength (inserted length). Let delta = -newLength − oldLength. For each {{FormControlRange}} object range in -el's form control ranges:

    -
      -

    1. Let rs be range's start offset; let re - be its end offset.

      2. +

      The form control range value mutation algorithm + updates each {{FormControlRange}} associated with a + supported text control when a contiguous substring of + its {{FormControlRange/value string}} is replaced. It is passed an element el and + non-negative integers start, oldLength (removed length), and + newLength (inserted length). Let delta = newLength - + oldLength. For each {{FormControlRange}} object range in + el's form control ranges:

      -

    2. Let editStart be start; let editEnd be start + - oldLength.

      3. +
        +

      1. Let rs be range's start offset, and + re be its end offset.

        2. -

      2. If editEnd ≤ rs, then (edit strictly before range) set rs = - rs + delta and re = re + delta and jump to step - Clamp.

        3. +

      3. Let editStart be start, and let editEnd be + start + oldLength.

        4. -

      4. If editStart ≥ re, then (edit strictly after range) jump to step - Clamp.

        5. +

      5. If editEnd ≤ rs, then (edit strictly before range) set + rs = rs + delta and re = re + delta, + then jump to step Clamp.

        6. -

      6. (Overlapping removal) If oldLength > 0, then:

        -
          -

        1. If rs ≥ editStart and rs < editEnd, set - rs = editStart.

          2. +

        2. If editStart ≥ re, then (edit strictly after range) jump to step + Clamp.

          3. -

        3. If re ≥ editStart and re < editEnd, set - re = editStart.

          4. -
        -
        7. +

      7. (Overlapping removal) If oldLength > 0, then:

        +
          +

        1. If rs ≥ editStart and rs < editEnd, + set rs = editStart.

          2. -

        2. (Replacement insertion remap) If oldLength > 0 and newLength > 0 - and editStart ≤ rs ≤ re ≤ editEnd, then for each boundary - (rs then re): let offsetWithin be that boundary's original value − - editStart; set boundary = editStart + min(offsetWithin, - newLength).

          3. +

        3. If re ≥ editStart and re < editEnd, + set re = editStart.

          4. +
        +
        8. -

      8. (Pure insertion) If oldLength = 0 and newLength > 0 and - editStart is within [rs, re] then:

        -
          -

        1. If rs = re (collapsed), set rs = re = rs - + newLength.

          2. +

        2. (Replacement insertion remap) If oldLength > 0 and + newLength > 0 and editStart ≤ rs ≤ re ≤ + editEnd, then for each boundary (rs then re): let + offsetWithin be that boundary's original value − editStart, and set the + boundary to editStart + min(offsetWithin, newLength).

          3. -

        3. Otherwise, if editStart = rs, set re = re + - newLength. (Insertion at start expands.)

          4. +

        4. (Pure insertion) If oldLength = 0 and newLength > 0 and + editStart is within [rs, re], then:

          +
            +

          1. If rs = re (collapsed), set + rs = re = rs + newLength.

            2. -

          2. Otherwise, if editStart = re, do nothing. (Insertion at end does not - expand.)

            3. -
          -
          5. +

        5. Otherwise, if editStart = rs, set + re = re + newLength.

          6. -

        6. Clamp: Let valueLen be the length of - el's current {{FormControlRange/value string}}. Set rs = - min(rs, valueLen) and re = min(re, valueLen). If - rs > re, then set re = rs.

          7. +

        7. Otherwise, if editStart = re, do nothing.

          8. +
        +
        9. + +

      9. Clamp: Let valueLen be the length of + el's current {{FormControlRange/value string}}. Set rs = + min(rs, valueLen) and re = + min(re, valueLen). If rs > re, set + re = rs.

        10. + +

      10. Set range's start offset to rs, and + its end offset to re.

        11. +
      -

    3. Set range's start offset to rs and its end offset to re.

      4. -
    -

    This algorithm mirrors {{Range}} boundary adjustment rules, operating instead on the -UTF-16 code unit indices of a form control's value string.

    -

    +

    This algorithm mirrors {{Range}} boundary adjustment rules, operating on UTF-16 + code unit indices within a form control's value string.

    +

    -

    The form control range full replacement steps +

    The form control range full replacement steps for an element el with previous value length oldLength and new value length newLength are to run the form control range value mutation algorithm with el, 0, oldLength, and newLength.

    -

    User agents typically call the algorithm explicitly at each value mutation point; it is not - implicitly invoked by unspecified text modifications.

    +

    User agents typically call this algorithm explicitly at each value mutation point; + it is not implicitly invoked by unspecified text modifications.

    @@ -57927,7 +57927,7 @@ interface HTMLTextAreaElement : HTMLElement {

    The defaultValue attribute's setter must - string replace all with the given value within this element. + string replace all with the given value within this element. If this changes the element's raw value, then run the form control range value mutation algorithm for the element, with a change offset of 0, a deleted length equal to the length of the previous @@ -96444,7 +96444,7 @@ interface BarProp {

    The identity of the reserved environment is considered to be fully transferred to the created environment settings object. The reserved environment - is not searchable by the environment’s environment's id from this point on.