Merge branch 'v14/dev' into v15/dev

# Conflicts:
#	Directory.Packages.props
#	src/Umbraco.Cms.Api.Common/DependencyInjection/UmbracoBuilderAuthExtensions.cs
#	src/Umbraco.Cms.Api.Delivery/DependencyInjection/UmbracoBuilderExtensions.cs
#	src/Umbraco.Cms.Api.Delivery/Querying/Selectors/AncestorsSelector.cs
#	src/Umbraco.Cms.Api.Management/OpenApi.json
#	src/Umbraco.Infrastructure/Examine/ExamineIndexRebuilder.cs
#	src/Umbraco.Infrastructure/PropertyEditors/MediaPicker3PropertyEditor.cs
#	src/Umbraco.PublishedCache.NuCache/ContentStore.cs
#	tests/Directory.Packages.props

tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/RefresherTests.cs

@@ -27,26 +27,68 @@ public class RefresherTests
         Assert.AreEqual(source[0].ChangeTypes, payload[0].ChangeTypes);
     }
 
-    [Test]
-    public void ContentCacheRefresherCanDeserializeJsonPayload()
+    [TestCase(TreeChangeTypes.None, false)]
+    [TestCase(TreeChangeTypes.RefreshAll, true)]
+    [TestCase(TreeChangeTypes.RefreshBranch, false)]
+    [TestCase(TreeChangeTypes.Remove, true)]
+    [TestCase(TreeChangeTypes.RefreshNode, false)]
+    public void ContentCacheRefresherCanDeserializeJsonPayload(TreeChangeTypes changeTypes, bool blueprint)
     {
+        var key = Guid.NewGuid();
         ContentCacheRefresher.JsonPayload[] source =
         {
             new ContentCacheRefresher.JsonPayload()
             {
                 Id = 1234,
-                Key = Guid.NewGuid(),
-                ChangeTypes = TreeChangeTypes.None
+                Key = key,
+                ChangeTypes = changeTypes,
+                Blueprint = blueprint
             }
         };
 
         var json = JsonSerializer.Serialize(source);
         var payload = JsonSerializer.Deserialize<ContentCacheRefresher.JsonPayload[]>(json);
 
-        Assert.AreEqual(source[0].Id, payload[0].Id);
-        Assert.AreEqual(source[0].Key, payload[0].Key);
-        Assert.AreEqual(source[0].ChangeTypes, payload[0].ChangeTypes);
-        Assert.AreEqual(source[0].Blueprint, payload[0].Blueprint);
+        Assert.AreEqual(1234, payload[0].Id);
+        Assert.AreEqual(key, payload[0].Key);
+        Assert.AreEqual(changeTypes, payload[0].ChangeTypes);
+        Assert.AreEqual(blueprint, payload[0].Blueprint);
+        Assert.IsNull(payload[0].PublishedCultures);
+        Assert.IsNull(payload[0].UnpublishedCultures);
+    }
+
+    [Test]
+    public void ContentCacheRefresherCanDeserializeJsonPayloadWithCultures()
+    {
+        var key = Guid.NewGuid();
+        ContentCacheRefresher.JsonPayload[] source =
+        {
+            new ContentCacheRefresher.JsonPayload()
+            {
+                Id = 1234,
+                Key = key,
+                PublishedCultures = ["en-US", "da-DK"],
+                UnpublishedCultures = ["de-DE"]
+            }
+        };
+
+        var json = JsonSerializer.Serialize(source);
+        var payload = JsonSerializer.Deserialize<ContentCacheRefresher.JsonPayload[]>(json);
+
+        Assert.IsNotNull(payload[0].PublishedCultures);
+        Assert.Multiple(() =>
+        {
+            Assert.AreEqual(2, payload[0].PublishedCultures.Length);
+            Assert.AreEqual("en-US", payload[0].PublishedCultures.First());
+            Assert.AreEqual("da-DK", payload[0].PublishedCultures.Last());
+        });
+
+        Assert.IsNotNull(payload[0].UnpublishedCultures);
+        Assert.Multiple(() =>
+        {
+            Assert.AreEqual(1, payload[0].UnpublishedCultures.Length);
+            Assert.AreEqual("de-DE", payload[0].UnpublishedCultures.First());
+        });
     }
 
     [Test]

tests/Umbraco.Tests.UnitTests/Umbraco.Core/DeliveryApi/RichTextParserTests.cs

@@ -357,6 +357,48 @@ public class RichTextParserTests : PropertyValueConverterTests
         Assert.IsEmpty(blockLevelBlock.Elements);
     }
 
+    [Test]
+    public void ParseElement_CanHandleWhitespaceAroundInlineElemements()
+    {
+        var parser = CreateRichTextElementParser();
+
+        var element = parser.Parse("<p>What follows from <strong>here</strong> <em>is</em> <a href=\"#\">just</a> a bunch of text.</p>") as RichTextRootElement;
+        Assert.IsNotNull(element);
+        var paragraphElement = element.Elements.Single() as RichTextGenericElement;
+        Assert.IsNotNull(paragraphElement);
+
+        var childElements = paragraphElement.Elements.ToArray();
+        Assert.AreEqual(7, childElements.Length);
+
+        var childElementCounter = 0;
+
+        void AssertNextChildElementIsText(string expectedText)
+        {
+            var textElement = childElements[childElementCounter++] as RichTextTextElement;
+            Assert.IsNotNull(textElement);
+            Assert.AreEqual(expectedText, textElement.Text);
+        }
+
+        void AssertNextChildElementIsGeneric(string expectedTag, string expectedInnerText)
+        {
+            var genericElement = childElements[childElementCounter++] as RichTextGenericElement;
+            Assert.IsNotNull(genericElement);
+            Assert.AreEqual(expectedTag, genericElement.Tag);
+            Assert.AreEqual(1, genericElement.Elements.Count());
+            var textElement = genericElement.Elements.First() as RichTextTextElement;
+            Assert.IsNotNull(textElement);
+            Assert.AreEqual(expectedInnerText, textElement.Text);
+        }
+
+        AssertNextChildElementIsText("What follows from ");
+        AssertNextChildElementIsGeneric("strong", "here");
+        AssertNextChildElementIsText(" ");
+        AssertNextChildElementIsGeneric("em", "is");
+        AssertNextChildElementIsText(" ");
+        AssertNextChildElementIsGeneric("a", "just");
+        AssertNextChildElementIsText(" a bunch of text.");
+    }
+
     [Test]
     public void ParseMarkup_CanParseContentLink()
     {