diff --git a/Accessibility/CaretBrowsing/explainer.md b/Accessibility/CaretBrowsing/explainer.md
index 796d09a5..5c9e92e3 100644
--- a/Accessibility/CaretBrowsing/explainer.md
+++ b/Accessibility/CaretBrowsing/explainer.md
@@ -44,7 +44,7 @@ We welcome your feedback and opinion on ways we can help improve Chromium caret
 
 * Caret Navigation: https://en.wikipedia.org/wiki/Caret_navigation
 * Caret Browsing extension in Chrome Web Store: https://chrome.google.com/webstore/detail/caret-browsing/fklpgenihifpccgiifchnihilipmbffg
-* Keyboard shortcuts in Windows (Copy, paste, and other general keyboard shortcuts): https://support.microsoft.com/en-us/help/12445/windows-keyboard-shortcuts
+* Keyboard shortcuts in Windows (Copy, paste, and other general keyboard shortcuts): https://support.microsoft.com/help/12445/windows-keyboard-shortcuts
 
 ---
 [Related issues](https://github.com/MicrosoftEdge/MSEdgeExplainers/labels/Caret%20Browsing) | [Open a new issue](https://github.com/MicrosoftEdge/MSEdgeExplainers/issues/new?title=%5BCaret%20Browsing%5D)
diff --git a/Accessibility/ConfirmationOfAction/explainer.md b/Accessibility/ConfirmationOfAction/explainer.md
index 7053d2a1..6de75d52 100644
--- a/Accessibility/ConfirmationOfAction/explainer.md
+++ b/Accessibility/ConfirmationOfAction/explainer.md
@@ -161,7 +161,7 @@ that should be announced beyond the immediate effect of the primary action.
 
 ## Proposed Solution
 
-(This version inspired by [UIA Notification API](https://docs.microsoft.com/en-us/windows/win32/api/uiautomationcoreapi/nf-uiautomationcoreapi-uiaraisenotificationevent))
+(This version inspired by [UIA Notification API](https://learn.microsoft.com/windows/win32/api/uiautomationcoreapi/nf-uiautomationcoreapi-uiaraisenotificationevent))
 
 For use cases that don't have an express UI tie-in, it makes sense to provide a solution
 not expressly tied to HTML element, but for which other document-centric information can
diff --git a/Accessibility/HighContrast/explainer.md b/Accessibility/HighContrast/explainer.md
index 789ba13a..7a14ef57 100644
--- a/Accessibility/HighContrast/explainer.md
+++ b/Accessibility/HighContrast/explainer.md
@@ -15,9 +15,9 @@ This document is intended as a starting point for engaging the community and sta
 
 ## Overview
 
-High contrast is a [Windows accessibility feature](https://docs.microsoft.com/en-us/windows/desktop/w8cookbook/high-contrast-mode) intended to increase the readability of text through color contrast. Individuals with low vision may find it more comfortable to read content when there is a strong contrast between foreground and background colors. High contrast is a useful feature in increasing the readability of screen-based text for such users.
+High contrast is a [Windows accessibility feature](https://learn.microsoft.com/windows/desktop/w8cookbook/high-contrast-mode) intended to increase the readability of text through color contrast. Individuals with low vision may find it more comfortable to read content when there is a strong contrast between foreground and background colors. High contrast is a useful feature in increasing the readability of screen-based text for such users.
 
-The Windows platform provides built-in [high contrast color themes](https://docs.microsoft.com/en-us/windows/uwp/design/accessibility/high-contrast-themes) such as the more popular "black-on-white" and "white-on-black" themes. Besides the default themes, users can customize the colors and create their own themes. Applications can make use of these color themes and propagate them into their content model. In the case of the web browser, high contrast colors are propagated to website pages as a set of user agent styles, thus increasing readability of the text and allowing a coherent experience across the Windows OS and various applications.
+The Windows platform provides built-in [high contrast color themes](https://learn.microsoft.com/windows/uwp/design/accessibility/high-contrast-themes) such as the more popular "black-on-white" and "white-on-black" themes. Besides the default themes, users can customize the colors and create their own themes. Applications can make use of these color themes and propagate them into their content model. In the case of the web browser, high contrast colors are propagated to website pages as a set of user agent styles, thus increasing readability of the text and allowing a coherent experience across the Windows OS and various applications.
 
 Microsoft Edge and IE are currently the only browsers to support the high contrast feature using Windows high contrast themes. Many of the features described in this document were first shipped in 2012 with IE 10 and continue to use the ```-ms-``` vendor prefix for names and values.
 
@@ -36,7 +36,7 @@ When high contrast is currently enabled in Chrome, a popup is displayed promptin
 
 ## CSS Media Query
 
-In order to allow developer defined high contrast rules for webpages, a [high contrast media query type](https://msdn.microsoft.com/en-us/library/hh771830(v=vs.85).aspx) would be added called ```high-contrast```. This CSS media query type is currently supported by Microsoft Edge and IE. If a ```high-contrast``` media query evaluates to true, any styles defined within that media query *will* be used when in high contrast and will *not* be overridden by the high contrast feature.
+In order to allow developer defined high contrast rules for webpages, a [high contrast media query type](https://msdn.microsoft.com/library/hh771830(v=vs.85).aspx) would be added called ```high-contrast```. This CSS media query type is currently supported by Microsoft Edge and IE. If a ```high-contrast``` media query evaluates to true, any styles defined within that media query *will* be used when in high contrast and will *not* be overridden by the high contrast feature.
 
 #### Possible values
 
@@ -86,7 +86,7 @@ To provide readability between foreground and background colors, high contrast c
 * ```-webkit-tap-highlight-color```
 * ```background-image``` (***only*** in the case of text/date/file input control types, as well as for ```select```, ```option```, and ```optgroup``` HTML tags)
 _____
-To allow for further developer customization of the high contrast feature, a [CSS property](https://msdn.microsoft.com/en-us/library/hh771863(v=vs.85).aspx), ```high-contrast-adjust```, would be added. This CSS property type is currently supported by Microsoft Edge and IE. This property can be used to override the effects of high contrast.
+To allow for further developer customization of the high contrast feature, a [CSS property](https://msdn.microsoft.com/library/hh771863(v=vs.85).aspx), ```high-contrast-adjust```, would be added. This CSS property type is currently supported by Microsoft Edge and IE. This property can be used to override the effects of high contrast.
 
 #### Possible values
 
diff --git a/Accessibility/UIA/explainer.md b/Accessibility/UIA/explainer.md
index 0b429c5e..29251f3d 100644
--- a/Accessibility/UIA/explainer.md
+++ b/Accessibility/UIA/explainer.md
@@ -4,7 +4,7 @@ Authors: [Rossen Atanassov](https://github.com/atanassov), [Melanie Richards](ht
 
 ## Introduction
 
-[Microsoft UI Automation (UIA)](https://docs.microsoft.com/en-us/dotnet/framework/ui-automation/ui-automation-overview) provides programmatic access to most user interface (UI) elements of desktop applications, as well as web content and web applications. This API enables assistive technology (AT) products, such as screen readers, to provide information about applications, their UI and contents to end users. With this information, ATs can allow the user to manipulate applications by means other than standard input.
+[Microsoft UI Automation (UIA)](https://learn.microsoft.com/dotnet/framework/ui-automation/ui-automation-overview) provides programmatic access to most user interface (UI) elements of desktop applications, as well as web content and web applications. This API enables assistive technology (AT) products, such as screen readers, to provide information about applications, their UI and contents to end users. With this information, ATs can allow the user to manipulate applications by means other than standard input.
 
 At a high level, UIA exposes two sets of APIs, *provider APIs*, those implemented by a web browser for example, and *client APIs*, those implemented by an AT. This document’s focus is on implementing the *provider* APIs inside Chromium. These APIs are not exposed to web developers, and it is not expected that web developers should change the way they build sites and web apps—these APIs are meant to map web content into a format useful to C/C++ programmers.
 
@@ -30,14 +30,14 @@ At the heart of all this are users of assistive tech, who are empowered to brows
 
 In order to complete UI Automation support in Chromium, this project will implement the provider APIs for:
 
-* **The [accessibility tree](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-eventsoverview) and [control types](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-controltypesoverview):** This work will leverage Chromium’s platform-agnostic accessibility tree abstraction layer, and map its elements to the appropriate UIA control types. For reference, in case of web applications, a control could be represented by one or more HTML elements, such as a `<a>` or `<select>` and its `<option>` elements.
-* **[Properties](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-propertiesoverview):** mappings from ARIA and host language semantics into control properties. These can include what state the control is in, the control’s relationship to other controls, its styles, value, and placement, and many other useful properties (such as alternative text).
-* **[Control patterns](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-controlpatternsoverview):** methods allowing interaction with controls, often with interaction models specific to their types. Many control patterns implement UI idioms such as "this element is toggle-able, here's a method to toggle it" or "this element accepts a range of values, here are the min/max/current values and a method for changing the current value." Some control patterns expose additional structural information, such as "this tree of nodes represents a table with rows and columns." TextPattern, as previously mentioned, is a robust control pattern which marks up text content with both structure and style information; it also enables linear navigation over text content.
-* **[Events](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-eventsoverview):** notifications for structural and property changes of UI controls. Similarly to other accessibility APIs, UIA events inform ATs of changes which can be surfaced to end users.
+* **The [accessibility tree](https://learn.microsoft.com/windows/desktop/winauto/uiauto-eventsoverview) and [control types](https://learn.microsoft.com/windows/desktop/winauto/uiauto-controltypesoverview):** This work will leverage Chromium’s platform-agnostic accessibility tree abstraction layer, and map its elements to the appropriate UIA control types. For reference, in case of web applications, a control could be represented by one or more HTML elements, such as a `<a>` or `<select>` and its `<option>` elements.
+* **[Properties](https://learn.microsoft.com/windows/desktop/winauto/uiauto-propertiesoverview):** mappings from ARIA and host language semantics into control properties. These can include what state the control is in, the control’s relationship to other controls, its styles, value, and placement, and many other useful properties (such as alternative text).
+* **[Control patterns](https://learn.microsoft.com/windows/desktop/winauto/uiauto-controlpatternsoverview):** methods allowing interaction with controls, often with interaction models specific to their types. Many control patterns implement UI idioms such as "this element is toggle-able, here's a method to toggle it" or "this element accepts a range of values, here are the min/max/current values and a method for changing the current value." Some control patterns expose additional structural information, such as "this tree of nodes represents a table with rows and columns." TextPattern, as previously mentioned, is a robust control pattern which marks up text content with both structure and style information; it also enables linear navigation over text content.
+* **[Events](https://learn.microsoft.com/windows/desktop/winauto/uiauto-eventsoverview):** notifications for structural and property changes of UI controls. Similarly to other accessibility APIs, UIA events inform ATs of changes which can be surfaced to end users.
 
 ## Example of control interfaces
 
-For an example of how these APIs work in conjunction to provide complete interactivity with a control, refer to documentation for the [Button control type](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-supportbuttoncontroltype) (which `<button>` and elements with `role="button"` map into).
+For an example of how these APIs work in conjunction to provide complete interactivity with a control, refer to documentation for the [Button control type](https://learn.microsoft.com/windows/desktop/winauto/uiauto-supportbuttoncontroltype) (which `<button>` and elements with `role="button"` map into).
 
 ## Current workarounds
 
@@ -47,7 +47,7 @@ Implementing UI Automation support on the Windows platform is not intended to re
 
 ## Additional information
 
-* For detailed information on UI Automation provider APIs, please refer to [UI Automation Providers Overview](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-providersoverview).
+* For detailed information on UI Automation provider APIs, please refer to [UI Automation Providers Overview](https://learn.microsoft.com/windows/desktop/winauto/uiauto-providersoverview).
 * Each accessibility API has its own nomenclature. For a quick sense of the differences between API mappings, refer to the tables in mapping specifications such as [Core-AAM](https://w3c.github.io/core-aam/), [HTML-AAM](https://w3c.github.io/html-aam/), [Graphics-AAM](https://w3c.github.io/graphics-aam/), and [SVG-AAM](https://w3c.github.io/svg-aam/).
 
 ---
diff --git a/Accessibility/UIA/i2i.md b/Accessibility/UIA/i2i.md
index 860d6b0d..bbf3bacc 100644
--- a/Accessibility/UIA/i2i.md
+++ b/Accessibility/UIA/i2i.md
@@ -10,7 +10,7 @@ Rossen.Atanassov@microsoft.com, Melanie.Richards@microsoft.com
 
 ## Design doc/Spec
 
-[UI Automation Providers Overview](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-providersoverview)
+[UI Automation Providers Overview](https://learn.microsoft.com/windows/desktop/winauto/uiauto-providersoverview)
 
 A TAG review is not requested, as these interfaces are specific to the Windows platform and not intended to be introduced as web standards. It is not expected that web developers will need to make changes to their content as a result of this work, as UIAutomation support reflects lower-level implementation details, and will not be replacing or removing accessibility APIs already supported in Chromium.
 
@@ -57,7 +57,7 @@ A UIA implementation has no bearing on browser support for any other assistive t
 
 UIA doesn’t pose any specific performance concerns that aren’t applicable to any other assistive API, such as IA2.
 
-In order to extend UIA support from basic to full coverage, this work will continue to leverage Chromium’s platform-agnostic accessibility tree abstraction layer, and will map tree elements to the appropriate UIA control types. Support of UIA interfaces will be consistent with other UIA providers, as outlined in [UI Automation Providers Overview](https://docs.microsoft.com/en-us/windows/desktop/winauto/uiauto-providersoverview). For an overview of how web content semantics will map to UIA, refer to the following mapping specifications: [Core-AAM](https://w3c.github.io/core-aam/), [HTML-AAM](https://w3c.github.io/html-aam/), [Graphics-AAM](https://w3c.github.io/graphics-aam/), and [SVG-AAM](https://w3c.github.io/svg-aam/).
+In order to extend UIA support from basic to full coverage, this work will continue to leverage Chromium’s platform-agnostic accessibility tree abstraction layer, and will map tree elements to the appropriate UIA control types. Support of UIA interfaces will be consistent with other UIA providers, as outlined in [UI Automation Providers Overview](https://learn.microsoft.com/windows/desktop/winauto/uiauto-providersoverview). For an overview of how web content semantics will map to UIA, refer to the following mapping specifications: [Core-AAM](https://w3c.github.io/core-aam/), [HTML-AAM](https://w3c.github.io/html-aam/), [Graphics-AAM](https://w3c.github.io/graphics-aam/), and [SVG-AAM](https://w3c.github.io/svg-aam/).
 
 ### Activation
 
diff --git a/AudioOffload/explainer.md b/AudioOffload/explainer.md
index c6880386..1eb287a8 100644
--- a/AudioOffload/explainer.md
+++ b/AudioOffload/explainer.md
@@ -2,7 +2,7 @@
 **Author:** William Carr (drawn on work from Isuru Pathirana)
 
 # Summary Description
-Hardware Accelerated Audio Processing allows audio processing to be performed on dedicated audio processors. This process is commonly referred to as audio offload (the processing is offloaded from the computer's main CPU to the dedicated audio processor(s)). Because audio processing is a computationally expensive process, the use of specialized hardware can improve power efficiency, resulting in longer battery life. To read more about the general concept of audio offload on Windows, please see: https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/hardware-offloaded-audio-processing
+Hardware Accelerated Audio Processing allows audio processing to be performed on dedicated audio processors. This process is commonly referred to as audio offload (the processing is offloaded from the computer's main CPU to the dedicated audio processor(s)). Because audio processing is a computationally expensive process, the use of specialized hardware can improve power efficiency, resulting in longer battery life. To read more about the general concept of audio offload on Windows, please see: https://learn.microsoft.com/windows-hardware/drivers/audio/hardware-offloaded-audio-processing
 
 This proposal lays out a path to enable the use of audio offload for the clear audio pipeline in Chromium on Windows when playback is using an audio device that supports hardware audio acceleration.
 
diff --git a/AudioStreamCategory/explainer.md b/AudioStreamCategory/explainer.md
index d026077c..ed1ecfe2 100644
--- a/AudioStreamCategory/explainer.md
+++ b/AudioStreamCategory/explainer.md
@@ -17,7 +17,7 @@ The ```contentHint``` we are proposing is ```speechRecognition```.
 
 We believe there is a general need to differentiate between streams intended for human consumption and streams meant to be used for transcription by a machine because there are many differences in the optimizations that are applied for each scenario. Specifically, requirements for communications between humans can be found in the [ETSI TS 126 131 specification](https://www.etsi.org/deliver/etsi_ts/126100_126199/126131/12.03.00_60/ts_126131v120300p.pdf), and include optimizations in noise suppression like the addition of pink noise in order to increase user satisfaction, which is in direct opposition to the needs of a speech recognition system. There is also a draft of testing methods for speech recognition systems that outlines some of the different requirements for those systems [STQ63-260v0210](https://drive.google.com/file/d/1y_i7NkXbCuRWznYRl9dacy3xDdH2e7-m/view?usp=sharing).
 
-The proposed solution below was inspired by the categories that Windows offers for audio streams. These categories allow you to specify what kind of audio stream you want (ex: “speech” for when someone is dictating into a mic), which gives the operating system a chance to optimize the stream for that type of input. After some research, we found that similar categories exist across [Android](https://developer.android.com/reference/android/media/AudioAttributes.html), [iOS](https://developer.apple.com/documentation/avfoundation/avaudiosessionmode?language=objc), and, of course, [Windows](https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/audio-signal-processing-modes).
+The proposed solution below was inspired by the categories that Windows offers for audio streams. These categories allow you to specify what kind of audio stream you want (ex: “speech” for when someone is dictating into a mic), which gives the operating system a chance to optimize the stream for that type of input. After some research, we found that similar categories exist across [Android](https://developer.android.com/reference/android/media/AudioAttributes.html), [iOS](https://developer.apple.com/documentation/avfoundation/avaudiosessionmode?language=objc), and, of course, [Windows](https://learn.microsoft.com/windows-hardware/drivers/audio/audio-signal-processing-modes).
 
 ## Proposed Solution
 
diff --git a/Canvas/FormattedText.md b/Canvas/FormattedText.md
index ec38ad80..60acf9ae 100644
--- a/Canvas/FormattedText.md
+++ b/Canvas/FormattedText.md
@@ -31,8 +31,8 @@ choice for presenting a rapidly-changing view.
 In these scenarios, it is often necessary to present text to the user. The 2D Canvas
 API currently provides a relatively simplistic text rendering capability: A single run
 of text can be
-[measured](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/measureText)
-and [rendered](https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/fillText)
+[measured](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/measureText)
+and [rendered](https://developer.mozilla.org/docs/Web/API/CanvasRenderingContext2D/fillText)
 **as a single line**, optionally compressed to fit
 within a certain width. If the developer needs to present more than just a few words
 (e.g., a paragraph of text) then things get very complicated very quickly. Some options
@@ -77,7 +77,7 @@ This proposal aims to make it easy for web developers to get correct and fast
 multiline formatted text rendering functionality in Canvas, while preserving
 the low-level flexibility for positioning text that is already present in the
 existing Canvas API. It takes inspiration from
-[related APIs](https://docs.microsoft.com/en-us/dotnet/framework/wpf/advanced/drawing-formatted-text)
+[related APIs](https://learn.microsoft.com/dotnet/framework/wpf/advanced/drawing-formatted-text)
 as a starting point.
 
 The proposal below introduces a Canvas formatted text API and shows how it can
@@ -462,7 +462,7 @@ as a `<p>` element), with formatted sections wrapped in appropriate
 [phrasing content](https://html.spec.whatwg.org/multipage/dom.html#phrasing-content-2)
 (such as `<span>` and styled to match the `CanvasFormattedTextRun` formatting.) The
 markup should make use of
-[ARIA Live Regions](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Live_Regions)
+[ARIA Live Regions](https://developer.mozilla.org/docs/Web/Accessibility/ARIA/ARIA_Live_Regions)
 to be sure assistive technologies (ATs) pickup and announce any dynamic changes.
 
 Looking generally at what low-level features are necessary to make text fully accessible
diff --git a/DevTools/3DView/explainer.md b/DevTools/3DView/explainer.md
index 69910e74..4b0aa69d 100644
--- a/DevTools/3DView/explainer.md
+++ b/DevTools/3DView/explainer.md
@@ -7,7 +7,7 @@ Authors: [Erica Draud](https://github.com/erdraud)
 * **Current version: https://github.com/MicrosoftEdge/DevTools/blob/main/explainers/3DView/explainer.md**
     
 ## Introduction
-We released [3D View](https://docs.microsoft.com/en-us/microsoft-edge/devtools-guide-chromium/3d-view/) as a comprehensive tool for debugging your web application in the 3D space. This document will cover enhancements and adjustments we're making based on feedback.
+We released [3D View](https://learn.microsoft.com/microsoft-edge/devtools-guide-chromium/3d-view/) as a comprehensive tool for debugging your web application in the 3D space. This document will cover enhancements and adjustments we're making based on feedback.
 
 ## Goals
 * Make the UI in the DOM and Z-index tabs consistent by updating the strings and their organization
diff --git a/DevTools/ClientHints/explainer.md b/DevTools/ClientHints/explainer.md
index 18b21dc8..21fee628 100644
--- a/DevTools/ClientHints/explainer.md
+++ b/DevTools/ClientHints/explainer.md
@@ -8,7 +8,7 @@ Authors: [Erica Draud](https://github.com/erdraud)
     
 ## Introduction
 
-[Client Hints](https://wicg.github.io/client-hints-infrastructure/) focus on securely enabling scalable content negotiation between the client and server through a collection of HTTP and user-agent features with a third-party delegation system. A new expansion to the Client Hints API, [User-Agent Client Hints](https://wicg.github.io/ua-client-hints/) enable developers to access information about a user's browser in a privacy-preserving and ergonomic way. The existing debugging experience for these client hints has been described as limited and “super painful” by our internal clients. Developers cannot easily modify UA Client Hints through an accessible UI, and currently the platform does not support testing custom UA Client Hints and [UA Strings](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent) simultaneously, an important use case for developers. This is a high priority for the Web Platform team; they want to encourage people to switch to using Client Hints over Strings as we hypothesize it will greatly improve site compatibility and code hygiene. They’ve gotten feedback that limited testing infrastructure is a large friction point in that migration, so we are taking on this work to support developers and to improve our existing UX.  
+[Client Hints](https://wicg.github.io/client-hints-infrastructure/) focus on securely enabling scalable content negotiation between the client and server through a collection of HTTP and user-agent features with a third-party delegation system. A new expansion to the Client Hints API, [User-Agent Client Hints](https://wicg.github.io/ua-client-hints/) enable developers to access information about a user's browser in a privacy-preserving and ergonomic way. The existing debugging experience for these client hints has been described as limited and “super painful” by our internal clients. Developers cannot easily modify UA Client Hints through an accessible UI, and currently the platform does not support testing custom UA Client Hints and [UA Strings](https://developer.mozilla.org/docs/Web/HTTP/Headers/User-Agent) simultaneously, an important use case for developers. This is a high priority for the Web Platform team; they want to encourage people to switch to using Client Hints over Strings as we hypothesize it will greatly improve site compatibility and code hygiene. They’ve gotten feedback that limited testing infrastructure is a large friction point in that migration, so we are taking on this work to support developers and to improve our existing UX.  
 
 While there are many feature requests regarding UA Client Hints, the Web Platform and our team have worked together to focus on the higher impact items: 
 
diff --git a/EUDC/explainer.md b/EUDC/explainer.md
index 0ac8ecdd..3a5c1ba8 100644
--- a/EUDC/explainer.md
+++ b/EUDC/explainer.md
@@ -3,11 +3,11 @@
 
   <img src="eudc-edit-example.jpg" alt="An example of a Chinese name utilizing EUDC to combine the characters that form their name" align="right" />
 
-[End User Defined Characters (EUDC)](https://docs.microsoft.com/en-us/windows/desktop/Intl/end-user-defined-characters
+[End User Defined Characters (EUDC)](https://learn.microsoft.com/windows/desktop/Intl/end-user-defined-characters
 ) utilize the [private use area (PUA)](https://unicode-table.com/en/blocks/private-use-area/) within unicode to provide extensibility to support custom
 characters. They can be defined by the end user or another party such as an equipment manufacturer, a user group, a government body, or a font design company. Their use enables users to form names and other words using characters that are not available in standard screen and printer fonts.
 
-The EUDC font is distributed via either a TTF or TTE file ([read more here](https://docs.microsoft.com/en-us/windows/desktop/intl/character-sets-and-fonts)) which are registered via the registry as supplementing the private use range of a specific or all system fonts. Typically organizations distribute this through a group policy script.
+The EUDC font is distributed via either a TTF or TTE file ([read more here](https://learn.microsoft.com/windows/desktop/intl/character-sets-and-fonts)) which are registered via the registry as supplementing the private use range of a specific or all system fonts. Typically organizations distribute this through a group policy script.
 
 ## Evidence
   - Microsoft has received feedback to retain support for EUDC for line-of-business and government applications and for their end users to utilize pre-defined characters.
diff --git a/EditContext/dev-design.md b/EditContext/dev-design.md
index d5f3cdd2..995ac982 100644
--- a/EditContext/dev-design.md
+++ b/EditContext/dev-design.md
@@ -102,4 +102,4 @@ This class implements the WebInputMethodController interface and is also the eve
 | OS X | [Implementing Text Input Support](https://developer.apple.com/library/archive/documentation/TextFonts/Conceptual/CocoaTextArchitecture/TextEditing/TextEditing.html#//apple_ref/doc/uid/TP40009459-CH3-SW25) |
 | iOS | [Communicating with the Text Input System](https://developer.apple.com/library/archive/documentation/StringsTextFonts/Conceptual/TextAndWebiPhoneOS/LowerLevelText-HandlingTechnologies/LowerLevelText-HandlingTechnologies.html#//apple_ref/doc/uid/TP40009542-CH15-SW16) |
 | Linux | [Intelligent Input Bus (IBus) ](https://github.com/ibus/ibus/wiki)
-| Windows | [Text Services Framework](https://docs.microsoft.com/en-us/windows/desktop/TSF/text-services-framework) |
\ No newline at end of file
+| Windows | [Text Services Framework](https://learn.microsoft.com/windows/desktop/TSF/text-services-framework) |
\ No newline at end of file
diff --git a/Focusgroup/explainer.md b/Focusgroup/explainer.md
index 7d00f5ee..c6fda989 100644
--- a/Focusgroup/explainer.md
+++ b/Focusgroup/explainer.md
@@ -57,7 +57,7 @@ implementing the pattern:
 * [Rob Dodson explains roving tabindex (YouTube)](https://www.youtube.com/watch?v=uCIC2LNt0bk)
 * [roving tabindex in React](https://js.coach/package/react-roving-tabindex)
 * [Angular's ListKeyManager in the Component Dev Kit](https://material.angular.io/cdk/a11y/overview#listkeymanager)
-* [FocusZone in Fluent UI](https://developer.microsoft.com/en-us/fluentui#/controls/web/focuszone)
+* [FocusZone in Fluent UI](https://developer.microsoft.com/fluentui#/controls/web/focuszone)
 * [Elix component library's KeyboardDirectionMixin](https://component.kitchen/elix/KeyboardDirectionMixin)
 
 To achieve this goal, we believe that the solution must be done with declarative markup or CSS.
diff --git a/Foldables/explainer.md b/Foldables/explainer.md
index f452c06b..c792ef93 100644
--- a/Foldables/explainer.md
+++ b/Foldables/explainer.md
@@ -40,7 +40,7 @@ Developers may be able to solve this by taking a hard dependency on a specific d
 ### Current problems:
 More specific challenges we've heard from our internal product teams that were exploring building experiences for this emerging classes of devices include:
 
-- *Hardware differences*: Devices could be seamless (e.g. Samsung Galaxy Fold) or have a seam (e.g. [Microsoft Surface Duo](https://www.microsoft.com/en-us/surface/devices/surface-duo) or ZTE Axon M). In both cases developers might want to take it into account or intentionally ignore depending on scenario;
+- *Hardware differences*: Devices could be seamless (e.g. Samsung Galaxy Fold) or have a seam (e.g. [Microsoft Surface Duo](https://www.microsoft.com/surface/devices/surface-duo) or ZTE Axon M). In both cases developers might want to take it into account or intentionally ignore depending on scenario;
 - *Folding capabilities, state*: the fold area could be safe or unsafe region to present content;
 - *Future-proofing*: Ideally developers would want a somewhat stable way to target this class of devices without having to rely on specific device hardware parameters.
 
diff --git a/Fragments/explainer.md b/Fragments/explainer.md
index a97f9637..ef38bb75 100644
--- a/Fragments/explainer.md
+++ b/Fragments/explainer.md
@@ -78,7 +78,7 @@ CSS currently supports the `:target` pseudo-class selector, which may seem appli
 ## Open Questions/Challenges
 
 * What happens if the text contains a `#` (e.g., a hashtag)?
-* Does [generated content](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Generated_Content) get factored in?
+* Does [generated content](https://developer.mozilla.org/docs/Web/CSS/CSS_Generated_Content) get factored in?
 * Do things like text transformation, bi-directional, and mixed language modes cause issues for in-page search?
 * What are the expectations around how URL encoding/decoding is handled (e.g., `%20` for space)?
 ---
@@ -125,8 +125,8 @@ There has been some discussion over whether white space should be represented as
 ## Appendix D: Related Specifications & Concepts
 
 * Media Fragments - [https://www.w3.org/TR/media-frags/](https://www.w3.org/TR/media-frags/)
-* CSS Selectors (only to elements though) - [https://developer.mozilla.org/docs/Web/CSS/CSS_Selectors](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors)
-* XPath (only to elements though) - [https://developer.mozilla.org/docs/Web/XPath](https://developer.mozilla.org/en-US/docs/Web/XPath)
+* CSS Selectors (only to elements though) - [https://developer.mozilla.org/docs/Web/CSS/CSS_Selectors](https://developer.mozilla.org/docs/Web/CSS/CSS_Selectors)
+* XPath (only to elements though) - [https://developer.mozilla.org/docs/Web/XPath](https://developer.mozilla.org/docs/Web/XPath)
 * DOM Range - [https://developer.mozilla.org/docs/Web/API/Range](https://developer.mozilla.org/en/docs/Web/API/Range)
 * EPUB Canonical Fragment Identifiers - [http://www.idpf.org/epub/linking/cfi/epub-cfi.html](http://www.idpf.org/epub/linking/cfi/epub-cfi.html)
 * SVG IRI fragments - [https://www.w3.org/TR/SVG/linking.html#LinksIntoSVG](https://www.w3.org/TR/SVG/linking.html#LinksIntoSVG)
diff --git a/GamepadHapticsActuatorTriggerRumble/explainer.md b/GamepadHapticsActuatorTriggerRumble/explainer.md
index d636ee83..57b314ec 100644
--- a/GamepadHapticsActuatorTriggerRumble/explainer.md
+++ b/GamepadHapticsActuatorTriggerRumble/explainer.md
@@ -22,7 +22,7 @@ It is the haptic feedback effect generated by two independent motors, with one m
 
 ## Introduction
 
-Currently, there are gamepads, like the [Microsoft's Xbox](https://www.xbox.com/en-us/accessories/controllers/xbox-wireless-controller#white) and the [Razer Wolverine Ultimate](https://www.razer.com/console-controllers/razer-wolverine-ultimate/RZ06-02250100-R3U1) Controllers, which comes equipped with "impulse triggers" capable of providing trigger-rumble feedback to the user. While the [GamepadHapticActuator](https://w3c.github.io/gamepad/extensions.html#gamepadhapticactuator-interface), part of the [Gamepad Haptics Extension](https://w3c.github.io/gamepad/extensions.html) proposal, already provides support for dual-rumble effect, it does not allow developers to have access to trigger-rumble yet.
+Currently, there are gamepads, like the [Microsoft's Xbox](https://www.xbox.com/accessories/controllers/xbox-wireless-controller#white) and the [Razer Wolverine Ultimate](https://www.razer.com/console-controllers/razer-wolverine-ultimate/RZ06-02250100-R3U1) Controllers, which comes equipped with "impulse triggers" capable of providing trigger-rumble feedback to the user. While the [GamepadHapticActuator](https://w3c.github.io/gamepad/extensions.html#gamepadhapticactuator-interface), part of the [Gamepad Haptics Extension](https://w3c.github.io/gamepad/extensions.html) proposal, already provides support for dual-rumble effect, it does not allow developers to have access to trigger-rumble yet.
 
 This change will allow game developers to equip their web applications with a wider set of haptics feedback options, making it possible for their users to have a richer and more engaging experience on the web.
 
@@ -106,7 +106,7 @@ The extension to the `GamepadHapticsActuator` is a short-term solution to unbloc
 ## References
 
 [Gamepad Haptics API proposal](https://docs.google.com/document/d/1jPKzVRNzzU4dUsvLpSXm1VXPQZ8FP-0lKMT-R_p-s6g/edit#)  
-[Microsoft Xbox Controller](https://www.xbox.com/en-us/accessories/controllers/xbox-wireless-controller#white)  
+[Microsoft Xbox Controller](https://www.xbox.com/accessories/controllers/xbox-wireless-controller#white)  
 [Razer Wolverine Ultimate Controller](https://www.razer.com/console-controllers/razer-wolverine-ultimate/RZ06-02250100-R3U1)  
 [W3C Gamepad Working Draft](https://www.w3.org/TR/gamepad/#getgamepads-method)  
 [W3C Gamepad Extensions draft](https://w3c.github.io/gamepad/extensions)  
diff --git a/HTMLModules/i2i.md b/HTMLModules/i2i.md
index a1ce335b..762870a6 100644
--- a/HTMLModules/i2i.md
+++ b/HTMLModules/i2i.md
@@ -46,7 +46,7 @@ We plan to initially ship the feature behind a runtime flag so that developers c
 Other browser implementers have expressed their support of the concept and its exploration during a Web Platform WG meeting at TPAC 2018 (see meeting minutes [here](https://www.w3.org/2018/10/26-WebPlat-minutes.html#item20)).  Specifically:
 
 * **Edge**: We're strongly in favor of the feature.  Given the newly shared engine, Edge's support will arrive in a similar timeframe to Chromium.
-* **Firefox**: Expressed support at TPAC 2018.  See also [this response to our initial proposal](https://github.com/w3c/webcomponents/issues/645#issuecomment-427317492) and [this page summarizing Mozilla's stance on HTML Imports](https://developer.mozilla.org/en-US/docs/Web/Web_Components/HTML_Imports) and the [status update](https://hacks.mozilla.org/2015/06/the-state-of-web-components/) it links to that indicates their desire to pursue a solution better aligned with ES modules.
+* **Firefox**: Expressed support at TPAC 2018.  See also [this response to our initial proposal](https://github.com/w3c/webcomponents/issues/645#issuecomment-427317492) and [this page summarizing Mozilla's stance on HTML Imports](https://developer.mozilla.org/docs/Web/Web_Components/HTML_Imports) and the [status update](https://hacks.mozilla.org/2015/06/the-state-of-web-components/) it links to that indicates their desire to pursue a solution better aligned with ES modules.
 * **Safari**: Expressed support at TPAC 2018.
 * **Web / Framework developers**: The responses to [this post](https://github.com/w3c/webcomponents/issues/645#issuecomment-427205519) include a good cross-section of developer sentiment (mostly positive with some expressing concern about various details of the proposal), e.g. [[1](https://github.com/w3c/webcomponents/issues/645#issuecomment-427395178)], [[2](https://github.com/w3c/webcomponents/issues/645#issuecomment-427446523)], [[3](https://github.com/w3c/webcomponents/issues/645#issuecomment-433036372)].
 * **See also**: [Google presentation](https://docs.google.com/presentation/d/1ksnC9Qr3c8RwbDyo1G8ZZSVOEfXpnfQsTHhR5ny9Wk4/edit#slide=id.gc6fa3c898_0_0) at BlinkOn about the idea of HTML Modules as a replacement for HTML Imports.
diff --git a/HapticsDevice/explainer.md b/HapticsDevice/explainer.md
index 3daa7455..5a36953a 100644
--- a/HapticsDevice/explainer.md
+++ b/HapticsDevice/explainer.md
@@ -21,7 +21,7 @@ In today's device ecosystem, there are several types of haptic-enabled surfaces:
 * Game/XR controllers
 * Peripheral hardware such as [Surface Dial](https://www.microsoft.com/p/surface-dial/925r551sktgn)
 
-While solutions such as [navigator.vibrate()](https://developer.mozilla.org/en-US/docs/Web/API/Navigator/vibrate) and [GamepadHapticActuator](https://developer.mozilla.org/en-US/docs/Web/API/GamepadHapticActuator) aim to expose a limited set of these haptic capabilities to the web, web developers today do not have the ability to harness the majority of these surfaces as they do on native platforms. This prevents them from building tactile experiences that physically engage users, help them understand when critical activities have succeeded or failed, or immerse them by simulating [virtual textures](https://source.android.com/devices/input/haptics/haptics-ux-design#virtual-texture)/actions.
+While solutions such as [navigator.vibrate()](https://developer.mozilla.org/docs/Web/API/Navigator/vibrate) and [GamepadHapticActuator](https://developer.mozilla.org/docs/Web/API/GamepadHapticActuator) aim to expose a limited set of these haptic capabilities to the web, web developers today do not have the ability to harness the majority of these surfaces as they do on native platforms. This prevents them from building tactile experiences that physically engage users, help them understand when critical activities have succeeded or failed, or immerse them by simulating [virtual textures](https://source.android.com/devices/input/haptics/haptics-ux-design#virtual-texture)/actions.
 
 This explainer defines a new Haptics API with the aim of meeting the following goals:
 
@@ -184,7 +184,7 @@ The following section enumerates the potential privacy concerns identified durin
 | :- | :- | :- |
 | Fingerprinting of predefined waveforms | As called out in the [Alternative Solutions](#alternative-solutions) section below, the original draft of this proposal included a `HapticsDevice.getSupportedWaveforms()` function that would allow web developers to query a list of predefined waveforms supported by a particular `HapticsDevice`. This would have introduced fingerprinting concerns, however, as the waveforms supported by specific pointer devices may vary by OEM, thus providing bits of entropy. | The current solution is to agree on a common set of waveforms that will be standard across all haptic implementations. See [Open Questions](#open-questions) for more information.
 | Fingerprinting of successful haptic playback | As called out in the [Open Questions](#open-questions) section, it is still TBD whether this API should expose a mechanism for informing developers whether the waveform they attempted to fire played successfully. While this would have uses from a developer ergonomics perspective, it could be used to fingerprint various device capabilities. | The current draft of this proposal does not include a mechanism for informing developers whether the waveform they attempted to fire played successfully.
-| Fingerprinting of device capabilities | As called out in the [Open Questions](#open-questions) section, it is still TBD whether this API should expose a mechanism for developers to query whether certain haptic capabilities (intensity, play count, repeat, etc.) are supported by a given pointer/haptic device. While native platforms expose this today ([Android](https://developer.android.com/reference/android/os/Vibrator), [iOS](https://developer.apple.com/documentation/corehaptics/chhapticengine/3081788-capabilitiesforhardware), [Windows](https://docs.microsoft.com/uwp/api/windows.devices.haptics.simplehapticscontroller)), exposing these on the web would reveal bits of entropy that could be used for fingerprinting. | The current draft of this proposal does not include a mechanism for developers to query whether certain haptic capabilities are supported by a given pointer/haptic device.
+| Fingerprinting of device capabilities | As called out in the [Open Questions](#open-questions) section, it is still TBD whether this API should expose a mechanism for developers to query whether certain haptic capabilities (intensity, play count, repeat, etc.) are supported by a given pointer/haptic device. While native platforms expose this today ([Android](https://developer.android.com/reference/android/os/Vibrator), [iOS](https://developer.apple.com/documentation/corehaptics/chhapticengine/3081788-capabilitiesforhardware), [Windows](https://learn.microsoft.com/uwp/api/windows.devices.haptics.simplehapticscontroller)), exposing these on the web would reveal bits of entropy that could be used for fingerprinting. | The current draft of this proposal does not include a mechanism for developers to query whether certain haptic capabilities are supported by a given pointer/haptic device.
 
 ### Security
 
diff --git a/Media/MFCdm/explainer.md b/Media/MFCdm/explainer.md
index 4a59bf9b..f8f46add 100644
--- a/Media/MFCdm/explainer.md
+++ b/Media/MFCdm/explainer.md
@@ -6,7 +6,7 @@
 
 # Summary
 An MF based DRM system can provide a highly secure, trusted and
-robust environment that premium media content providers expect to distribute high-value protected media. We propose additions to enable the integration of MF based DRM systems into Chromium. More details on MF based DRM systems can be found at [Protected Media Path (PMP)](https://docs.microsoft.com/en-us/windows/win32/medfound/protected-media-path).
+robust environment that premium media content providers expect to distribute high-value protected media. We propose additions to enable the integration of MF based DRM systems into Chromium. More details on MF based DRM systems can be found at [Protected Media Path (PMP)](https://learn.microsoft.com/windows/win32/medfound/protected-media-path).
 
 # Goals
 * Adding the support of specific MF based DRM systems into Chromium - this is done by writing an MF based CDM provider.
@@ -30,7 +30,7 @@ Components as seen from the media  [Encrypted Media Extensions (EME)](https://ww
 
 ### Component Interactions
 In terms of functionalities, 4 major components can be identified:
-1. In the Renderer process, a MFCdmSwitchingRenderer selects the Chromium DefaultRenderer by default. When the content is known to be protected media and the given key system is implemented by a MF based CDM, a MFMediaEngineRendererClient will be used as the media Renderer. The MFMediaEngineRendererClient and MFMediaEngineRenderer classes are specializations of FooRendererClient/FooRenderer pair as described in the "Specialized Out-of-Process media::Renderers" section of [media/mojo](https://chromium.googlesource.com/chromium/src/media/+/master/mojo/) document. The protected media data from the RenderClient side is pulled by the MFMediaEngineRenderer which in turn acts as a custom [IMFMediaSource](https://docs.microsoft.com/en-us/windows/win32/api/mfidl/nn-mfidl-imfmediasource) passing the media data to an [IMFMediaEngine](https://docs.microsoft.com/en-us/windows/win32/api/mfmediaengine/nn-mfmediaengine-imfmediaengine) instance.
+1. In the Renderer process, a MFCdmSwitchingRenderer selects the Chromium DefaultRenderer by default. When the content is known to be protected media and the given key system is implemented by a MF based CDM, a MFMediaEngineRendererClient will be used as the media Renderer. The MFMediaEngineRendererClient and MFMediaEngineRenderer classes are specializations of FooRendererClient/FooRenderer pair as described in the "Specialized Out-of-Process media::Renderers" section of [media/mojo](https://chromium.googlesource.com/chromium/src/media/+/master/mojo/) document. The protected media data from the RenderClient side is pulled by the MFMediaEngineRenderer which in turn acts as a custom [IMFMediaSource](https://learn.microsoft.com/windows/win32/api/mfidl/nn-mfidl-imfmediasource) passing the media data to an [IMFMediaEngine](https://learn.microsoft.com/windows/win32/api/mfmediaengine/nn-mfmediaengine-imfmediaengine) instance.
 
 2. Since the MF based CDM binary contains third-party code, we have added the creation of a Less Privileged AppContainer (LPAC) MF CDM Utility process to sandbox it. In this LPAC process, there are two new components. A MFMediaEngineRenderer component integrates with an instance of IMFMediaEngine rendering pipeline. A MF CDM Adapter component instantiates the MF based CDM and acts as a translation layer between this CDM and the Chromium CDM adapter.
 
diff --git a/Notifications/notifications_actions_customization.md b/Notifications/notifications_actions_customization.md
index d24e0338..ec549e55 100644
--- a/Notifications/notifications_actions_customization.md
+++ b/Notifications/notifications_actions_customization.md
@@ -151,7 +151,7 @@ However, this approach was not proposed as the main one because the only platfor
 
 ### Play Ringtone from Inside the Tab
 
-Previouly, the `sound` property was part of the Notifications API specification, but was removed mainly due to the lack of support across many platforms (refer to the discussion [here](https://github.com/whatwg/notifications/pull/127)). [Windows](https://docs.microsoft.com/en-us/windows/apps/design/shell/tiles-and-notifications/custom-audio-on-toasts#add-the-custom-audio), [Mac OS and iOS](https://developer.apple.com/documentation/usernotifications/unnotificationsound) allow the notifications to play custom sound, but the audio files should be stored beforehand in the local system. Besides that, it seems not possible to provide an audio file from the Web in any platform.
+Previouly, the `sound` property was part of the Notifications API specification, but was removed mainly due to the lack of support across many platforms (refer to the discussion [here](https://github.com/whatwg/notifications/pull/127)). [Windows](https://learn.microsoft.com/windows/apps/design/shell/tiles-and-notifications/custom-audio-on-toasts#add-the-custom-audio), [Mac OS and iOS](https://developer.apple.com/documentation/usernotifications/unnotificationsound) allow the notifications to play custom sound, but the audio files should be stored beforehand in the local system. Besides that, it seems not possible to provide an audio file from the Web in any platform.
 
 An option to circumvent this issue would be to trigger a silent notification, the moment the user receives an incoming call in the web app, and then play the custom audio inside the tab. However, synchronicity problems might arise with the audio starting to play before or after the notification showing up in the screen.
 
diff --git a/OriginTrialsGuide/explainer.md b/OriginTrialsGuide/explainer.md
index 4050cd8a..9751ee36 100644
--- a/OriginTrialsGuide/explainer.md
+++ b/OriginTrialsGuide/explainer.md
@@ -11,7 +11,7 @@ Once you have registered your website for an experiment, you will be able to use
 # Getting Started
 ## Browse Available Experiments
 
-You can visit the [Edge Origin Trials Developer Console](https://developer.microsoft.com/en-us/microsoft-edge/origin-trials) to see a list of the experimental APIs Edge browser engineers are offering and would like to you try and give them feedback on.
+You can visit the [Edge Origin Trials Developer Console](https://developer.microsoft.com/microsoft-edge/origin-trials) to see a list of the experimental APIs Edge browser engineers are offering and would like to you try and give them feedback on.
 
 ## Register for an Experiment
 Our framework is consistent with [Chrome Origin Trials](https://developers.chrome.com/origintrials/#/trials/active), simply click the `register` button for any of the available experiments in our Origin Trials Developer console, provide your website's origin, and we will instantly generate a token once you agree to our terms and conditions and submit the form.
@@ -43,7 +43,7 @@ The Edge Origin Trials portal today **only supports SSL Enabled Origins**, websi
 
 ## Subdomains, URL Paths and Query Params
 
-It is possible to only enroll a specific subdomain such as `https://dev.example.com` or an origin with wild-card match to all it's subdomains by answering *Yes* to the "Do you need to match all subdomains for the provided origin?" question in the [Microsoft Edge Origin Trials Developer Console](https://developer.microsoft.com/en-us/microsoft-edge/origin-trials). However, the following scenarios are **not** possible:
+It is possible to only enroll a specific subdomain such as `https://dev.example.com` or an origin with wild-card match to all it's subdomains by answering *Yes* to the "Do you need to match all subdomains for the provided origin?" question in the [Microsoft Edge Origin Trials Developer Console](https://developer.microsoft.com/microsoft-edge/origin-trials). However, the following scenarios are **not** possible:
 
 - `https://example.com/path/new-feature`
 - `https://example.com/path/new-feature?test_id=12345`
@@ -66,4 +66,4 @@ To opt out of an experiment, you can simply remove the token we have provided fr
 
 ## Experimental feature implementation best practices
 
-MDN has a great resource on best practices for feature detection, you can [view it here](https://developer.mozilla.org/en-US/docs/Learn/Tools_and_testing/Cross_browser_testing/Feature_detection). In summary, it is important to always provide a working experience if the feature your website is using does not exist in the browser your visitor is running, this is extremely applicable when relying on an experimental feature using a token that needs to be renewed every 6 weeks.
\ No newline at end of file
+MDN has a great resource on best practices for feature detection, you can [view it here](https://developer.mozilla.org/docs/Learn/Tools_and_testing/Cross_browser_testing/Feature_detection). In summary, it is important to always provide a working experience if the feature your website is using does not exist in the browser your visitor is running, this is extremely applicable when relying on an experimental feature using a token that needs to be renewed every 6 weeks.
\ No newline at end of file
diff --git a/PWAWidgets/README.md b/PWAWidgets/README.md
index c31b7986..96c19d15 100644
--- a/PWAWidgets/README.md
+++ b/PWAWidgets/README.md
@@ -253,7 +253,7 @@ A Manifest’s [`theme_color`](https://w3c.github.io/manifest/#theme_color-membe
 
 Some widget platforms may wish to allow developers to further refine a Widget’s appearance and/or functionality within their system. We recommend that those platforms use [the extensibility of the Manifest](https://www.w3.org/TR/appmanifest/#extensibility) to allow developers to encode their widgets with this additional information, if they so choose.
 
-For example, if using something like [Adaptive Cards](https://docs.microsoft.com/en-us/adaptive-cards/templating/) for rendering, a [Widget Host](#dfn-widget-host) might consider adding something like the following to the `WidgetDefinition`:
+For example, if using something like [Adaptive Cards](https://learn.microsoft.com/adaptive-cards/templating/) for rendering, a [Widget Host](#dfn-widget-host) might consider adding something like the following to the `WidgetDefinition`:
 
 ```json
 "ms_ac_template": "/widgets/templates/agenda.ac.json",
diff --git a/PerformanceNavigationTimingProtocolLaunchExtensions/explainer.md b/PerformanceNavigationTimingProtocolLaunchExtensions/explainer.md
index 597e72ac..aae9490c 100644
--- a/PerformanceNavigationTimingProtocolLaunchExtensions/explainer.md
+++ b/PerformanceNavigationTimingProtocolLaunchExtensions/explainer.md
@@ -29,12 +29,12 @@ The proposed changes in this document aim to enable the web applications to:
 * A user clicking on a link in a non-web email client that leads to starting a new navigation in an existing instance of the user agent.
 
 ## Proposed Solution
-As part of the proposed solution, a client application initiating the protocol launch will need to capture and provide the timestamp for the user action as a command line parameter. This timestamp will need to be based on a monotonic increasing clock that is not subject to system clock adjustments or system clock skew. This timestamp will also need to be in a format that can be correlated with other timestamps collected in the browser processes. For example, on Windows we propose using something akin to [QueryPerformanceCounter](https://docs.microsoft.com/en-us/windows/win32/sysinfo/acquiring-high-resolution-time-stamps). Both these timestamps; the user action timestamp captured in the client application and the application start timestamp captured in the browser process; are then converted to a [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp). The conversion to [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp) reduces the possibility of timing attacks by setting the resolution to 5 microseconds.
+As part of the proposed solution, a client application initiating the protocol launch will need to capture and provide the timestamp for the user action as a command line parameter. This timestamp will need to be based on a monotonic increasing clock that is not subject to system clock adjustments or system clock skew. This timestamp will also need to be in a format that can be correlated with other timestamps collected in the browser processes. For example, on Windows we propose using something akin to [QueryPerformanceCounter](https://learn.microsoft.com/windows/win32/sysinfo/acquiring-high-resolution-time-stamps). Both these timestamps; the user action timestamp captured in the client application and the application start timestamp captured in the browser process; are then converted to a [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp). The conversion to [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp) reduces the possibility of timing attacks by setting the resolution to 5 microseconds.
 
 This strategy to collect timestamps in different processes and converting to [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp) is not new and has been the motivation for introduction of the [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp). This mechanism is part of the [High Resolution Time Level 2](https://www.w3.org/TR/hr-time-2/#introduction) specification that addresses many such scenarios for browser developers and web application developers where they need to obtain high resolution timing information including but not limited to evaluating performance of various parts of their applications.
 
 ### PerformanceNavigationTiming
-To help web applications compute end-to-end telemetry for protocol launches we propose adding 2 new fields userAgentStart and protocolLaunchStart to the [PerformanceNavigationTiming](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigationTiming) object. The parameter userAgentStart corresponds to a timestamp captured early in the startup of the browser application. The parameter protocolLaunchStart corresponds to the user action that initiated the protocol launch in the non-browser client application. For cold starts; when no browser process has yet been created; the protocolLaunchStart value will be lesser than the userAgentStart value. For warm starts; where one or more browser processes are already running; the protocolLaunchStart value may be higher than the userAgentStart value. These new fields are only populated for protocol launches. It could be further restricted to specific domains through origin trial.
+To help web applications compute end-to-end telemetry for protocol launches we propose adding 2 new fields userAgentStart and protocolLaunchStart to the [PerformanceNavigationTiming](https://developer.mozilla.org/docs/Web/API/PerformanceNavigationTiming) object. The parameter userAgentStart corresponds to a timestamp captured early in the startup of the browser application. The parameter protocolLaunchStart corresponds to the user action that initiated the protocol launch in the non-browser client application. For cold starts; when no browser process has yet been created; the protocolLaunchStart value will be lesser than the userAgentStart value. For warm starts; where one or more browser processes are already running; the protocolLaunchStart value may be higher than the userAgentStart value. These new fields are only populated for protocol launches. It could be further restricted to specific domains through origin trial.
 
 A typical response for `performance.getEntriesByType("navigation")` will produce something like:
 ```javascript
@@ -94,12 +94,12 @@ if (navigationEntries.length > 0) {
 ```
 Additional guidance:
 
-* The new timing fields added by this change protocolLaunchStart and userAgentStart have the same format as other timing fields such as [loadEventStart](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming/loadEventStart) and represents a [DOMHighResTimeStamp](https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp). 
+* The new timing fields added by this change protocolLaunchStart and userAgentStart have the same format as other timing fields such as [loadEventStart](https://developer.mozilla.org/docs/Web/API/PerformanceTiming/loadEventStart) and represents a [DOMHighResTimeStamp](https://developer.mozilla.org/docs/Web/API/DOMHighResTimeStamp). 
 
 ## Privacy and Security Considerations
 
 ### Privacy
-Adding additional timing fields to PerformanceNavigationTiming does add new attributes to an existing fingerprinting surface as these are high resolution timestamps. However, this does not significantly change the timing related fingerprinting risk as there are other multiple such timing fields exposed through this API. The conversion to [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp) reduces the possibility of timing attacks by setting the resolution to 5 microseconds. As with the other such fields this also makes it possible to determine device performance characteristics. In addition, the web application can interpret the values for these new timing fields to determine if the user agent was launched anew (cold start) or was already running (warm start). However, this information is already available to applications through other mechanisms and is considered low risk. For example, this could be done using certain [Win32 APIs](https://docs.microsoft.com/en-us/windows/win32/toolhelp/taking-a-snapshot-and-viewing-processes)
+Adding additional timing fields to PerformanceNavigationTiming does add new attributes to an existing fingerprinting surface as these are high resolution timestamps. However, this does not significantly change the timing related fingerprinting risk as there are other multiple such timing fields exposed through this API. The conversion to [DOMHighResTimeStamp](https://www.w3.org/TR/hr-time-2/#dom-domhighrestimestamp) reduces the possibility of timing attacks by setting the resolution to 5 microseconds. As with the other such fields this also makes it possible to determine device performance characteristics. In addition, the web application can interpret the values for these new timing fields to determine if the user agent was launched anew (cold start) or was already running (warm start). However, this information is already available to applications through other mechanisms and is considered low risk. For example, this could be done using certain [Win32 APIs](https://learn.microsoft.com/windows/win32/toolhelp/taking-a-snapshot-and-viewing-processes)
 
 An analysis of fingerprinting capability provided by this surface suggests some impact.
 
diff --git a/PointerEventDeviceId/explainer.md b/PointerEventDeviceId/explainer.md
index 65ee605f..74ce5706 100644
--- a/PointerEventDeviceId/explainer.md
+++ b/PointerEventDeviceId/explainer.md
@@ -105,4 +105,4 @@ The following section enumerates the potential privacy concerns identified durin
 ## References
 [PointerEvent interface](https://w3c.github.io/pointerevents/#pointerevent-interface)
 
-[WinRT PenDevice.PenId Property](https://docs.microsoft.com/en-us/uwp/api/windows.devices.input.pendevice.penid?view=winrt-22000)
+[WinRT PenDevice.PenId Property](https://learn.microsoft.com/uwp/api/windows.devices.input.pendevice.penid?view=winrt-22000)
diff --git a/Popup/explainer.md b/Popup/explainer.md
index f456194f..12a96e8a 100644
--- a/Popup/explainer.md
+++ b/Popup/explainer.md
@@ -318,7 +318,7 @@ Freedom over the size and position of a `popup` could enable an author to spoof
 
 ## Open questions
 
-1. **Collision with CSS contain.** It’s worth noting that using the [`contain` CSS property](https://developer.mozilla.org/en-US/docs/Web/CSS/contain) on an ancestor of `popup` will prevent `popup` from being positioned and painted correctly. How common is this use case? How might the platform resolve this unintentional effect?
+1. **Collision with CSS contain.** It’s worth noting that using the [`contain` CSS property](https://developer.mozilla.org/docs/Web/CSS/contain) on an ancestor of `popup` will prevent `popup` from being positioned and painted correctly. How common is this use case? How might the platform resolve this unintentional effect?
 
 2. **Could we require popups to use the DOM hierarchy for event propagation and establishing hierarchical popup relationships?** Elements used for popup UI today are frequently appended to the end of the DOM to ensure they appear on top of other UI. With the new capabilities of the `popup` element, that isn't necessary, yet we still assume in this proposal that DOM positioning of the `popup` needs to be separate from the anchor. One reason why that might still be needed is for anchor elements that can't accept a `popup` descendant, for example, image or input elements or custom-elements that expect a particular content model. Eliminating this requirement would also eliminate the complexity to modify the event propagation path based on the anchor attribute, and would make hierarchical relationships between popups clear just by observing the DOM hierarchy.
 
diff --git a/PwaUriHandler/explainer.md b/PwaUriHandler/explainer.md
index e42e4898..34ea5503 100644
--- a/PwaUriHandler/explainer.md
+++ b/PwaUriHandler/explainer.md
@@ -59,7 +59,7 @@ We propose the following:
 
 **Changes 1-4** allow PWAs to handle URL activations at the browser level, which means that as long as a URL activation (clicking on a link) launches a conforming browser, the browser has the ability to launch the matching PWA. A PWA will not be launched if it was installed through a non-default browser and all URL activations launch the default browser.
 
-To allow PWAs to handle URLs that are outside of their own scope, it is necessary to introduce a mechanism for the owner of those URLs to opt-in to URL handling by PWAs. **Change 2** introduces the concept of a `pwa-site-association` file that will serve this purpose. This file is similar to the [Apple App Site Association File](https://developer.apple.com/documentation/safariservices/supporting_associated_domains_in_your_app#3001215), the [`assetlinks.json`](https://developer.android.com/training/app-links/verify-site-associations) file in Android, and the [`windows-app-web-link`](https://docs.microsoft.com/en-us/windows/uwp/launch-resume/web-to-app-linking#associate-your-app-and-website-with-a-json-file) file in Windows. What differs, is that the `pwa-site-association` file does not require a platform specific app id, but instead identifies PWAs by their web app manifest URL.
+To allow PWAs to handle URLs that are outside of their own scope, it is necessary to introduce a mechanism for the owner of those URLs to opt-in to URL handling by PWAs. **Change 2** introduces the concept of a `pwa-site-association` file that will serve this purpose. This file is similar to the [Apple App Site Association File](https://developer.apple.com/documentation/safariservices/supporting_associated_domains_in_your_app#3001215), the [`assetlinks.json`](https://developer.android.com/training/app-links/verify-site-associations) file in Android, and the [`windows-app-web-link`](https://learn.microsoft.com/windows/uwp/launch-resume/web-to-app-linking#associate-your-app-and-website-with-a-json-file) file in Windows. What differs, is that the `pwa-site-association` file does not require a platform specific app id, but instead identifies PWAs by their web app manifest URL.
 
 **Change 5** will also allow PWAs to handle URL activations at the OS level on supportive platforms. If the PWA is able to register as a URL handler with the OS, it could be launched whenever a URL activation is handled by the OS, regardless of the default browser setting. Most native applications rely on the OS for URL activation. In terms of user experience, the OS could now prompt the user to choose between the PWA and the default browser using the system app disambiguation dialog. The user is able to make an explicit choice to select the PWA and configure their default setting from there. (Implementation note: because most OSes do not know of or treat PWAs as first-class applications, it may not be possible to register them directly with the OS as URL handlers. Supporting changes will need to be made in PWA implementation and/or in the OS to enable this. A notable exception is Chrome's implementation of PWAs on Android using `WebAPK`. Because `WebAPK`s are recognized by the Android OS, Chrome PWAs are able to fully integrate with OS features like the app picker.)
 
@@ -231,13 +231,13 @@ URL handler registrations should only be performed for installed PWAs as users e
 
 As websites are currently unable to launch URL handlers through normal in-browser navigation, we do not anticipate third-party websites being able to leverage this API to detect which PWAs the user has installed. Although not an immediate privacy concern, fingerprinting risks should be thoroughly examined when designing web APIs that activate URL handlers instead of performing in-browser navigation.
 
-Native applications can already use OS APIs to enumerate installed applications on the user's system. For example, native applications in Windows can use the [FindAppUriHandlersAsync](https://docs.microsoft.com/en-us/uwp/api/windows.system.launcher.findappurihandlersasync) API to enumerate URL handlers. If PWAs register as OS level URL handlers in Windows, their presence would be visible to other applications.
+Native applications can already use OS APIs to enumerate installed applications on the user's system. For example, native applications in Windows can use the [FindAppUriHandlersAsync](https://learn.microsoft.com/uwp/api/windows.system.launcher.findappurihandlersasync) API to enumerate URL handlers. If PWAs register as OS level URL handlers in Windows, their presence would be visible to other applications.
 
 ## OS Specific Implementation Notes
 
 ### Windows
 
-Starting from the Windows 10 Anniversary update, Windows enabled an ["Apps for Websites"](https://docs.microsoft.com/en-us/windows/uwp/launch-resume/web-to-app-linking) capability that allowed the registration of apps to handle URLs from associated websites.
+Starting from the Windows 10 Anniversary update, Windows enabled an ["Apps for Websites"](https://learn.microsoft.com/windows/uwp/launch-resume/web-to-app-linking) capability that allowed the registration of apps to handle URLs from associated websites.
 
 ### Android
 
diff --git a/RangeInnerText/explainer.md b/RangeInnerText/explainer.md
index 481c9fef..0528ba89 100644
--- a/RangeInnerText/explainer.md
+++ b/RangeInnerText/explainer.md
@@ -24,7 +24,7 @@ painted with certain effects applied.
 Ranges are somewhat limited in capabilities for advanced editing scenarios.
 While Ranges expose information about the rendering of the contained text via
 client rect(s), they only expose the text content (not the visible text &mdash;
-see [differences](https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent#differences_from_innertext)) of the Range to script via `toString()`.
+see [differences](https://developer.mozilla.org/docs/Web/API/Node/textContent#differences_from_innertext)) of the Range to script via `toString()`.
 
 Complex editing applications on the Web will typically want to operate on
 the visible text, which in turn requires the use of heuristics to map
@@ -33,7 +33,7 @@ the computed innerText back to DOM Ranges.
 Creating an interoperable find-on-page feature exposes the difficulties in
 trying to use heuristics to perform this mapping.
 Performing the find without using the non-standard
-[`window.find()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/find)
+[`window.find()`](https://developer.mozilla.org/docs/Web/API/Window/find)
 API requires computing matches based on the visible text. In order to visually
 highlight the matches, authors then must determine where the string matches that
 were found to live in the DOM. This becomes difficult to manage when there is
diff --git a/RatingsAndReviewsPrompt/explainer.md b/RatingsAndReviewsPrompt/explainer.md
index c7aa9aff..a58381cf 100644
--- a/RatingsAndReviewsPrompt/explainer.md
+++ b/RatingsAndReviewsPrompt/explainer.md
@@ -46,7 +46,7 @@ Each app catalog provides its own API for triggering an app review flow within t
 
 * [Apple’s Store Kit](https://developer.apple.com/app-store/ratings-and-reviews/) provides `SKStoreReviewController.requestReview()`
 * Google’s Play Store provides this functionality in multiple languages: [C++](https://developer.android.com/guide/playcore/in-app-review/native) (`ReviewManager_requestReviewFlow`), [Java and Kotlin](https://developer.android.com/guide/playcore/in-app-review/kotlin-java) (`ReviewManager.requestReviewFlow()`), and [Unity](https://developer.android.com/guide/playcore/in-app-review/unity) (`ReviewManager.RequestReviewFlow()`).
-* Microsoft’s Store provides this functionality in multiple languages using [`RequestRateAndReviewAppAsync` and the proprietary URL protocol `ms-windows-store`](https://docs.microsoft.com/en-us/windows/uwp/monetize/request-ratings-and-reviews).
+* Microsoft’s Store provides this functionality in multiple languages using [`RequestRateAndReviewAppAsync` and the proprietary URL protocol `ms-windows-store`](https://learn.microsoft.com/windows/uwp/monetize/request-ratings-and-reviews).
 
 
 ## API Proposal
diff --git a/Shortcuts/explainer.md b/Shortcuts/explainer.md
index ee9ceadf..a7434254 100644
--- a/Shortcuts/explainer.md
+++ b/Shortcuts/explainer.md
@@ -82,7 +82,7 @@ This menu provides direct access to:
 
 ### Customer validation
 
-* **Twitter** is actively using [Windows’ "Jump Lists" feature](https://docs.microsoft.com/en-us/uwp/api/Windows.UI.StartScreen.JumpList) in their PWA via WinRT (see [the above example](#twitter)).
+* **Twitter** is actively using [Windows’ "Jump Lists" feature](https://learn.microsoft.com/uwp/api/Windows.UI.StartScreen.JumpList) in their PWA via WinRT (see [the above example](#twitter)).
 * **Starbucks** has also expressed interest in increasing re-engagement with their PWA by providing quick access to options like:
   * Pay with your Starbucks card,
   * Place an order, and
@@ -240,7 +240,7 @@ In iOS, a hard press (3D Touch) exposes the application shortcuts (iOS 9.0+ on 3
 
 ### macOS/Windows/Linux GUI/etc.
 
-In most OSes, this context menu is triggered by right clicking (or two finger tapping) on the icon. Windows calls these "Jump Lists" and allows each shortcut item to have a description ([Documentation](https://docs.microsoft.com/en-us/uwp/api/windows.ui.startscreen.jumplist)). In macOS these shortcuts are referred to as the "Dock Menu" ([Documentation](https://developer.apple.com/design/human-interface-guidelines/macos/menus/dock-menus/)).
+In most OSes, this context menu is triggered by right clicking (or two finger tapping) on the icon. Windows calls these "Jump Lists" and allows each shortcut item to have a description ([Documentation](https://learn.microsoft.com/uwp/api/windows.ui.startscreen.jumplist)). In macOS these shortcuts are referred to as the "Dock Menu" ([Documentation](https://developer.apple.com/design/human-interface-guidelines/macos/menus/dock-menus/)).
 
 ### Electron
 
diff --git a/StorageAccessAPI/explainer.md b/StorageAccessAPI/explainer.md
index 41eec34b..d5ca8a51 100644
--- a/StorageAccessAPI/explainer.md
+++ b/StorageAccessAPI/explainer.md
@@ -27,7 +27,7 @@ Users shouldn't have to compromise between privacy protections and enabling site
 ## Existing Implementations & Discussions
 Current implementations: Firefox, Safari
 
-MDN: https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API
+MDN: https://developer.mozilla.org/docs/Web/API/Storage_Access_API
 
 WHATWG discussions:
 - https://github.com/whatwg/html/issues/3338
@@ -95,7 +95,7 @@ A root document, https://example.site, embeds an iframe from https://socialmedia
     - This allows content to seamlessly work for a reasonable period of time after explicit interaction and consent has been obtained, allowing it to function in subsequent loads without re-prompting the user.
 
 ## Implementation Considerations
-There are two existing similar implementations with minor differences (Firefox, and Safari), documented at https://developer.mozilla.org/en-US/docs/Web/API/Storage_Access_API#Safari_implementation_differences.
+There are two existing similar implementations with minor differences (Firefox, and Safari), documented at https://developer.mozilla.org/docs/Web/API/Storage_Access_API#Safari_implementation_differences.
 The intent is to follow common implementation patterns between the two implementations. Where differences exist or more favorable Chromium mechanisms exist (e.g. site-engagement scores) a preference towards being minimally invasive for the user (e.g. few, or no prompts) and maintaining functional web experiences will be taken. There are a number of considerations discussed by various Chromium implementors and browser vendors in the WHATWG discussion (https://github.com/whatwg/html/issues/3338). The intent is to take these concerns, feedback, and considerations into account when making design decisions in areas that differ between implementations.
 
 ---
diff --git a/TSF1/explainer.md b/TSF1/explainer.md
index 99d080c7..394aea64 100644
--- a/TSF1/explainer.md
+++ b/TSF1/explainer.md
@@ -47,8 +47,8 @@ We welcome your feedback and opinion on ways we can help improve Chromium text i
 ## Links:
 
 * Issue 657623: Using TSF instead of IMM32 in the IMF on Windows: https://crbug.com/657623
-* About Text Services Framework: https://docs.microsoft.com/en-us/windows/desktop/TSF/about-text-services-framework
-* Text Services Framework Reference: https://docs.microsoft.com/en-us/windows/desktop/TSF/text-services-framework-reference
+* About Text Services Framework: https://learn.microsoft.com/windows/desktop/TSF/about-text-services-framework
+* Text Services Framework Reference: https://learn.microsoft.com/windows/desktop/TSF/text-services-framework-reference
 
 ---
 [Related issues](https://github.com/MicrosoftEdge/MSEdgeExplainers/labels/TSF%201.0) | [Open a new issue](https://github.com/MicrosoftEdge/MSEdgeExplainers/issues/new?title=%5BTSF%201.0%5D)
diff --git a/TitleBarCustomization/explainer.md b/TitleBarCustomization/explainer.md
index 9bae1f87..99e4e091 100644
--- a/TitleBarCustomization/explainer.md
+++ b/TitleBarCustomization/explainer.md
@@ -29,7 +29,7 @@ This document is intended as a starting point for engaging the community and sta
 
 ## Introduction 
 
-Installed web apps hosted within a user agent (UA) frame are able to declare which browser display mode best meets the needs of the application via the manifest file's [`display` member](https://developer.mozilla.org/en-US/docs/Web/Manifest/display). Currently, there are 4 supported values and their behaviors on Chromium browsers are described below:
+Installed web apps hosted within a user agent (UA) frame are able to declare which browser display mode best meets the needs of the application via the manifest file's [`display` member](https://developer.mozilla.org/docs/Web/Manifest/display). Currently, there are 4 supported values and their behaviors on Chromium browsers are described below:
 - `fullscreen`: All of the available display is used and no UA chrome is shown. This is implemented only for mobile devices running Android or iOS.
 - `standalone`: The web app looks like a standalone application. The title bar includes the title of the application, a web app menu button, and window control buttons (minimize, maximize/restore, close). 
 - `minimal-ui`: Similar to `standalone`, except it also contains a back and refresh button. 
@@ -66,7 +66,7 @@ Contrast the above examples of popular desktop applications with the current lim
 
 ![Installed Web app title bar not available for content](TwitterStandalone.png)
 
-- The UA supplied title bar is styled by the browser (with input from the developer via the manifest's [`"display"`](https://developer.mozilla.org/en-US/docs/Web/Manifest/display) and [`"theme_color"`](https://developer.mozilla.org/en-US/docs/Web/Manifest/theme_color))
+- The UA supplied title bar is styled by the browser (with input from the developer via the manifest's [`"display"`](https://developer.mozilla.org/docs/Web/Manifest/display) and [`"theme_color"`](https://developer.mozilla.org/docs/Web/Manifest/theme_color))
 - The 3-dot menu is displayed beside the window controls
 
 None of this area is available to application developers. This is a problem where 
@@ -135,7 +135,7 @@ The bounding rectangle and the visibility of the window controls overlay will ne
 To provide the visibility and bounding rectangle of the overlay, this explainer proposes a new object on the `window.navigator` property called `windowControlsOverlay`.
 
 `windowControlsOverlay` would make available the following objects:
-* `getBoundingClientRect()` which would return a [`DOMRect`](https://developer.mozilla.org/en-US/docs/Web/API/DOMRect) that represents the area under the window controls overlay. Interactive web content should not be displayed beneath the overlay.
+* `getBoundingClientRect()` which would return a [`DOMRect`](https://developer.mozilla.org/docs/Web/API/DOMRect) that represents the area under the window controls overlay. Interactive web content should not be displayed beneath the overlay.
 * `visible` a boolean to determine if the window controls overlay has been rendered
 
 For privacy, the `windowControlsOverlay` will not be accessible to iframes inside of a webpage. See [Privacy Considerations](#privacy-considerations) below
@@ -145,7 +145,7 @@ Whenever the overlay is resized, a `geometrychange` event will be fired on the `
 #### CSS Environment Variables
 Although it's possible to layout the content of the title bar and web page with just the JavaScript APIs provided above, they are not as responsive as a CSS solution. This is problematic either when the overlay resizes to accommodate the origin text or a new extension icon populates the overlay, or when the window resizes.
 
-The solution is to treat the overlay like a notch in a phone screen and layout the title bar area next to the window controls overlay "notch". The position of the overlay can be defined using the existing [`safe-area-inset-top`](https://developer.mozilla.org/en-US/docs/Web/CSS/env) CSS environment variable to determine the height, and two new CSS environment variables describing the left and right insets of the overlay: [`unsafe-area-top-inset-left/right`](https://github.com/w3c/csswg-drafts/issues/4721). See the [sample code](#example) below on one method of laying out the title bar using these CSS environment variables. 
+The solution is to treat the overlay like a notch in a phone screen and layout the title bar area next to the window controls overlay "notch". The position of the overlay can be defined using the existing [`safe-area-inset-top`](https://developer.mozilla.org/docs/Web/CSS/env) CSS environment variable to determine the height, and two new CSS environment variables describing the left and right insets of the overlay: [`unsafe-area-top-inset-left/right`](https://github.com/w3c/csswg-drafts/issues/4721). See the [sample code](#example) below on one method of laying out the title bar using these CSS environment variables. 
 
 We explored and rejected an alternative approach which instead uses CSS environment variables to describe the safe area of the title bar, `title-bar-area-[top/left/bottom/right]`. Although this "safe area" approach would be easier for developers to use than the "unsafe area" approach, it would be difficult to standardize given that it is such a niche use case (only available on installed desktop web apps). 
 
diff --git a/TransparentAds/Program-Overview.md b/TransparentAds/Program-Overview.md
index bc5ed268..fd757c8c 100644
--- a/TransparentAds/Program-Overview.md
+++ b/TransparentAds/Program-Overview.md
@@ -29,7 +29,7 @@ The following section outlines the strict set of privacy requirements to join th
 |--------------|----------|
 |The ability for users to contact the company serving personalized ads | Contact information can be published in the privacy policy or terms of service document for the company. | 
 | Privacy Policy must be published on the web at a [`/.well-known/`](https://datatracker.ietf.org/doc/html/rfc5785) location| Published privacy policies must cover the following:<ul><li> What types of cookies/tracking technologies are used? </li><li>What information is collected, how it is used, how it is stored/for how long? </li><li>How is collected data shared with other companies? </li><li>What security measures are taken to protect information? </li><li> What choices can users make regarding cookies and tracking technologies, such as opt-out or similar controls?  </li> |
-| For ad serving partners (i.e. demand-side platforms), provide users with a clear indication when they are seeing an ad while browsing | Example: An “Ad” or “Sponsored” tag that aligns with [Microsoft’s ad labelling policies](https://about.ads.microsoft.com/en-us/resources/policies/traffic-quality) (currently under “Publisher resources” section). AdChoices and similar inline icons and controls would also satisfy this requirement.|
+| For ad serving partners (i.e. demand-side platforms), provide users with a clear indication when they are seeing an ad while browsing | Example: An “Ad” or “Sponsored” tag that aligns with [Microsoft’s ad labelling policies](https://about.ads.microsoft.com/resources/policies/traffic-quality) (currently under “Publisher resources” section). AdChoices and similar inline icons and controls would also satisfy this requirement.|
 |Provide browser-consumable metadata on each ad that offers the following:<ul><li>For partners facilitating ad auctions: an understanding of what data was used to request bids</li><li>For ad serving partners: an understanding of what data was used to personalize the ad being served</li><li>An overview of how this data was acquired (user provided, inferred based on interactions on the same site, inferred based on interactions with other sites, collected via device characteristics, obtained from data partnerships with other companies, etc.)</li></ul>||
 | Ensure ad slots are marked with a unique identifier. | The identifier will be used to link ads transparency metadata to discrete creatives. 
 
@@ -47,13 +47,13 @@ The following section outlines the strict set of privacy requirements to join th
 ## Protection
 | Requirements | Comments | 
 |--------------|----------|
-|Any data collection must meet the [Microsoft privacy and data protection policies](https://about.ads.microsoft.com/en-us/resources/policies/privacy-and-data-protection-policies) and comply with all applicable laws and regulations related to the collection and use of personal data.||
+|Any data collection must meet the [Microsoft privacy and data protection policies](https://about.ads.microsoft.com/resources/policies/privacy-and-data-protection-policies) and comply with all applicable laws and regulations related to the collection and use of personal data.||
 
 
 # Detailed Implementation Requirements: Transparency
 No additional requirements apply to the following:
 * The ability for users to contact the company serving personalized ads
-* For ad serving partners (i.e. demand-side platforms), provide users with a clear indication when they are seeing an ad while browsing. Example: An “Ad” or “Sponsored” tag that aligns with [Microsoft’s ad labelling policies](https://about.ads.microsoft.com/en-us/resources/policies/traffic-quality) (currently under “Publisher resources” section). AdChoices and similar inline icons and controls would also satisfy this requirement.
+* For ad serving partners (i.e. demand-side platforms), provide users with a clear indication when they are seeing an ad while browsing. Example: An “Ad” or “Sponsored” tag that aligns with [Microsoft’s ad labelling policies](https://about.ads.microsoft.com/resources/policies/traffic-quality) (currently under “Publisher resources” section). AdChoices and similar inline icons and controls would also satisfy this requirement.
 
 ## Privacy policy at a /.well-known/ location
 
@@ -180,8 +180,8 @@ The following describes these fields and accepted values.
 
 **lookalike**
 * `NOT_USED`: Lookalike targeting was not used.
-* `SIMILAR_AUDIENCE`: Lookalike targeting using a behavioral seed was used. Examples include Microsoft Ads’ [Similar Audiences](https://about.ads.microsoft.com/en-us/solutions/audience-targeting/similar-audiences) or Google’s [Affinity Audiences](https://support.google.com/displayvideo/answer/6021489?hl=en#zippy=).
-* `ID_MATCH`: A customer was matched based on an identifier (e.g. email address, phone number, address) shared by the advertiser. An example includes Microsoft Ads’ [Customer Match](https://about.ads.microsoft.com/en-us/solutions/audience-targeting/customer-match).
+* `SIMILAR_AUDIENCE`: Lookalike targeting using a behavioral seed was used. Examples include Microsoft Ads’ [Similar Audiences](https://about.ads.microsoft.com/solutions/audience-targeting/similar-audiences) or Google’s [Affinity Audiences](https://support.google.com/displayvideo/answer/6021489?hl=en#zippy=).
+* `ID_MATCH`: A customer was matched based on an identifier (e.g. email address, phone number, address) shared by the advertiser. An example includes Microsoft Ads’ [Customer Match](https://about.ads.microsoft.com/solutions/audience-targeting/customer-match).
 
 Providers should match “lookalike” values based on the intent of a customer list, regardless of the origination. For example, a list of customers provided by a partner platform would be a match for `SIMILAR_AUDIENCE` if a behavioral seed was used to create that segment. If the “why” behind a particular customer segment from a third-party partner cannot be determined (e.g. unclear whether this customer segment is based on lookalike or remarketing behaviors), match the other: `OTHER_USED` key-value pair.
 
@@ -444,5 +444,5 @@ We plan to audit the program requirements using the process below:
 ## Protection
 | Requirements | Auditing | 
 |--------------|----------|
-|Any data collection must meet the [Microsoft privacy and data protection policies](https://about.ads.microsoft.com/en-us/resources/policies/privacy-and-data-protection-policies) and comply with all applicable laws and regulations related to the collection and use of personal data.|No new auditing under this program. Complaints raised against a participant (including but not limited to: informal user complaints, regulatory inquiries, and formal complaints filed in local jurisdictions) may cause review of inclusion in the program.|
+|Any data collection must meet the [Microsoft privacy and data protection policies](https://about.ads.microsoft.com/resources/policies/privacy-and-data-protection-policies) and comply with all applicable laws and regulations related to the collection and use of personal data.|No new auditing under this program. Complaints raised against a participant (including but not limited to: informal user complaints, regulatory inquiries, and formal complaints filed in local jurisdictions) may cause review of inclusion in the program.|
 
diff --git a/URLProtocolHandler/explainer.md b/URLProtocolHandler/explainer.md
index 4cc6d6f5..0e4906d1 100644
--- a/URLProtocolHandler/explainer.md
+++ b/URLProtocolHandler/explainer.md
@@ -123,9 +123,9 @@ Registering applications to handle URL schemes is operating system dependent. Th
 
 ### Windows
 
-- **Desktop applications** can be registered to handle URL schemes by modifying registry key values. See more [here](https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85)?redirectedfrom=MSDN).
+- **Desktop applications** can be registered to handle URL schemes by modifying registry key values. See more [here](https://learn.microsoft.com/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa767914(v=vs.85)?redirectedfrom=MSDN).
 
-- **UWP apps** can specify a supported schemes in their package manifest. The OS registers these associations during installation. Read more [here](https://docs.microsoft.com/en-us/windows/uwp/launch-resume/handle-uri-activation).
+- **UWP apps** can specify a supported schemes in their package manifest. The OS registers these associations during installation. Read more [here](https://learn.microsoft.com/windows/uwp/launch-resume/handle-uri-activation).
 
 ### Linux
 
@@ -188,11 +188,11 @@ As mentioned before, the Navigator interface from WebAPI has the method `registe
 
 <https://html.spec.whatwg.org/multipage/system-state.html#custom-handlers>
 
-<https://developer.mozilla.org/en-US/docs/Web/API/Navigator/registerProtocolHandler>
+<https://developer.mozilla.org/docs/Web/API/Navigator/registerProtocolHandler>
 
 ### protocol_handlers for WebExtensions
 
-Another related API is Mozilla's `protocol_handlers` property for their [WebExtensions](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/protocol_handlers). With that property, extensions can register a website as a handler for a particular protocol. Just like in this proposal, the syntax and semantics of this `WebExtensions` property is very similar to `registerProtocolHandler`, except that with `registerProtocolHandler` a website can only register itself as a handler. To avoid confusion for developers, it would be wise to keep the extensions API ([Chromium proposal](https://bugs.chromium.org/p/chromium/issues/detail?id=64100)), the web app API (proposed here) and `registerProtocolHandler` as aligned as possible. Keeping compatibility with all these APIs might also make it easier for user agents to share as much logic as possible among all the implementations. [Issue #280](https://github.com/MicrosoftEdge/MSEdgeExplainers/issues/280) provides more context on this.
+Another related API is Mozilla's `protocol_handlers` property for their [WebExtensions](https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/manifest.json/protocol_handlers). With that property, extensions can register a website as a handler for a particular protocol. Just like in this proposal, the syntax and semantics of this `WebExtensions` property is very similar to `registerProtocolHandler`, except that with `registerProtocolHandler` a website can only register itself as a handler. To avoid confusion for developers, it would be wise to keep the extensions API ([Chromium proposal](https://bugs.chromium.org/p/chromium/issues/detail?id=64100)), the web app API (proposed here) and `registerProtocolHandler` as aligned as possible. Keeping compatibility with all these APIs might also make it easier for user agents to share as much logic as possible among all the implementations. [Issue #280](https://github.com/MicrosoftEdge/MSEdgeExplainers/issues/280) provides more context on this.
 
 ## Alternatives Considered
 
diff --git a/WebDriverRPC/bootstrap-scripts.md b/WebDriverRPC/bootstrap-scripts.md
index 46ed8ebc..afecd07b 100644
--- a/WebDriverRPC/bootstrap-scripts.md
+++ b/WebDriverRPC/bootstrap-scripts.md
@@ -20,7 +20,7 @@ A simple example might be using a bootstrap script to register a "DOMContentLoad
 
 Expanding on the above example, a single-page app may load some UI content asynchronously and the "DOMContentLoaded" or "load" events may not be a good enough indication that the app is in a steady state and ready to test. If the app had a way to signal to test code that the UI is fully loaded, then the test code could listen for this event before proceeding with the test. This would be more reliable and efficient than either timeouts or polling the DOM. A bidirectional WebDriver protocol makes this sort of messaging possible.
 
-Another use case is adding instrumentation or shims before a page starts running. A bootstrap script could wrap the console.log function with a custom implementation that forwards its arguments to the WebDriver client. This would be a simple but effective way to add logging to a WebDriver test. Similarly, a bootstrap script could create a [PerformanceObserver](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver) and use the messaging channel to forward performance entries to the WebDriver client.
+Another use case is adding instrumentation or shims before a page starts running. A bootstrap script could wrap the console.log function with a custom implementation that forwards its arguments to the WebDriver client. This would be a simple but effective way to add logging to a WebDriver test. Similarly, a bootstrap script could create a [PerformanceObserver](https://developer.mozilla.org/docs/Web/API/PerformanceObserver) and use the messaging channel to forward performance entries to the WebDriver client.
 
 ## Registering Bootstrap Scripts
 
@@ -151,7 +151,7 @@ Message data is an arbitrary JSON blob that will be deserialized on the bootstra
 
 ### Bootstrap script-side
 
-To allow a bootstrap script to send and receive messages from the client side, we can expose a [MessagePort](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort) object. The script can subscribe to the MessagePort's onmessage event which will fire whenever the client calls postMessageToBootstrapScript. The script can call postMessage() which will fire a messageReceivedFromBootstrapScript event on the client side.
+To allow a bootstrap script to send and receive messages from the client side, we can expose a [MessagePort](https://developer.mozilla.org/docs/Web/API/MessagePort) object. The script can subscribe to the MessagePort's onmessage event which will fire whenever the client calls postMessageToBootstrapScript. The script can call postMessage() which will fire a messageReceivedFromBootstrapScript event on the client side.
 
 The question then is how to expose the MessagePort object to the bootstrap script. Bootstrap scripts run in the same context as page script, so exposing the port as a global is not a good idea. This would give untrusted page script access to the port object.
 
@@ -165,7 +165,7 @@ function myBootstrapScript(port) {
 
 The browser would call the function, passing in a MessagePort object. This would scope the port variable so that it is only visible inside the function. Of course, the user could proceed to expose the port to the page somehow, but this would at least be an explicit choice by the user.
 
-Another option is to avoid running bootstraps scripts in the same context as page script, and run them in some kind of "isolated" context instead; Something similar to a WebExtension [content script](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#Content_script_environment), which has access to a clean version of the DOM, but has its own global scope. This would make it possible to expose the MessortPort (and possibly other privileged APIs) to the bootstrap script as globals. However, this kind of functionality may not be available in all browsers and doesn't appear to be standardized outside of WebExtensions. This also makes it difficult for the bootstrap script to manipulate the page's view of the DOM, which could be a useful feature.
+Another option is to avoid running bootstraps scripts in the same context as page script, and run them in some kind of "isolated" context instead; Something similar to a WebExtension [content script](https://developer.mozilla.org/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#Content_script_environment), which has access to a clean version of the DOM, but has its own global scope. This would make it possible to expose the MessortPort (and possibly other privileged APIs) to the bootstrap script as globals. However, this kind of functionality may not be available in all browsers and doesn't appear to be standardized outside of WebExtensions. This also makes it difficult for the bootstrap script to manipulate the page's view of the DOM, which could be a useful feature.
 
 ## Examples
 
diff --git a/WebInkEnhancement/explainer.md b/WebInkEnhancement/explainer.md
index 9defde22..47859cc4 100644
--- a/WebInkEnhancement/explainer.md
+++ b/WebInkEnhancement/explainer.md
@@ -13,7 +13,7 @@ Achieving low latency is critical for delivering great inking experiences on the
 
 There are a number of progressive enhancements to this programming model that are aimed at reducing latency.
 
-- [Offscreen canvas](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas) and [Input for Workers](https://github.com/WICG/input-for-workers/blob/gh-pages/README.md)
+- [Offscreen canvas](https://developer.mozilla.org/docs/Web/API/OffscreenCanvas) and [Input for Workers](https://github.com/WICG/input-for-workers/blob/gh-pages/README.md)
 
   This helps web developers separate their pointer handling from other main thread logic and execution, which allows for more timely and consistent delivery of these input events.
 
diff --git a/Withdrawn/CustomDialogOnClose/explainer.md b/Withdrawn/CustomDialogOnClose/explainer.md
index 4f30cb99..3a1dbcb7 100644
--- a/Withdrawn/CustomDialogOnClose/explainer.md
+++ b/Withdrawn/CustomDialogOnClose/explainer.md
@@ -127,7 +127,7 @@ This option will not be pursued, in favor of the declarative approach. The two a
 - Having a beforeunload handler can harm the performance of the browser by preventing optimizations like BFCache. A declarative approach should lessen the frequency with which this optimization is missed.
 
 ### Extend window.confirm()
-[`window.confirm()`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm) is a familiar API that lets websites query the user and act based on their response.
+[`window.confirm()`](https://developer.mozilla.org/docs/Web/API/Window/confirm) is a familiar API that lets websites query the user and act based on their response.
 
 ![A dialog is displayed with the title "An embedded page on this page says" and the contents "This is an example of the confirm API, this text is customizable". There are two buttons "OK" and "Cancel".](./images/ConfirmExample.PNG)