For anyone still looking for an easy way to convert an entire XML document in 2024 using Powershell, I threw together this quick function that will convert from a System.Xml.XmlDocument to a standard PSObject recursively. From there you can pipe it into ConvertTo-Json or whatever you want.

It's pretty basic so may require some modification for more complex scenarios, but it works for simple stuff like RSS feeds.

function Convert-XmlNodeToObject
{
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true, ValueFromPipeline = $true)]
        [ValidateNotNull()]
        [System.Xml.XmlNode]$Node,

        # If a node has no attributes and a single child with a node type of 'Text', then return the innerText value of that child node rather than a separate object
        # This eliminates '#text' child nodes where possible
        [Parameter(Mandatory = $false)]
        [switch]$IncludeChildTextNodes
    )

    $NODE_TYPES = @(
        [System.Xml.XmlNodeType]::Element,
        [System.Xml.XmlNodeType]::Attribute,
        [System.Xml.XmlNodeType]::Text
    )

    if ($Node.NodeType -eq [System.Xml.XmlNodeType]::Text)
    {
        Write-Debug ("Returning child node '{0}' as text because NodeType is '{1}'" -f $Node.Name, $Node.NodeType)
        return $Node.InnerText
    }

    if (!$IncludeChildTextNodes.IsPresent -and $Node.HasChildNodes -and $Node.ChildNodes.Count -eq 1 -and !$Node.HasAttributes)
    {
        $child = $Node.ChildNodes | Select-Object -First 1
        if ($child.NodeType -eq [System.Xml.XmlNodeType]::Text)
        {
            Write-Debug ("Returning child '{0}' node '{1}' as text for parent '{2}' because the parent has no attributes and the child text node is the only node. Pass IncludeChildTextNodes to prevent this behaviour." -f $child.NodeType, $child.Name, $Node.Name)
            return $child.InnerText
        }
    }

    $nodeHt = ([System.Management.Automation.OrderedHashtable]@{})

    foreach ($attribute in $Node.Attributes)
    {
        if ($nodeHt.Contains($attribute.Name))
        {
            Write-Warning ("Skipping attribute '{0}' on node '{1}' because the name is a duplicate" -f $attribute.Name, $Node.Name)
            continue
        }

        $thisObject = Convert-XmlNodeToObject $attribute -IncludeChildTextNodes:$IncludeChildTextNodes.IsPresent
        if ($null -ne $thisObject)
        {
            Write-Debug ("Recursively adding attribute '{0}' for parent node '{1}'" -f $attribute.Name, $Node.Name)
            $nodeHt += @{
                $attribute.Name = $thisObject
            }
        }
        else
        {
            Write-Warning ("Omitting attribute '{0}' for parent '{1}' because the result was null." -f $attribute.Name, $Node.Name)
        }
    }

    # Skip stuff we're not interested in, e.g. declarations
    foreach ($child in $Node.ChildNodes.Where({ $_.NodeType -in $NODE_TYPES }))
    {
        if ($nodeHt.Contains($child.Name))
        {
            # Duplicate node name -- assume an array
            if ($null -ne $nodeHt[$child.Name] -and $nodeHt[$child.Name].GetType().Name.StartsWith('List'))
            {
                Write-Debug ("Duplicate child node name '{0}' of type '{1}' on parent node '{2}' -- using existing collection" -f $child.Name, $child.NodeType, $Node.Name)
                $nodes = $nodeHt[$child.Name]
            }
            else
            {
                Write-Verbose ("Duplicate child node name '{0}' of type '{1}' on parent node '{2}' -- assuming a collection of nodes" -f $child.Name, $child.NodeType, $Node.Name)
                $nodes = New-Object System.Collections.Generic.List[object]
                if ($null -ne $nodeHt[$child.Name])
                {
                    $nodes.Add(($nodeHt[$child.Name]))
                }
            }

            $thisObject = Convert-XmlNodeToObject $child -IncludeChildTextNodes:$IncludeChildTextNodes.IsPresent
            if ($null -ne $thisObject)
            {
                $nodes.Add(($thisObject))
            }
            else
            {
                Write-Warning ("Omitting child '{0}' node '{1}' for parent '{2}' (index {3}) because the result was null." -f $child.NodeType, $child.Name, $Node.Name, $nodes.Count)
            }

            $nodeHt[$child.Name] = $nodes
        }
        else
        {
            $thisObject = Convert-XmlNodeToObject $child -IncludeChildTextNodes:$IncludeChildTextNodes.IsPresent
            if ($null -ne $thisObject)
            {
                Write-Debug ("Recursively adding child node '{0}' of type '{1}' for parent node '{2}'" -f $child.Name, $child.NodeType, $Node.Name)
                $nodeHt += @{
                    $child.Name = $thisObject
                }
            }
            else
            {
                Write-Warning ("Omitting child '{0}' node '{1}' for parent '{2}' because the result was null." -f $child.NodeType, $child.Name, $Node.Name)
            }
        }
    }

    return (New-Object PSObject -Property $nodeHt)
}

It accepts a .NET XmlNode, which XmlDocument implements. If you have raw XML you'll need to create an instance of XmlDocument first:

$xml = [System.Xml.XmlDocument]$someXml
$object = $xml | Convert-XmlNodeToObject

Then to get some JSON:

$object | ConvertTo-Json -Depth 16