PSParseHTML.psm1

# PSParseHTML bootstrapper
# Auto-generated by PowerForge. Do not edit.

# Get library name, from the PSM1 file name
$LibraryName = 'PSParseHTML.PowerShell'
$Library = "$LibraryName.dll"
$Class = "$LibraryName.Initialize"

$LibRoot = [IO.Path]::Combine($PSScriptRoot, 'Lib')
$AssemblyFolders = Get-ChildItem -LiteralPath $LibRoot -Directory -ErrorAction SilentlyContinue

$Default = $false
$Core = $false
$Standard = $false
foreach ($A in $AssemblyFolders.Name) {
    if ($A -eq 'Default') {
        $Default = $true
    } elseif ($A -eq 'Core') {
        $Core = $true
    } elseif ($A -eq 'Standard') {
        $Standard = $true
    }
}
if ($Standard -and $Core -and $Default) {
    $FrameworkNet = 'Default'
    $Framework = 'Standard'
} elseif ($Standard -and $Core) {
    $Framework = 'Standard'
    $FrameworkNet = 'Standard'
} elseif ($Core -and $Default) {
    $Framework = 'Core'
    $FrameworkNet = 'Default'
} elseif ($Standard -and $Default) {
    $Framework = 'Standard'
    $FrameworkNet = 'Default'
} elseif ($Standard) {
    $Framework = 'Standard'
    $FrameworkNet = 'Standard'
} elseif ($Core) {
    $Framework = 'Core'
    $FrameworkNet = ''
} elseif ($Default) {
    $Framework = 'Default'
    $FrameworkNet = 'Default'
} else {
    Write-Error -Message 'No assemblies found'
    return
}

if ($PSEdition -eq 'Core') {
    $LibFolder = $Framework
} else {
    $LibFolder = $FrameworkNet
}

try {
    $ImportModule = Get-Command -Name Import-Module -Module Microsoft.PowerShell.Core
    $ModuleAssemblyPath = [IO.Path]::Combine($PSScriptRoot, 'Lib', $LibFolder, $Library)

    if ($PSEdition -eq 'Core') {
        $LoaderAssemblyPath = [IO.Path]::Combine($PSScriptRoot, 'Lib', $LibFolder, 'PSParseHTML.ModuleLoadContext.dll')
        if (-not ('PSParseHTML.ModuleLoadContext.ModuleAssemblyLoadContext' -as [type])) {
            Add-Type -Path $LoaderAssemblyPath -ErrorAction Stop
        }

        $ModuleAssembly = [PSParseHTML.ModuleLoadContext.ModuleAssemblyLoadContext]::LoadModule($ModuleAssemblyPath, 'PSParseHTML')
        $InnerModule = & $ImportModule -Assembly $ModuleAssembly -Force -PassThru -ErrorAction Stop

        # Type accelerator registration relies on $ModuleAssembly and $LibFolder from this ALC loader scope.
        $RegisterPowerForgeAssemblyTypeAccelerators = {
            param(
                [Parameter(Mandatory = $true)][System.Reflection.Assembly] $ModuleAssembly,
                [Parameter(Mandatory = $true)][string] $LibFolder
            )

            $Mode = 'Enums'
            $RequestedTypes = @('Acornima.Ast.Node', 'Acornima.Ast.Program', 'Acornima.Ast.Script', 'HtmlTinkerX.HtmlBrowser', 'HtmlTinkerX.HtmlBrowserLaunchOptions', 'HtmlTinkerX.HtmlBrowserlessExtraction', 'HtmlTinkerX.HtmlBrowserProfile', 'HtmlTinkerX.HtmlBrowserRecipe', 'HtmlTinkerX.HtmlBrowserRecipeRunOptions', 'HtmlTinkerX.HtmlBrowserSsoField', 'HtmlTinkerX.HtmlBrowserSsoHandoff', 'HtmlTinkerX.HtmlCookie', 'HtmlTinkerX.HtmlHttpClientFactory', 'HtmlTinkerX.HtmlNetworkEntry', 'HtmlTinkerX.HtmlOptimizer', 'HtmlTinkerX.HtmlParser', 'HtmlTinkerX.HtmlRenderedPageSnapshot', 'HtmlTinkerX.HtmlResourceLink', 'HtmlAgilityPack.HtmlDocument', 'HtmlAgilityPack.HtmlNode', 'HtmlAgilityPack.HtmlAttribute', 'PSParseHTML.PowerShell.PowerShellHtmlRoute', 'Microsoft.Playwright.IRoute', 'Microsoft.Playwright.RouteContinueOptions', 'Microsoft.Playwright.RouteFallbackOptions', 'Microsoft.Playwright.RouteFulfillOptions')
            $RequestedAssemblies = @('Acornima', 'HtmlTinkerX', 'HtmlAgilityPack')

            if ($null -eq $ModuleAssembly) {
                Write-Warning -Message 'Module assembly was not available. ALC dependency type exposure is disabled.'
                return
            }

            if ([string]::IsNullOrWhiteSpace($LibFolder)) {
                Write-Warning -Message 'Module library folder was not available. ALC dependency type exposure is disabled.'
                return
            }

            $PowerForgeAlcLibraryDirectory = $null
            if ([IO.Path]::IsPathRooted($LibFolder)) {
                $PowerForgeAlcLibraryDirectory = [IO.Path]::GetFullPath($LibFolder)
            } elseif ($LibFolder.Contains('..') -or $LibFolder.IndexOfAny([IO.Path]::GetInvalidFileNameChars()) -ge 0) {
                Write-Warning -Message "Module library folder '$LibFolder' must be a simple folder name or a rooted development binary directory. ALC dependency type exposure is disabled."
                return
            } else {
                $PowerForgeAlcLibraryDirectory = [IO.Path]::Combine($PSScriptRoot, 'Lib', $LibFolder)
            }

            if ($Mode -eq 'AllowList' -and $RequestedTypes.Count -eq 0) {
                Write-Warning -Message 'AllowList type accelerator mode was configured without type names. No ALC dependency type accelerators will be registered.'
                return
            }

            if (($Mode -eq 'Assembly' -or $Mode -eq 'Enums') -and $RequestedAssemblies.Count -eq 0) {
                if ($RequestedTypes.Count -eq 0) {
                    Write-Warning -Message "$Mode type accelerator mode was configured without assembly names or type names. No ALC dependency type accelerators will be registered."
                    return
                }

                Write-Warning -Message "$Mode type accelerator mode was configured without assembly names. Only explicitly configured type names will be registered."
            }

            $TypeAccelerators = [psobject].Assembly.GetType('System.Management.Automation.TypeAccelerators')
            if ($null -eq $TypeAccelerators) {
                Write-Warning -Message 'PowerShell type accelerator APIs are not available. ALC dependency type exposure is disabled.'
                return
            }

            $AddTypeAccelerator = $TypeAccelerators.GetMethod('Add', [type[]]@([string], [type]))
            $GetTypeAccelerators = $TypeAccelerators.GetProperty('Get', [System.Reflection.BindingFlags] 'Static,Public,NonPublic')
            if ($null -eq $AddTypeAccelerator -or $null -eq $GetTypeAccelerators) {
                Write-Warning -Message 'PowerShell type accelerator APIs are incomplete. ALC dependency type exposure is disabled.'
                return
            }

            $ModuleAlc = [System.Runtime.Loader.AssemblyLoadContext]::GetLoadContext($ModuleAssembly)
            if ($null -eq $ModuleAlc) {
                Write-Warning -Message 'Unable to resolve the module AssemblyLoadContext. ALC dependency type exposure is disabled.'
                return
            }

            if ($null -eq $script:PowerForgeRegisteredAssemblyTypeAccelerators) {
                $script:PowerForgeRegisteredAssemblyTypeAccelerators = @{}
            }

            $ImportPowerForgeAlcAssembly = {
                param([Parameter(Mandatory = $true)][string] $AssemblyName)

                foreach ($Assembly in $ModuleAlc.Assemblies) {
                    if ($Assembly.GetName().Name -eq $AssemblyName) {
                        return $Assembly
                    }
                }

                try {
                    return $ModuleAlc.LoadFromAssemblyName([System.Reflection.AssemblyName]::new($AssemblyName))
                } catch {
                    $AssemblyPath = [IO.Path]::Combine($PowerForgeAlcLibraryDirectory, $AssemblyName + '.dll')
                    if (Test-Path -LiteralPath $AssemblyPath) {
                        try {
                            $AssemblyNameObject = [System.Reflection.AssemblyName]::GetAssemblyName($AssemblyPath)
                            return $ModuleAlc.LoadFromAssemblyName($AssemblyNameObject)
                        } catch {
                            Write-Warning -Message "Could not load ALC assembly '$AssemblyName' for type accelerator exposure: $($_.Exception.Message)"
                        }
                    }
                }

                return $null
            }

            $FindPowerForgeAlcType = {
                param([Parameter(Mandatory = $true)][string] $TypeName)

                foreach ($Assembly in $ModuleAlc.Assemblies) {
                    $Type = $Assembly.GetType($TypeName, $false, $false)
                    if ($null -ne $Type) {
                        return $Type
                    }
                }

                $LibDirectory = $PowerForgeAlcLibraryDirectory
                if (-not (Test-Path -LiteralPath $LibDirectory)) {
                    return $null
                }

                foreach ($File in Get-ChildItem -LiteralPath $LibDirectory -Filter '*.dll' -File -ErrorAction SilentlyContinue) {
                    try {
                        $AssemblyName = [System.Reflection.AssemblyName]::GetAssemblyName($File.FullName)
                        $Assembly = & $ImportPowerForgeAlcAssembly -AssemblyName $AssemblyName.Name
                        if ($null -eq $Assembly) {
                            continue
                        }

                        $Type = $Assembly.GetType($TypeName, $false, $false)
                        if ($null -ne $Type) {
                            return $Type
                        }
                    } catch {
                        continue
                    }
                }

                return $null
            }

            $AddPowerForgeTypeAccelerator = {
                param([Parameter(Mandatory = $true)][type] $Type)

                if ([string]::IsNullOrWhiteSpace($Type.FullName)) {
                    return
                }

                $Name = $Type.FullName
                $Existing = $GetTypeAccelerators.GetValue($null)
                if ($Existing.ContainsKey($Name)) {
                    $ExistingType = $Existing[$Name]
                    if ([object]::ReferenceEquals($ExistingType, $Type)) {
                        return
                    } else {
                        $ExistingAssemblyName = $ExistingType.Assembly.GetName()
                        $TypeAssemblyName = $Type.Assembly.GetName()
                        $ExistingLoadContext = [System.Runtime.Loader.AssemblyLoadContext]::GetLoadContext($ExistingType.Assembly)
                        $TypeLoadContext = [System.Runtime.Loader.AssemblyLoadContext]::GetLoadContext($Type.Assembly)
                        if ([object]::ReferenceEquals($ExistingLoadContext, $TypeLoadContext) -and [object]::Equals($ExistingAssemblyName.FullName, $TypeAssemblyName.FullName)) {
                            Write-Verbose -Message "Type accelerator '$Name' already exists in the same AssemblyLoadContext from the same assembly identity. Keeping the existing accelerator and skipping the duplicate type from $($TypeAssemblyName.Name)."
                        } else {
                            Write-Warning -Message "Type accelerator '$Name' already exists from $($ExistingAssemblyName.FullName). Keeping the existing accelerator and skipping the ALC type from $($TypeAssemblyName.FullName)."
                        }
                    }
                    return
                }

                try {
                    $AddTypeAccelerator.Invoke($null, @($Name, $Type)) | Out-Null
                } catch {
                    Write-Warning -Message "Type accelerator '$Name' could not be registered from $($Type.Assembly.GetName().Name): $($_.Exception.Message)"
                    return
                }

                $script:PowerForgeRegisteredAssemblyTypeAccelerators[$Name] = $Type
            }

            if ($Mode -eq 'Assembly' -or $Mode -eq 'Enums') {
                foreach ($AssemblyName in $RequestedAssemblies) {
                    $Assembly = & $ImportPowerForgeAlcAssembly -AssemblyName $AssemblyName
                    if ($null -eq $Assembly) {
                        Write-Warning -Message "Assembly '$AssemblyName' was not found in the module AssemblyLoadContext. No type accelerators were registered for it."
                        continue
                    }

                    try {
                        $ExportedTypes = @($Assembly.GetExportedTypes())
                    } catch {
                        Write-Warning -Message "Could not enumerate exported types from assembly '$AssemblyName' for type accelerator exposure: $($_.Exception.Message)"
                        continue
                    }

                    foreach ($Type in $ExportedTypes) {
                        if ($Mode -eq 'Enums' -and -not $Type.IsEnum) {
                            continue
                        }

                        & $AddPowerForgeTypeAccelerator -Type $Type
                    }
                }
            }

            foreach ($TypeName in $RequestedTypes) {
                $Type = & $FindPowerForgeAlcType -TypeName $TypeName
                if ($null -eq $Type) {
                    Write-Warning -Message "Type '$TypeName' was not found in the module AssemblyLoadContext. No type accelerator was registered."
                    continue
                }

                & $AddPowerForgeTypeAccelerator -Type $Type
            }

            if ($script:PowerForgeAssemblyTypeAcceleratorCleanupRegistered -ne $true) {
                $script:PowerForgeAssemblyTypeAcceleratorCleanupRegistered = $true
                $PreviousPowerForgeOnRemove = $ExecutionContext.SessionState.Module.OnRemove
                $ExecutionContext.SessionState.Module.OnRemove = {
                    try {
                        $TypeAccelerators = [psobject].Assembly.GetType('System.Management.Automation.TypeAccelerators')
                        if ($null -eq $TypeAccelerators -or $null -eq $script:PowerForgeRegisteredAssemblyTypeAccelerators) {
                            return
                        }

                        $GetTypeAccelerators = $TypeAccelerators.GetProperty('Get', [System.Reflection.BindingFlags] 'Static,Public,NonPublic')
                        $RemoveTypeAccelerator = $TypeAccelerators.GetMethod('Remove', [type[]]@([string]))
                        if ($null -eq $GetTypeAccelerators -or $null -eq $RemoveTypeAccelerator) {
                            return
                        }

                        $Existing = $GetTypeAccelerators.GetValue($null)
                        foreach ($Entry in @($script:PowerForgeRegisteredAssemblyTypeAccelerators.GetEnumerator())) {
                            if ($Existing.ContainsKey($Entry.Key) -and [object]::ReferenceEquals($Existing[$Entry.Key], $Entry.Value)) {
                                $RemoveTypeAccelerator.Invoke($null, @($Entry.Key)) | Out-Null
                            }
                        }
                    } finally {
                        if ($null -ne $PreviousPowerForgeOnRemove) {
                            & $PreviousPowerForgeOnRemove @args
                        }
                    }
                }.GetNewClosure()
            }
        }

        # Type accelerator exposure is PowerShell Core-only because it depends on AssemblyLoadContext.
        try {
            & $RegisterPowerForgeAssemblyTypeAccelerators -ModuleAssembly $ModuleAssembly -LibFolder $LibFolder
        } catch {
            Write-Warning -Message "ALC type accelerator registration failed: $($_.Exception.Message)"
        }

        if ($InnerModule) {
            # Import-Module -Assembly loads the inner binary module into its own module object. PowerShell has no
            # public API to copy those exported cmdlets back to the script-module wrapper, so this uses the same
            # private PSModuleInfo hook used by community ALC loaders. This runs on first load and reloads so the
            # outer script module always re-exports cmdlets from the ALC-loaded binary module.
            $AddExportedCmdlet = [System.Management.Automation.PSModuleInfo].GetMethod(
                'AddExportedCmdlet',
                [System.Reflection.BindingFlags]'Instance, NonPublic'
            )
            if ($null -ne $AddExportedCmdlet) {
                foreach ($Cmd in $InnerModule.ExportedCmdlets.Values) {
                    $AddExportedCmdlet.Invoke($ExecutionContext.SessionState.Module, @(, $Cmd)) | Out-Null
                }
                $AddExportedAlias = [System.Management.Automation.PSModuleInfo].GetMethod(
                    'AddExportedAlias',
                    [System.Reflection.BindingFlags]'Instance, NonPublic'
                )
                if ($null -ne $AddExportedAlias) {
                    foreach ($Alias in $InnerModule.ExportedAliases.Values) {
                        $AliasTarget = if ([string]::IsNullOrWhiteSpace($Alias.Definition)) {
                            $Alias.ResolvedCommandName 
                        } else {
                            $Alias.Definition 
                        }
                        try {
                            # The alias must exist in this module scope before the private export table can reference it.
                            Set-Alias -Name $Alias.Name -Value $AliasTarget -Scope Local -Force -ErrorAction Stop
                            $ExportedAlias = $ExecutionContext.SessionState.InvokeCommand.GetCommand($Alias.Name, [System.Management.Automation.CommandTypes]::Alias)
                            if ($null -ne $ExportedAlias) {
                                $AddExportedAlias.Invoke($ExecutionContext.SessionState.Module, @(, $ExportedAlias)) | Out-Null
                            } else {
                                Write-Warning -Message "Alias '$($Alias.Name)' from $LibraryName was created but could not be resolved for export."
                            }
                        } catch {
                            Write-Warning -Message "Alias '$($Alias.Name)' from $LibraryName could not be re-exported: $($_.Exception.Message)"
                        }
                    }
                } else {
                    Write-Warning -Message "AddExportedAlias is not available on this PowerShell version. Aliases from $LibraryName will not be re-exported to the module scope."
                }
            } else {
                Write-Warning -Message "AddExportedCmdlet is not available on this PowerShell version. Falling back to direct Import-Module; cmdlets from $LibraryName will load from the default context."
                & $ImportModule $ModuleAssemblyPath -ErrorAction Stop
            }
        }
    } elseif (-not ($Class -as [type])) {
        & $ImportModule $ModuleAssemblyPath -ErrorAction Stop
    } else {
        $Type = "$Class" -as [Type]
        & $ImportModule -Force -Assembly ($Type.Assembly)
    }
} catch {
    if ($ErrorActionPreference -eq 'Stop') {
        throw
    } else {
        Write-Warning -Message "Importing module $Library failed. Fix errors before continuing. Error: $($_.Exception.Message)"
    }
}

if ($PSEdition -ne 'Core') {
    # Core loads dependencies through the module-scoped AssemblyLoadContext above. Dot-sourcing the libraries script
    # there would load dependency DLLs into the default context and undo the isolation this template exists to provide.
    $LibrariesScript = [IO.Path]::Combine($PSScriptRoot, 'PSParseHTML.Libraries.ps1')
    if (Test-Path -LiteralPath $LibrariesScript) {
        . $LibrariesScript
    }
}


$FunctionsToExport = @()
$CmdletsToExport = @('Clear-HtmlBrowserCache', 'Close-HtmlBrowserOverlay', 'Close-HtmlBrowserSession', 'Compare-Html', 'Compare-HtmlStaticRendered', 'Complete-HtmlRoute', 'Convert-HtmlToMarkdown', 'Convert-HtmlToText', 'ConvertFrom-CssUrl', 'ConvertFrom-Html', 'ConvertFrom-HtmlAppState', 'ConvertFrom-HtmlAttributes', 'ConvertFrom-HtmlCookie', 'ConvertFrom-HtmlEntity', 'ConvertFrom-HtmlForm', 'ConvertFrom-HtmlHeadLink', 'ConvertFrom-HtmlImageCandidate', 'ConvertFrom-HtmlJsonLd', 'ConvertFrom-HtmlJsonWebToken', 'ConvertFrom-HtmlLink', 'ConvertFrom-HtmlLinkedJavaScriptEndpoint', 'ConvertFrom-HtmlList', 'ConvertFrom-HtmlMeta', 'ConvertFrom-HtmlMicrodata', 'ConvertFrom-HtmlOpenGraph', 'ConvertFrom-HtmlRscPayload', 'ConvertFrom-HtmlSamlResponse', 'ConvertFrom-HtmlScriptData', 'ConvertFrom-HtmlSitemap', 'ConvertFrom-HtmlSsoHandoff', 'ConvertFrom-HtmlSyndication', 'ConvertFrom-HtmlTable', 'ConvertFrom-JavaScriptAst', 'ConvertFrom-JavaScriptEndpoint', 'ConvertFrom-RobotsTxt', 'ConvertFrom-WebManifest', 'ConvertFrom-WellKnownText', 'ConvertTo-HtmlDatasetJsonL', 'ConvertTo-HtmlEntity', 'ConvertTo-HtmlWebRequestSession', 'Export-HtmlBrowserEvidence', 'Export-HtmlBrowserHar', 'Export-HtmlBrowserProfile', 'Export-HtmlBrowserRecipe', 'Export-HtmlBrowserSession', 'Export-HtmlBrowserState', 'Export-HtmlExtractionRecipe', 'Export-HtmlOutline', 'Find-HtmlApiEndpoint', 'Find-HtmlBrowserDataSource', 'Find-HtmlBrowserLocator', 'Find-HtmlDataSource', 'Find-HtmlInteractionSurface', 'Format-Css', 'Format-Html', 'Format-JavaScript', 'Get-CssVariable', 'Get-HtmlBrowserActiveElement', 'Get-HtmlBrowserConsoleLog', 'Get-HtmlBrowserContent', 'Get-HtmlBrowserCookie', 'Get-HtmlBrowserDiagnostics', 'Get-HtmlBrowserElement', 'Get-HtmlBrowserFormField', 'Get-HtmlBrowserInteractable', 'Get-HtmlBrowserLoginForm', 'Get-HtmlBrowserNetworkLog', 'Get-HtmlBrowserSsoHandoff', 'Get-HtmlBrowserStorage', 'Get-HtmlCrawlProfile', 'Get-HtmlExtractionProfile', 'Get-HtmlResource', 'Import-HtmlBrowserProfile', 'Import-HtmlBrowserSession', 'Import-HtmlBrowserState', 'Import-HtmlExtractionRecipe', 'Invoke-HtmlBrowserClick', 'Invoke-HtmlBrowserDomScript', 'Invoke-HtmlBrowserHover', 'Invoke-HtmlBrowserKey', 'Invoke-HtmlBrowserLogin', 'Invoke-HtmlBrowserNavigation', 'Invoke-HtmlBrowserRecipe', 'Invoke-HtmlBrowserScript', 'Invoke-HtmlBrowserScroll', 'Invoke-HtmlCrawl', 'Invoke-HtmlDataExtraction', 'Invoke-HtmlExtractionRecipe', 'Invoke-HtmlFormRelay', 'Invoke-HtmlPageWorkbench', 'Invoke-HtmlRendering', 'Measure-CssSpecificity', 'Measure-HtmlBrowserPerformance', 'Measure-HtmlCompatibility', 'Measure-HtmlDocumentStructure', 'New-HtmlBrowserCookie', 'New-HtmlBrowserProfile', 'Optimize-Css', 'Optimize-Email', 'Optimize-Html', 'Optimize-HtmlBrowserRecipe', 'Optimize-JavaScript', 'Register-HtmlRoute', 'Save-HtmlBrowserAttachment', 'Save-HtmlBrowserContent', 'Save-HtmlBrowserPdf', 'Save-HtmlBrowserScreenshot', 'Select-CssDeclaration', 'Select-CssRule', 'Select-HtmlAsset', 'Select-HtmlAttributeValue', 'Select-HtmlData', 'Select-HtmlInnerText', 'Select-HtmlJavaScriptConfig', 'Select-HtmlJavaScriptVariable', 'Select-HtmlNode', 'Select-HtmlScript', 'Select-HtmlStyleUsage', 'Select-HtmlToken', 'Select-JavaScriptAstNode', 'Select-JavaScriptVariable', 'Set-HtmlBrowserChecked', 'Set-HtmlBrowserClientOption', 'Set-HtmlBrowserCookie', 'Set-HtmlBrowserInput', 'Set-HtmlBrowserSelectOption', 'Set-HtmlBrowserStorage', 'Show-HtmlBrowserHar', 'Start-HtmlBrowserRecipeRecording', 'Start-HtmlBrowserSession', 'Start-HtmlBrowserTracing', 'Start-HtmlBrowserVideoCapture', 'Stop-HtmlBrowserRecipeRecording', 'Stop-HtmlBrowserTracing', 'Stop-HtmlBrowserVideoCapture', 'Submit-HtmlBrowserForm', 'Test-HtmlBrowser', 'Test-HtmlBrowserElement', 'Test-HtmlBrowserRecipe', 'Test-HtmlExtractionPlan', 'Test-HtmlMicrodata', 'Unregister-HtmlRoute', 'Wait-HtmlBrowserContent', 'Wait-HtmlBrowserReady')
$AliasesToExport = @('cfhtml', 'Close-HtmlOverlay', 'Close-HtmlSession', 'ConvertFrom-HtmlClass', 'ConvertFrom-HtmlLinkedJSEndpoint', 'ConvertFrom-HtmlReactFlight', 'ConvertFrom-HtmlReactFlightPayload', 'ConvertFrom-HtmlTag', 'ConvertFrom-JSAst', 'ConvertFrom-JSEndpoint', 'ConvertTo-HtmlWebSession', 'Export-BrowserState', 'Export-HtmlSession', 'Format-JS', 'Get-HtmlActiveElement', 'Get-HtmlConsoleLog', 'Get-HtmlContent', 'Get-HtmlCookie', 'Get-HtmlDiagnostics', 'Get-HtmlElement', 'Get-HtmlFormField', 'Get-HtmlInteractable', 'Get-HtmlLoginForm', 'Get-HtmlNetworkLog', 'Get-HtmlSsoHandoff', 'Get-HtmlStorage', 'Import-BrowserState', 'Import-HtmlSession', 'Invoke-HtmlAutoSubmitForm', 'Invoke-HtmlBrowserOverlayDismissal', 'Invoke-HtmlClick', 'Invoke-HtmlDomScript', 'Invoke-HtmlHover', 'Invoke-HtmlKey', 'Invoke-HtmlLogin', 'Invoke-HtmlNavigation', 'Invoke-HtmlOverlayDismissal', 'Invoke-HtmlScript', 'Invoke-HtmlScroll', 'Measure-HtmlDocument', 'Measure-HtmlPerformance', 'New-HtmlCookie', 'Open-HtmlSession', 'Press-HtmlKey', 'Save-HtmlAttachment', 'Save-HtmlBrowserHar', 'Save-HtmlContent', 'Save-HtmlDownload', 'Save-HtmlHar', 'Save-HtmlPdf', 'Save-HtmlScreenshot', 'Select-HtmlJSConfig', 'Select-HtmlJSVariable', 'Select-JavaScriptDescendantNode', 'Select-JSAstNode', 'Select-JSDescendantNode', 'Set-HtmlChecked', 'Set-HtmlCookie', 'Set-HtmlHttpClientOption', 'Set-HtmlInput', 'Set-HtmlSelectOption', 'Set-HtmlStorage', 'Show-HtmlHar', 'sjsdn', 'sjsn', 'sjsv', 'Start-HtmlSession', 'Start-HtmlTracing', 'Start-HtmlVideoRecording', 'Stop-HtmlSession', 'Stop-HtmlTracing', 'Stop-HtmlVideoRecording', 'Submit-HtmlForm', 'Test-HtmlElement', 'Wait-HtmlContent', 'Wait-HtmlReady')
Export-ModuleMember -Function $FunctionsToExport -Alias $AliasesToExport -Cmdlet $CmdletsToExport